@typeonce/effect-machine 0.31.1 → 0.32.0

package/src/internal/machine/atom.ts

@@ -18,6 +18,7 @@ import type * as Machine from "../../Machine.js"
 import type { Bound, ChildMachineAtom, MachineAtom } from "../../unstable/reactivity/AtomMachine.js"
 import * as internalMachine from "./machine.js"
 import type { EnsureExecutable } from "./readiness.js"
+import type { ExcludeCompatibleRuntime as ExcludeCompatibleMachineRuntime, IsAny } from "./requirements.js"
 import * as Topology from "./topology.js"
 
 export class NotReadyError extends Data.TaggedError("NotReadyError") {}
@@ -36,15 +37,6 @@ type EnsureNoExternalRequirements<Requirements> = [ExternalRequirements<Requirem
   readonly [ExternalRequirementsTypeId]: ExternalRequirements<Requirements>
 }
 
-type IsAny<A> = 0 extends (1 & A) ? true : false
-
-type ExcludeCompatibleMachineRuntime<Requirements, Events, Emits> = Requirements extends
-  Machine.Runtime.Requirement<infer RequiredEvents, infer RequiredEmits> ?
-  IsAny<Requirements> extends true ? Requirements
-  : [RequiredEvents] extends [Events] ? [RequiredEmits] extends [Emits] ? never : Requirements
-  : Requirements
-  : Requirements
-
 type MachineRequirements<InitialR, R, Events, Emits> = ExcludeCompatibleMachineRuntime<
   Machine.ExecutionServices<InitialR | R>,
   Events,
