Fix initial choice state decoding

.changeset/tidy-choices-decode.md

@@ -0,0 +1,7 @@
+---
+"@typeonce/effect-machine": patch
+---
+
+Fix initial choice resolvers so schema-backed `containingState` and `ancestors` are decoded before the choice runs.
+
+This makes `.from(...)` state construction behave the same for transient initial choices as it does for ordinary active-state entry.

packages/effect-machine/src/internal/machine/planner.ts

@@ -1277,15 +1277,19 @@ function resolveChoiceTarget(
       if (choice === undefined || typeof choice.transition !== "function") {
         throw new Error(`Machine choice state "${node.path}" requires an implementation`)
       }
+      const provisionalValues = new Map(configuration.values)
+      for (const [path, value] of Object.entries(extracted.values)) {
+        const valueNode = getNode(machine, path)
+        if (valueNode.schema !== undefined) {
+          provisionalValues.set(path, decodeStateValueSync(machine, valueNode, value))
+        }
+      }
       const provisional: ActiveConfiguration = {
         active: new Set([
           ...configuration.active,
           ...Object.keys(extracted.values)
         ]),
-        values: new Map([
-          ...configuration.values,
-          ...Object.entries(extracted.values)
-        ]),
+        values: provisionalValues,
         outputs: configuration.outputs,
         history: configuration.history,
         ...(configuration.machineReferences === undefined ? {} : { machineReferences: configuration.machineReferences })

packages/effect-machine/test/internal/machine/strategyDifferential.test.ts

@@ -879,6 +879,99 @@ describe("machine planner and runtime strategies", () => {
       assert.deepStrictEqual(results[1], results[0])
     }) as Effect.Effect<void, unknown, any>)
 
+  it.effect("matches initial choice invoke and retry lifecycles across managed runtimes", () =>
+    Effect.gen(function*() {
+      class Flow extends Schema.TaggedClass<Flow>("StrategyChoiceFlow")("StrategyChoiceFlow", {
+        authenticated: Schema.Boolean
+      }) {}
+      class Retry extends Schema.TaggedClass<Retry>("StrategyChoiceRetry")("StrategyChoiceRetry", {}) {}
+      const states = Machine.states({
+        Flow: {
+          schema: Flow,
+          initial: "Routing",
+          states: {
+            Routing: { type: "choice" },
+            Checking: {},
+            Failed: {},
+            Plans: {},
+            MemberNavigating: {}
+          }
+        }
+      })
+      const waitForPath = (ref: Machine.MachineRef<any, any, any, any>, path: string) =>
+        Effect.gen(function*() {
+          for (let index = 0; index < 100; index += 1) {
+            if ((yield* ref.state).state.path === path) return
+            yield* Effect.yieldNow
+          }
+          return assert.fail(`machine did not reach ${path}`)
+        })
+      const results: Array<unknown> = []
+
+      for (const strategy of ["generic", "compiled"] as const) {
+        let membershipAttempts = 0
+        let navigationRuns = 0
+        const machine = Machine.make({
+          states: states.states,
+          events: Machine.events(Retry),
+          input: Schema.Struct({ authenticated: Schema.Boolean }),
+          initial: (to) => to.Flow.initial.resolve(({ input, target }) => target.from(input, (flow) => flow.Routing()))
+        }).handle({
+          Flow: {
+            states: {
+              Routing: {
+                choice: (to) =>
+                  to.branches({
+                    authenticated: { target: to.local.Checking() },
+                    anonymous: { target: to.local.Plans() }
+                  }).resolve(({ containingState, select }) =>
+                    containingState.authenticated ? select.authenticated.from() : select.anonymous.from()
+                  )
+              },
+              Checking: {
+                invoke: (from) =>
+                  from.effect("membership", () =>
+                    Effect.suspend(() => {
+                      membershipAttempts += 1
+                      return membershipAttempts === 1 ? Effect.fail("offline") : Effect.succeed("active")
+                    })).onDone((to) => to.local.MemberNavigating()).onFailure((to) => to.local.Failed())
+              },
+              Failed: {
+                on: {
+                  StrategyChoiceRetry: (to) => to.local.Checking()
+                }
+              },
+              MemberNavigating: {
+                invoke: (from) =>
+                  from.effect("navigate", () =>
+                    Effect.sync(() => {
+                      navigationRuns += 1
+                    }).pipe(Effect.andThen(Effect.never)))
+              }
+            }
+          }
+        })
+
+        assert.strictEqual(ExecutionPlan.selectExecutionPlanForTesting(machine, "auto").strategy, "generic")
+        const ref = yield* openWithRuntimeStrategy(machine, strategy, { authenticated: true })
+        yield* waitForPath(ref, "Flow.Failed")
+        yield* ref.send(new Retry({}))
+        yield* waitForPath(ref, "Flow.MemberNavigating")
+        for (let index = 0; index < 5; index += 1) yield* Effect.yieldNow
+        results.push({
+          membershipAttempts,
+          navigationRuns,
+          path: (yield* ref.state).state.path
+        })
+        yield* ref.stop
+      }
+
+      assert.deepStrictEqual(results, [
+        { membershipAttempts: 2, navigationRuns: 1, path: "Flow.MemberNavigating" },
+        { membershipAttempts: 2, navigationRuns: 1, path: "Flow.MemberNavigating" }
+      ])
+    }) as Effect.Effect<void, unknown, any>)
+
   it.effect("matches generic and indexed invoke failure traces", () =>
     Effect.gen(function*() {
       class Loading extends Schema.TaggedClass<Loading>("StrategyInvokeFailureLoading")("Loading", {}) {}

packages/effect-machine/test/internal/machine/support/strategyDifferential.ts

@@ -113,9 +113,10 @@ export const verifyPlannerStrategies: (options: {
 
 export const openWithRuntimeStrategy = (
   machine: Machine.Machine.Any,
-  strategy: "generic" | "compiled"
+  strategy: "generic" | "compiled",
+  ...args: ReadonlyArray<unknown>
 ): Effect.Effect<Machine.MachineRef<any, any, any, any>, unknown> =>
-  Process.startWithRuntimeStrategyForTesting(machine, strategy) as any
+  Process.startWithRuntimeStrategyForTesting(machine, strategy, ...args) as any
 
 export const prepareWithRuntimeStrategy = (
   machine: Machine.Machine.Any,

packages/effect-machine/test/machine/Choice.test.ts

@@ -129,6 +129,73 @@ describe("Machine choice pseudo-states", () => {
       ])
     }))
 
+  it.effect("decodes initial state constructions before resolving a choice", () =>
+    Effect.gen(function*() {
+      class Root extends Schema.TaggedClass<Root>("ChoiceInputRoot")("ChoiceInputRoot", {
+        enabled: Schema.Boolean
+      }) {}
+      class NestedFlow extends Schema.TaggedClass<NestedFlow>("ChoiceInputFlow")("ChoiceInputFlow", {
+        score: Schema.Number
+      }) {}
+      const states = Machine.states({
+        Root: {
+          schema: Root,
+          initial: "Flow",
+          states: {
+            Flow: {
+              schema: NestedFlow,
+              initial: "Routing",
+              states: {
+                Routing: { type: "choice" },
+                Approved,
+                Rejected
+              }
+            }
+          }
+        }
+      })
+      let observedContext: { readonly enabled: boolean; readonly score: number } | undefined
+      const inputChoice = Machine.make({
+        states: states.states,
+        events: Machine.events(),
+        input: Schema.Struct({ enabled: Schema.Boolean, score: Schema.Number }),
+        initial: (to) =>
+          to.Root.initial.resolve(({ input, target }) =>
+            target.from({ enabled: input.enabled }, (root) =>
+              root.Flow.from({ score: input.score }, (flow) => flow.Routing()))
+          )
+      }).handle({
+        Root: {
+          states: {
+            Flow: {
+              states: {
+                Routing: {
+                  choice: (to) =>
+                    to.branches({
+                      approved: { target: to.local.Approved() },
+                      rejected: { target: to.local.Rejected() }
+                    }).resolve(({ ancestors, containingState, select }) => {
+                      observedContext = {
+                        enabled: ancestors.Root.enabled,
+                        score: containingState.score
+                      }
+                      return ancestors.Root.enabled && containingState.score >= 70
+                        ? select.approved.decoded(new Approved({}))
+                        : select.rejected.decoded(new Rejected({}))
+                    })
+                }
+              }
+            }
+          }
+        }
+      })
+
+      const plan = yield* Machine.planInitial(inputChoice, { enabled: true, score: 80 })
+      assert.deepStrictEqual(observedContext, { enabled: true, score: 80 })
+      assert.strictEqual(plan.state.state.state.path, "Root.Flow.Approved")
+      assert.strictEqual(plan.microsteps[0]?.transitions[0]?.branchKey, "approved")
+    }))
+
   it.effect("targets a choice from an event and preserves that event", () =>
     Effect.gen(function*() {
       const initial = yield* Machine.planInitial(machine)