@@ -391,7 +383,6 @@ const makeChildFromRefAtom = <Child extends Machine.ChildMachine.Any, StartError
   return {
     ref,
     snapshot,
-    state: Atom.mapResult(snapshot, Option.map((snapshot) => snapshot.state)),
     result: makeChildRuntimeResultAtom(snapshot),
     send,
     stop,
@@ -504,7 +495,6 @@ const makeFromRefAtom = <State, Event, Error, Output, StartError, Emitted>(
   const result = {
     ref,
     snapshot,
-    state: Atom.mapResult(snapshot, (snapshot) => snapshot.state),
     result: makeRuntimeResultAtom(snapshot),
     send,
     stop,
@@ -775,7 +765,7 @@ export const can = (event: unknown) => {
 type MachineResumeRequirementsOf<M extends Machine.Machine.Any> = MachineResumeRequirements<
   Machine.Machine.Services<M>,
   Machine.Machine.Event<M>,
-  Machine.Machine.Emit<M>
+  Machine.Machine.EmittedEvent<M>
 >
 
 type EnsureMachineExecutable<M extends Machine.Machine.Any> = IsAny<Machine.Machine.States<M>> extends true ? {
@@ -835,7 +825,7 @@ export const make: {
           InitialR,
           R,
           Machine.Machine.EventOf<Events>,
-          Machine.Machine.EmitOf<Emits>
+          Machine.Machine.EmittedEventOf<Emits>
         >
       >
       & EnsureExecutable<States, UnhandledStates, OutputStates>

package/src/internal/machine/childRegistry.ts

@@ -0,0 +1,141 @@
+/** Owns child reservations and ordered observer buffers for one local runtime. */
+import * as Deferred from "effect/Deferred"
+import * as Effect from "effect/Effect"
+import * as Option from "effect/Option"
+import type * as Scope from "effect/Scope"
+import type { MachineRef } from "./runtime.js"
+
+export type ChildDescriptor = {
+  readonly id: string
+  readonly machine: object
+}
+
+export type ChildEntry =
+  | {
+    readonly _tag: "Starting"
+    readonly token: symbol
+    readonly ownerKey?: string
+    readonly ownerPath?: string
+    ownerActive?: boolean
+  }
+  | {
+    readonly _tag: "Started"
+    readonly token: symbol
+    readonly descriptor: ChildDescriptor | undefined
+    readonly ref: MachineRef<any, any, any, any>
+    readonly ownerKey?: string
+    readonly ownerPath?: string
+    ownerActive?: boolean
+  }
+
+export type ChildSelector = string | ChildDescriptor
+export type ChildKey = string | symbol
+
+type ChildObservation = Option.Option<MachineRef<any, any, any, any>>
+type ChildObservationBatch = [ChildObservation, ...Array<ChildObservation>]
+
+export interface ChildObserver {
+  readonly child: ChildSelector
+  readonly id: string
+  values: ChildObservationBatch | undefined
+  waiter: Deferred.Deferred<void> | undefined
+}
+
+export const offerChildObservation = (
+  observer: ChildObserver,
+  value: ChildObservation
+): void => {
+  if (observer.values === undefined) {
+    observer.values = [value]
+  } else {
+    observer.values.push(value)
+  }
+  if (observer.waiter !== undefined) {
+    const waiter = observer.waiter
+    observer.waiter = undefined
+    Deferred.doneUnsafe(waiter, Effect.void)
+  }
+}
+
+export const takeChildObservations = (
+  observer: ChildObserver
+): Effect.Effect<ChildObservationBatch> =>
+  Effect.suspend(() => {
+    if (observer.values !== undefined) {
+      const values = observer.values
+      observer.values = undefined
+      return Effect.succeed(values)
+    }
+    const waiter = Deferred.makeUnsafe<void>()
+    observer.waiter = waiter
+    return Deferred.await(waiter).pipe(Effect.andThen(takeChildObservations(observer)))
+  })
+
+export interface ChildRegistry {
+  closed: boolean
+  readonly children: Map<ChildKey, ChildEntry>
+  observers: Set<ChildObserver> | undefined
+  scope: Scope.Closeable | undefined
+}
+
+export const matchesChild = (
+  entry: ChildEntry,
+  child: ChildSelector
+): entry is Extract<ChildEntry, { readonly _tag: "Started" }> =>
+  entry._tag === "Started" && (typeof child === "string" || (
+    entry.descriptor !== undefined &&
+    entry.descriptor.id === child.id &&
+    entry.descriptor.machine === child.machine
+  ))
+
+export const selectRegistryChild = (
+  registry: ChildRegistry,
+  id: string,
+  child: ChildSelector
+): ChildObservation => {
+  if (registry.closed) return Option.none()
+  const entry = registry.children.get(id)
+  return entry !== undefined && matchesChild(entry, child) ? Option.some(entry.ref) : Option.none()
+}
+
+export const publishRegistryChange = (registry: ChildRegistry): void => {
+  if (registry.observers === undefined) return
+  for (const observer of registry.observers) {
+    offerChildObservation(observer, selectRegistryChild(registry, observer.id, observer.child))
+  }
+}
+
+export const unregisterChild = (registry: ChildRegistry, key: ChildKey, token: symbol): void => {
+  const entry = registry.children.get(key)
+  if (entry === undefined || entry.token !== token) return
+  registry.children.delete(key)
+  if (typeof key === "string") publishRegistryChange(registry)
+}
+
+export const registerChild = (
+  registry: ChildRegistry,
+  key: ChildKey,
+  token: symbol,
+  ref: MachineRef<any, any, any, any>,
+  descriptor: ChildDescriptor | undefined
+): boolean => {
+  const entry = registry.children.get(key)
+  if (registry.closed || entry === undefined || entry._tag !== "Starting" || entry.token !== token) {
+    return false
+  }
+  registry.children.delete(key)
+  const started: ChildEntry = entry.ownerKey === undefined
+    ? { _tag: "Started", token, descriptor, ref }
+    : {
+      _tag: "Started",
+      token,
+      descriptor,
+      ref,
+      ownerKey: entry.ownerKey,
+      ownerPath: entry.ownerPath!,
+      ownerActive: entry.ownerActive === true
+    }
+  registry.children.set(key, started)
+  if (typeof key === "string") publishRegistryChange(registry)
+  return true
+}

package/src/internal/machine/cluster.ts

@@ -16,6 +16,7 @@ import type { Checkpoint, ClusterMachine, LoadResult } from "../../unstable/clus
 import * as internalMachine from "./machine.js"
 import * as Protocol from "./protocol.js"
 import type { EnsureExecutable } from "./readiness.js"
+import type { ExcludeCompatibleRuntime } from "./requirements.js"
 
 type EntityAddress = EntityAddress.EntityAddress
 type PersistenceError = ClusterError.PersistenceError
@@ -97,17 +98,7 @@ type SendRpc<Events extends ReadonlyArray<Machine.Machine.TaggedSchema>> = Rpc.R
 
 type MachineEvents<M extends Machine.Machine.Any> = Machine.Machine.InputEvents<M>
 
-type MachineEmits<M extends Machine.Machine.Any> = Machine.Machine.Emits<M>
-
-type IsAny<A> = 0 extends (1 & A) ? true : false
-
-type ExcludeCompatibleRuntime<Requirements, Events, Emits> = Requirements extends Machine.Runtime.Requirement<
-  infer RequiredEvents,
-  infer RequiredEmits
-> ? IsAny<Requirements> extends true ? Requirements
-  : [RequiredEvents] extends [Events] ? [RequiredEmits] extends [Emits] ? never : Requirements
-  : Requirements
-  : Requirements
+type MachineEmits<M extends Machine.Machine.Any> = Machine.Machine.EmittedEvents<M>
 
 const hasInvokes = (machine: Machine.Machine.Any): boolean =>
   Reflect.ownKeys(machine.handlers).some((key) => machine.handlers[key as string]?.invoke !== undefined)
@@ -234,7 +225,7 @@ export const make = <
   | ExcludeCompatibleRuntime<
     Machine.ExecutionServices<R | InitialR>,
     Machine.Machine.EventOf<Events>,
-    Machine.Machine.EmitOf<Emits>
+    Machine.Machine.EmittedEventOf<Emits>
   >
   | Machine.Machine.SnapshotDecodingServices<States>
   | Machine.Machine.SnapshotEncodingServices<States>
@@ -270,7 +261,7 @@ export const make = <
     | ExcludeCompatibleRuntime<
       Machine.ExecutionServices<R | InitialR>,
       Machine.Machine.EventOf<Events>,
-      Machine.Machine.EmitOf<Emits>
+      Machine.Machine.EmittedEventOf<Emits>
     >
     | Machine.Machine.SnapshotDecodingServices<States>
     | Machine.Machine.SnapshotEncodingServices<States>
@@ -292,7 +283,7 @@ export const make = <
             Effect.mapError((error) => reject("PersistenceFailure", String(error.cause)))
           )
           let current: Machine.Machine.Snapshot<States> | undefined
-          const emitted: Array<Machine.Machine.EmitOf<MachineEmits<M>>> = []
+          const emitted: Array<Machine.Machine.EmittedEventOf<MachineEmits<M>>> = []
 
           if (Option.isSome(loaded.checkpoint)) {
             const checkpoint = loaded.checkpoint.value

package/src/internal/machine/configuration.ts

@@ -292,7 +292,8 @@ const pathToRootCache = new WeakMap<Machine.StateNodes, Map<string, ReadonlyArra
 
 export const hasOwn = (u: object, key: string): boolean => Object.prototype.hasOwnProperty.call(u, key)
 
-export const isDescendantOf = (path: string, ancestor: string): boolean => path.startsWith(`${ancestor}.`)
+export const isDescendantOf = (path: string, ancestor: string): boolean =>
+  path !== ancestor && (ancestor === "" || path.startsWith(`${ancestor}.`))
 
 export const isPathInSubtree = (path: string, ancestor: string): boolean =>
   path === ancestor || isDescendantOf(path, ancestor)
@@ -642,6 +643,14 @@ export const normalizeConfigurationEffect = <const States extends Machine.StateS
 ): Effect.Effect<ActiveConfiguration, MachineSchemaDecodeError> =>
   configurationFromSnapshotEffect(machine, state).pipe(
     Effect.catchCause((cause) => {
+      if (Cause.hasInterrupts(cause)) {
+        return Effect.failCause(Cause.map(cause, (error) =>
+          error instanceof MachineSchemaDecodeError ? error : new MachineSchemaDecodeError({
+            machineId: machine.id,
+            boundary: "configuration",
+            cause: Cause.fail(error)
+          })))
+      }
       const error = Cause.findErrorOption(cause)
       return Option.isSome(error) && error.value instanceof MachineSchemaDecodeError
         ? Effect.fail(error.value)
@@ -1160,7 +1169,10 @@ export const isActiveFinalNode = (
   const node = getNode(machine, path)
   if (node.type === "compound") {
     const child = getActiveChildPath(machine, configuration, path)
-    return child !== undefined && isDirectFinalPath(machine, child)
+    return child !== undefined &&
+      (path === ""
+        ? !hasCompletionHandler(machine, child) && isActiveFinalNode(machine, configuration, child)
+        : isDirectFinalPath(machine, child))
   }
   if (node.type === "parallel") {
     for (const child of node.children) {
@@ -1261,7 +1273,9 @@ export const completeActiveFinalNodeEffect: <
   const node = getNode(machine, path)
   if (node.type === "compound") {
     const child = getActiveChildPath(machine, configuration, path)
-    if (child === undefined || !isDirectFinalPath(machine, child)) {
+    if (
+      child === undefined || (path === "" ? hasCompletionHandler(machine, child) : !isDirectFinalPath(machine, child))
+    ) {
       return undefined
     }
     const childCompletion = yield* completeActiveFinalNodeEffect(
@@ -1395,7 +1409,9 @@ const completeActiveFinalNodeSync = <const Events extends ReadonlyArray<Machine.
   const node = getNode(machine, path)
   if (node.type === "compound") {
     const child = getActiveChildPath(machine, configuration, path)
-    if (child === undefined || !isDirectFinalPath(machine, child)) return undefined
+    if (
+      child === undefined || (path === "" ? hasCompletionHandler(machine, child) : !isDirectFinalPath(machine, child))
+    ) return undefined
     const childCompletion = completeActiveFinalNodeSync(machine, configuration, child, event, outputs, completions)
     if (childCompletion === undefined) return undefined
     const completion = setCompletedOutput(outputs, path, childCompletion.output)

package/src/internal/machine/executionPlan.ts

@@ -59,6 +59,8 @@ import {
 
 interface IndexedExecutionDescriptor {
   readonly flat: boolean
+  /** Distinguishes structural nodes from valued slots, including decoded undefined. */
+  readonly valued: ReadonlyArray<boolean>
   readonly nodes: ReadonlyArray<Machine.StateNode>
   readonly indexByPath: ReadonlyMap<string, number>
   readonly parentIndices: ReadonlyArray<number>
@@ -140,12 +142,6 @@ const compileIndexedExecutionDescriptor = (
     if (node.type === "choice" || node.type === "history") {
       return undefined
     }
-    // Structural active states deliberately use the generic semantic
-    // reference until the indexed value table represents absent values as an
-    // explicit capability rather than an `undefined` slot.
-    if (node.schema === undefined) {
-      return undefined
-    }
     if (node.type === "atomic" || node.type === "final") {
       leafPaths.push(node.path)
     }
@@ -210,7 +206,20 @@ const compileIndexedExecutionDescriptor = (
     dispatchByLeaf.set(leafIndex, dispatch)
   }
   return {
-    flat: nodes.every((node) => node.parent === undefined && (node.type === "atomic" || node.type === "final")),
+    valued: Object.freeze(nodes.map((node) => node.schema !== undefined)),
+    // A structural root with direct leaves has the same event kernel as an
+    // atomic root. Root behavior and targets that can rebuild the root retain
+    // the hierarchical planner so their entry and exit boundaries stay explicit.
+    flat: nodes.every((node) => node.parent === undefined && (node.type === "atomic" || node.type === "final")) || (
+      nodes[0]?.path === "" && nodes[0].type === "compound" && nodes[0].schema === undefined &&
+      (machine.handlers[""] === undefined || Reflect.ownKeys(machine.handlers[""]).length === 0) &&
+      nodes.slice(1).every((node) => node.parent === "" && (node.type === "atomic" || node.type === "final")) &&
+      [...transitionsByPath.values()].every((events) =>
+        [...events.values()].every((transition) =>
+          transition.targets !== undefined && transition.targets.every((path) => path !== "")
+        )
+      )
+    ),
     nodes,
     indexByPath,
     parentIndices,
@@ -276,7 +285,7 @@ const ownedIndexedStateFromActive = (
     const index = descriptor.indexByPath.get(path)
     if (index === undefined) throw new Error(`Machine expected indexed active path "${path}"`)
     active[index] = 1
-    values[index] = configuration.values.get(path)
+    if (descriptor.valued[index]) values[index] = configuration.values.get(path)
   }
   for (const [path, output] of configuration.outputs) {
     const index = descriptor.indexByPath.get(path)
@@ -306,7 +315,7 @@ const activeConfigurationFromIndexedState = (
     if (configuration.active[index] !== 1) continue
     const path = descriptor.nodes[index]!.path
     active.add(path)
-    values.set(path, configuration.values[index])
+    if (descriptor.valued[index]) values.set(path, configuration.values[index])
   }
   for (const index of configuration.completedOrder) {
     if (configuration.completed[index] === 1) {
@@ -324,7 +333,7 @@ const snapshotFromIndexedStateStatePath = (
   const node = descriptor.nodes[index]!
   const snapshot: Record<string, unknown> = {
     path: node.path,
-    value: configuration.values[index]
+    value: descriptor.valued[index] ? configuration.values[index] : undefined
   }
   if (node.type === "compound") {
     const childIndex = descriptor.childIndices[index]!.find((childIndex) => configuration.active[childIndex] === 1)
@@ -383,7 +392,9 @@ const makeIndexedTransitionContext = (
   const parentIndex = descriptor.parentIndices[sourceIndex]!
   const ancestors: Record<string, unknown> = {}
   for (const ancestorIndex of descriptor.ancestorIndices[sourceIndex]!) {
-    ancestors[descriptor.nodes[ancestorIndex]!.path] = configuration.values[ancestorIndex]
+    if (descriptor.valued[ancestorIndex]) {
+      ancestors[descriptor.nodes[ancestorIndex]!.path] = configuration.values[ancestorIndex]
+    }
   }
   return {
     ...resolveMachineReferences(machine, machineReferences),
@@ -426,6 +437,7 @@ export interface ExecutionMicrostep<State = unknown> {
 }
 
 export interface ExecutionMacrostep<State = unknown> {
+  readonly event: unknown
   readonly next: State
   readonly commands: ReadonlyArray<RuntimeCommand>
   readonly emittedEvents: ReadonlyArray<unknown>
@@ -564,11 +576,10 @@ const collectIndexedEvaluatedTransition = (
       const index = descriptor.indexByPath.get(stateUpdate.path)
       const node = index === undefined ? undefined : descriptor.nodes[index]
       if (
-        index === undefined || node === undefined || state.active[index] !== 1 || node.schema === undefined ||
-        (node.type !== "compound" && node.type !== "parallel")
+        index === undefined || node === undefined || state.active[index] !== 1 || node.schema === undefined
       ) {
         throw new Error(
-          `Machine state update owner "${stateUpdate.path}" must be an active valued compound or parallel state`
+          `Machine state update owner "${stateUpdate.path}" must be an active valued state`
         )
       }
       return {
@@ -794,6 +805,7 @@ const planIndexedFlatState = (
         throw new Error("Machine reached a terminal indexed configuration without a completed root output")
       }
       return {
+        event: decoded,
         next: ownedIndexedStateFromActive(descriptor, completed),
         commands: commands ?? emptyExecutionValues,
         emittedEvents: emittedEvents ?? emptyExecutionValues,
@@ -820,7 +832,15 @@ const planIndexedFlatState = (
         },
         transition.evaluate
       )
-      const target = transitionResult.state
+      const update = isStateUpdate(transitionResult.state) ? transitionResult.state : undefined
+      const target = update === undefined ? transitionResult.state : undefined
+      if (update !== undefined) {
+        const node = descriptor.nodes[sourceIndex]!
+        if (update.path !== sourcePath || node.schema === undefined) {
+          throw new Error(`Machine state update owner "${update.path}" must be the active valued state`)
+        }
+        updateOwnedIndexedValue(current, sourceIndex, decodeStateValueSync(machine, node, update.value))
+      }
       validateDeclaredTransitionTarget(
         sourcePath,
         { type: "event", event: event._tag },
@@ -871,7 +891,7 @@ const planIndexedFlatState = (
               branchKey: transitionResult.branchKey,
               target: target === undefined ? undefined : getTargetNodePath(target as any),
               resolvedTarget: target === undefined ? undefined : getTargetNodePath(target as any),
-              updates: []
+              updates: update === undefined ? [] : [update.path]
             }]
           }
           : undefined),
@@ -901,6 +921,7 @@ const planIndexedFlatState = (
     const raised = raisedEvents?.[raisedIndex]
     if (raised === undefined) {
       return {
+        event: decoded,
         next: current,
         commands: commands ?? emptyExecutionValues,
         emittedEvents: emittedEvents ?? emptyExecutionValues,
@@ -935,6 +956,7 @@ const planIndexedState = (
       input
     )
     return {
+      event: planned.event,
       next: ownedIndexedStateFromActive(descriptor, planned.next),
       commands: planned.commands,
       emittedEvents: planned.emittedEvents,
@@ -966,6 +988,7 @@ const planIndexedState = (
         throw new Error("Machine reached a terminal indexed configuration without a completed root output")
       }
       return {
+        event: decoded,
         next: ownedIndexedStateFromActive(descriptor, completed),
         commands: [],
         emittedEvents: [],
@@ -979,6 +1002,7 @@ const planIndexedState = (
   const selections = selectIndexedEventTransitions(machine, descriptor, configuration, decoded, machineReferences)
   if (selections.length === 0) {
     return {
+      event: decoded,
       next: configuration,
       commands: [],
       emittedEvents: [],
@@ -1021,6 +1045,7 @@ const planIndexedState = (
           throw new Error("Machine reached a terminal indexed configuration without a completed root output")
         }
         return {
+          event: decoded,
           next: current,
           commands,
           emittedEvents,
@@ -1034,6 +1059,7 @@ const planIndexedState = (
     const raised = raisedEvents[raisedIndex]
     if (raised === undefined) {
       return {
+        event: decoded,
         next: current,
         commands,
         emittedEvents,
@@ -1103,43 +1129,74 @@ const makeIndexedExecutionPlan = (
   snapshot: (state) => snapshotFromIndexedState(indexed, state as OwnedIndexedState),
   plan: (state, event, retainMicrosteps = false, machineReferences) =>
     planIndexedState(machine, indexed, state as OwnedIndexedState, event, retainMicrosteps, machineReferences),
-  initial: (args, machineReferences) => {
-    const inputArgs = machine.input === undefined
-      ? args
-      : args.length === 0
-      ? (decodeInputSync(machine, machine.input, undefined), args)
-      : [decodeInputSync(machine, machine.input, args[0])]
-    const initial = machine.initial(...inputArgs as any)
-    const normalized = normalizeConfigurationSync(machine, initial as Machine.Snapshot<any>)
-    const active = machineReferences === undefined ? normalized : withMachineReferences(normalized, machineReferences)
-    validateInitialConfiguration(machine, active)
-    const completed = completeConfigurationSync(machine, active, InitialEvent).configuration
-    const configuration = ownedIndexedStateFromActive(indexed, completed)
-    const state = snapshotFromIndexedState(indexed, configuration)
-    const done = isActiveFinalConfiguration(machine, completed)
-    if (!done) {
-      return {
-        state,
-        configuration,
-        activeConfiguration: completed,
-        initialEntryPaths: getInitialEntryPaths(machine, completed),
-        done: false,
-        output: undefined
+  // Initializers may enqueue commands and emissions. Managed startup owns that
+  // work through the generic initial planner; indexed event execution remains valid.
+  ...(Object.values(machine.handlers as Record<string, Machine.AnyStateConfig>).some((config) =>
+      "initialize" in config
+    ) ?
+    {} :
+    {
+      initial: (args: ReadonlyArray<unknown>, machineReferences?: PlanningMachineReferences) => {
+        const inputArgs = machine.input === undefined
+          ? args
+          : args.length === 0
+          ? (decodeInputSync(machine, machine.input, undefined), args)
+          : [decodeInputSync(machine, machine.input, args[0])]
+        const initial = machine.initial(...inputArgs as any)
+        const resolved = isInitialTarget(initial)
+          ? resolveInitialTarget(
+            machine,
+            {
+              active: new Set(),
+              values: new Map(),
+              outputs: new Map(),
+              history: new Map(),
+              ...(machineReferences === undefined ? {} : { machineReferences })
+            },
+            initial,
+            InitialEvent
+          ).target
+          : initial
+        const normalized = isInitialTarget(initial)
+          ? normalizeTargetConfigurationSync(machine, {
+            active: new Set(),
+            values: new Map(),
+            outputs: new Map(),
+            history: new Map()
+          }, resolved)
+          : normalizeConfigurationSync(machine, resolved as Machine.Snapshot<any>)
+        const active = machineReferences === undefined
+          ? normalized
+          : withMachineReferences(normalized, machineReferences)
+        if (machine.initialDefinition.selection.kind === "initial") validateInitialConfiguration(machine, active)
+        const completed = completeConfigurationSync(machine, active, InitialEvent).configuration
+        const configuration = ownedIndexedStateFromActive(indexed, completed)
+        const state = snapshotFromIndexedState(indexed, configuration)
+        const done = isActiveFinalConfiguration(machine, completed)
+        if (!done) {
+          return {
+            state,
+            configuration,
+            activeConfiguration: completed,
+            initialEntryPaths: getInitialEntryPaths(machine, completed),
+            done: false,
+            output: undefined
+          }
+        }
+        const root = getRootPath(machine, completed)
+        if (!completed.outputs.has(root)) {
+          throw new Error("Machine reached a terminal configuration without a completed root output")
+        }
+        return {
+          state,
+          configuration,
+          activeConfiguration: completed,
+          initialEntryPaths: getInitialEntryPaths(machine, completed),
+          done: true,
+          output: completed.outputs.get(root)
+        }
       }
-    }
-    const root = getRootPath(machine, completed)
-    if (!completed.outputs.has(root)) {
-      throw new Error("Machine reached a terminal configuration without a completed root output")
-    }
-    return {
-      state,
-      configuration,
-      activeConfiguration: completed,
-      initialEntryPaths: getInitialEntryPaths(machine, completed),
-      done: true,
-      output: completed.outputs.get(root)
-    }
-  }
+    })
 })
 
 export type ExecutionPlanStrategy = "generic" | "indexed-flat" | "indexed-hierarchical" | "auto"

package/src/internal/machine/invocation.ts

@@ -10,6 +10,7 @@ import * as Stream from "effect/Stream"
 import type { ChildMachine, ChildOwner, Inspection, Logic, Machine } from "../../Machine.js"
 import * as Configuration from "./configuration.js"
 import { InfiniteTransitionError, MachineSchemaDecodeError, StoppedError } from "./errors.js"
+import * as InvocationDefinition from "./invocationDefinition.js"
 import * as InvocationEvent from "./invocationEvent.js"
 import * as Planner from "./planner.js"
 import * as Runtime from "./runtime.js"
@@ -74,7 +75,7 @@ const makeChildOwner = (scope: Runtime.ProcessScope<any>): ChildOwner<any> => ({
 })
 
 const resolveOne = (
-  raw: Record<PropertyKey, any>,
+  raw: InvocationDefinition.InvocationDefinition,
   context: Machine.InvokeContext<any, any, any, any>,
   path: string
 ): AnyConfig => {
@@ -134,7 +135,7 @@ const resolveOne = (
     }
   }
   if ("child" in raw) {
-    const descriptor = raw.child as ChildMachine.Any
+    const descriptor = raw.child
     return {
       id: descriptor.id,
       address: descriptor.id,
@@ -148,7 +149,8 @@ const resolveOne = (
       onSnapshot: raw.onSnapshot
     }
   }
-  throw new Error("Machine invoke must define exactly one of effect, stream, after, logic, or child")
+  const unsupported: never = raw
+  throw new Error(`Unsupported captured machine invocation: ${String(unsupported)}`)
 }
 
 /** @internal */
@@ -266,12 +268,12 @@ const startStaticChild = (
   scope: Runtime.ProcessScope<any>,
   ownedChildren: Runtime.OwnedChildRuntime,
   path: string,
-  raw: Record<PropertyKey, any>
+  raw: Extract<InvocationDefinition.InvocationDefinition, { readonly child: ChildMachine.Any }>
 ): Effect.Effect<void, any, any> => {
   // A zero-input child has no entry-context dependency. Reuse the descriptor's
   // source function so each running parent does not retain a resolved config
   // object and an otherwise redundant source closure.
-  const descriptor = raw.child as ChildMachine.Any
+  const descriptor = raw.child
   return startResolved(
     scope,
     ownedChildren,
@@ -313,7 +315,9 @@ export const startAll = (
         ancestors: Configuration.getParentValues(machine, configuration, path),
         event
       }
-      return InvocationEvent.definitions(Configuration.getStateConfigByPath(machine, path)?.invoke).map((definition) =>
+      return InvocationDefinition.definitions(Configuration.getStateConfigByPath(machine, path)?.invoke).map((
+        definition
+      ) =>
         "child" in definition && !("input" in definition)
           ? startStaticChild(scope, ownedChildren, path, definition)
           : start(scope, ownedChildren, path, resolveOne(definition, context, path))