@typeonce/effect-machine 0.19.1 → 0.21.0

package/src/internal/machine/executionPlan.ts

@@ -47,7 +47,7 @@ import {
   validateDeclaredTransitionTarget
 } from "./planner.js"
 import { decodeEmitSync, decodeEventSync, decodeInputSync, decodeStateValueSync } from "./protocol.js"
-import { isInitialTarget, isNoTarget, isSnapshot, isTarget, TargetSnapshotTypeId } from "./topology.js"
+import { isInitialTarget, isNoTarget, isSnapshot, isStateUpdate, isTarget, TargetSnapshotTypeId } from "./topology.js"
 
 interface IndexedExecutionDescriptor {
   readonly flat: boolean
@@ -548,7 +548,25 @@ const collectIndexedEvaluatedTransition = (
     selection.context,
     selection.transition.evaluate
   )
-  const unresolvedTarget = transitionResult.state
+  const update = isStateUpdate(transitionResult.state)
+    ? (() => {
+      const index = descriptor.indexByPath.get(transitionResult.state.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")
+      ) {
+        throw new Error(
+          `Machine state update owner "${transitionResult.state.path}" must be an active valued compound or parallel state`
+        )
+      }
+      return {
+        path: node.path,
+        value: decodeStateValueSync(machine, node, transitionResult.state.value)
+      }
+    })()
+    : undefined
+  const unresolvedTarget = update === undefined ? transitionResult.state : undefined
   validateDeclaredTransitionTarget(
     selection.sourcePath,
     selection.trigger,
@@ -568,9 +586,14 @@ const collectIndexedEvaluatedTransition = (
     throw new Error("Machine expected indexed transition target to be a snapshot or target builder result")
   }
   const next = target === undefined
-    ? state
+    ? update === undefined ? state : (() => {
+      const next = copyOwnedIndexedState(state)
+      next.values[descriptor.indexByPath.get(update.path)!] = update.value
+      return next
+    })()
     : normalizeIndexedTargetStateSync(machine, descriptor, state, target as any, selection.leafIndex)
   const changed = selection.transition.reenter || !hasSameIndexedActive(state, next)
+  const stabilize = changed || update !== undefined
   if (!changed) {
     return {
       selection,
@@ -578,11 +601,13 @@ const collectIndexedEvaluatedTransition = (
       branchKey: transitionResult.branchKey,
       unresolvedTarget: unresolvedTarget as any,
       target: target as any,
+      update,
       next,
       commands: [...transitionResult.commands, ...(initialResolution?.commands ?? [])],
       raisedEvents: [...transitionResult.raisedEvents, ...(initialResolution?.raisedEvents ?? [])],
       emittedEvents: [...transitionResult.emittedEvents, ...(initialResolution?.emittedEvents ?? [])],
       changed: false,
+      stabilize,
       exitPaths: [],
       entryPaths: [],
       choiceTransitions: initialResolution?.transitions ?? []
@@ -603,11 +628,13 @@ const collectIndexedEvaluatedTransition = (
     branchKey: transitionResult.branchKey,
     unresolvedTarget: unresolvedTarget as any,
     target: target as any,
+    update,
     next,
     commands: [...transitionResult.commands, ...(initialResolution?.commands ?? [])],
     raisedEvents: [...transitionResult.raisedEvents, ...(initialResolution?.raisedEvents ?? [])],
     emittedEvents: [...transitionResult.emittedEvents, ...(initialResolution?.emittedEvents ?? [])],
     changed: true,
+    stabilize,
     exitPaths: getExitPaths(machine, activeConfigurationFromIndexedState(descriptor, state), boundary),
     entryPaths: getEntryPaths(machine, activeConfigurationFromIndexedState(descriptor, next), boundary),
     choiceTransitions: initialResolution?.transitions ?? []
@@ -663,6 +690,13 @@ const indexedMicrostep = (
   if (transitions.length === 1) {
     next = transitions[0]!.next
   } else {
+    for (const transition of transitions) {
+      if (transition.update !== undefined) {
+        const values = next.values.slice()
+        values[descriptor.indexByPath.get(transition.update.path)!] = transition.update.value
+        next = { ...next, values }
+      }
+    }
     const applicationOrder = [
       ...transitions.filter((transition) => !transition.changed),
       ...transitions.filter((transition) => transition.changed)

package/src/internal/machine/invocation.ts

@@ -7,7 +7,7 @@
 import * as Cause from "effect/Cause"
 import * as Effect from "effect/Effect"
 import * as Stream from "effect/Stream"
-import type { ChildMachine, Inspection, Logic, Machine } from "../../Machine.js"
+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 InvocationEvent from "./invocationEvent.js"
@@ -63,6 +63,16 @@ const streamLogic = (
 const resolveValue = (value: unknown, context: Machine.InvokeContext<any, any, any, any>): unknown =>
   typeof value === "function" ? value(context) : value
 
+const makeChildOwner = (scope: Runtime.ProcessScope<any>): ChildOwner<any> => ({
+  spawn:
+    ((descriptor: ChildMachine.Any, options?: { readonly input?: unknown }) =>
+      (scope.spawn as any)(descriptor, options)) as ChildOwner<any>["spawn"],
+  sendTo: ((descriptor: ChildMachine.Any, event: unknown) => scope.sendTo(descriptor, event)) as ChildOwner<
+    any
+  >["sendTo"],
+  stop: ((descriptor: ChildMachine.Any) => scope.stopChild(descriptor)) as ChildOwner<any>["stop"]
+})
+
 const resolveOne = (
   raw: Record<PropertyKey, any>,
   context: Machine.InvokeContext<any, any, any, any>,
@@ -291,11 +301,13 @@ export const startAll = (
   paths: ReadonlyArray<string>,
   event: Machine.LifecycleEvent<any>
 ): Effect.Effect<void, any, any> | undefined => {
+  const children = makeChildOwner(scope)
   const effects = Planner.sortEntryPaths(machine, paths)
     .filter((path) => configuration.active.has(path))
     .flatMap((path) => {
       const context = {
         ...(Configuration.getMachineReferences(configuration) ?? { self: scope.self, parent: scope.parent }),
+        children,
         state: configuration.values.get(path),
         containingState: Configuration.getParentValue(machine, configuration, path),
         ancestors: Configuration.getParentValues(machine, configuration, path),

package/src/internal/machine/machine.ts

@@ -227,6 +227,15 @@ const decorateTransitionSelection = (selection: Topology.TargetSelection): Topol
     reenter: () => makeDirectTransitionDescriptor(selection, undefined, { reenter: true })
   })
 
+const decorateStateUpdateSelection = (selection: Topology.TargetSelection): Topology.TargetSelection => {
+  const update = (
+    resolve: (context: any, enqueue: unknown) => unknown,
+    options?: unknown
+  ) => makeDirectTransitionDescriptor(selection, resolve, options)
+  Object.assign(update, selection)
+  return Object.freeze(update) as unknown as Topology.TargetSelection
+}
+
 const noneTransitionSelection = decorateTransitionSelection(Topology.noneTargetSelection)
 
 const makeInitialBuilderDescriptor = (
@@ -268,6 +277,7 @@ const decorateInitialSelectorNode = (node: unknown): unknown => {
 
 const decorateTransitionSelectorNode = (node: unknown): unknown => {
   if (Topology.isTargetSelection(node)) {
+    if (node.kind === "update") return decorateStateUpdateSelection(node)
     return node === Topology.noneTargetSelection ? noneTransitionSelection : decorateTransitionSelection(node)
   }
   if (typeof node === "function") {
@@ -363,22 +373,29 @@ const makeSelectionValue = (
   scope: Topology.TargetSelectionScope
 ): Topology.TargetSelection => Topology.makeTargetSelection(kind, path, scope)
 
+const makeStateUpdateSelection = (
+  path: string,
+  scope: "local" | "branch"
+): Topology.TargetSelection => Topology.makeTargetSelection("update", path, scope)
+
 const addSelectionChildren = (
   builder: Record<string, unknown>,
   stateNodes: Machine.StateNodes,
   parent: string,
-  scope: "local" | "branch"
+  scope: "local" | "branch",
+  source?: string
 ): void => {
   for (const node of stateNodes.byPath.values()) {
     if (node.parent !== parent || node.type === "history") continue
-    builder[node.key] = makeSelectionNode(stateNodes, node.path, scope)
+    builder[node.key] = makeSelectionNode(stateNodes, node.path, scope, source)
   }
 }
 
 const makeSelectionNode = (
   stateNodes: Machine.StateNodes,
   path: string,
-  scope: Topology.TargetSelectionScope
+  scope: Topology.TargetSelectionScope,
+  source?: string
 ): unknown => {
   const node = getTargetBuilderNode(stateNodes, path)
   const kind: Topology.TargetSelectionKind = node.type === "choice" ? "choice" : "state"
@@ -389,7 +406,17 @@ const makeSelectionNode = (
       enumerable: true
     })
     if (scope === "local" || scope === "branch") {
-      addSelectionChildren(method, stateNodes, path, scope)
+      addSelectionChildren(method, stateNodes, path, scope, source)
+    }
+    if (
+      scope === "branch" && source !== undefined && node.schema !== undefined &&
+      (source === path || source.startsWith(`${path}.`)) &&
+      getTargetBuilderNode(stateNodes, source).type !== "choice"
+    ) {
+      Object.defineProperty(method, "update", {
+        value: makeStateUpdateSelection(path, "branch"),
+        enumerable: true
+      })
     }
   }
   return method
@@ -424,13 +451,16 @@ const makeTargetSelector = (
   }
   const branch: Record<string, unknown> = {}
   const root = getTargetBuilderNode(stateNodes, source.split(".")[0]!)
-  branch[root.key] = makeSelectionNode(stateNodes, root.path, "branch")
+  branch[root.key] = makeSelectionNode(stateNodes, root.path, "branch", source)
   const local: Record<string, unknown> = {}
   const localScope = getLocalTargetScope(stateNodes, source)
   if (localScope !== undefined) {
     const localScopeNode = getTargetBuilderNode(stateNodes, localScope)
     if (localScopeNode.schema !== undefined) {
       local.with = makeSelectionValue("state", localScope, "local")
+      if (getTargetBuilderNode(stateNodes, source).type !== "choice") {
+        local.update = makeStateUpdateSelection(localScope, "local")
+      }
     }
     addSelectionChildren(local, stateNodes, localScope, "local")
   }
@@ -469,6 +499,13 @@ const getSelectionBuilder = (
   source: string
 ): unknown => {
   if (selection.kind === "none") return target.none
+  if (selection.kind === "update") {
+    return withFrom(
+      (value: unknown) => Topology.makeStateUpdate(selection.path!, value),
+      "leaf",
+      true
+    )
+  }
   let builder: any
   let parts = selection.path!.split(".")
   if (selection.kind === "history") {
@@ -514,6 +551,12 @@ const validateResolvedSelection = (
     }
     return
   }
+  if (selection.kind === "update") {
+    if (!Topology.isStateUpdate(result) || result.path !== selection.path) {
+      throw new Error(`Machine state update for "${selection.path}" must return its selected update builder`)
+    }
+    return
+  }
   if (result === undefined) return
   const resultPath = typeof result === "object" && result !== null && hasProperty(result, "path") &&
       typeof result.path === "string"
@@ -556,6 +599,9 @@ const runCapturedBranch = (
   return resolved === undefined ? constructSelectedTarget(selectedTarget) : resolved
 }
 
+const topologyTargetPath = (selection: Topology.TargetSelection): string | undefined =>
+  selection.kind === "update" ? undefined : selection.path
+
 const isArrayIndexKey = (key: string): boolean => {
   const index = Number(key)
   return Number.isInteger(index) && index >= 0 && index < 0xffff_ffff && String(index) === key
@@ -738,7 +784,9 @@ const captureTransition = (
       declinable,
       targets: [
         ...new Set(
-          branches.flatMap((branch) => branch.selection.path === undefined ? [] : [branch.selection.path])
+          branches.flatMap((branch) =>
+            topologyTargetPath(branch.selection) === undefined ? [] : [branch.selection.path!]
+          )
         )
       ],
       branches: branches.map((branch) =>
@@ -746,7 +794,7 @@ const captureTransition = (
           type: "branch" as const,
           key: branch.key,
           title: branch.title,
-          target: branch.selection.path,
+          target: topologyTargetPath(branch.selection),
           selection: transitionTargetSelection(branch.selection)
         })
       ),
@@ -763,10 +811,10 @@ const captureTransition = (
   return {
     reenter,
     declinable,
-    targets: branch.selection.path === undefined ? [] : [branch.selection.path],
+    targets: topologyTargetPath(branch.selection) === undefined ? [] : [branch.selection.path!],
     branches: [{
       type: "direct" as const,
-      target: branch.selection.path,
+      target: topologyTargetPath(branch.selection),
       selection: transitionTargetSelection(branch.selection)
     }],
     evaluate,
@@ -2124,15 +2172,30 @@ export const transition = <State, Event, Error = never, Requirements = never>(
 export const child = <const Id extends string, M extends Machine.Any>(
   id: Id,
   machine: M
+): ChildMachine<Id, M> =>
+  makeChild(id, machine, (input) =>
+    machine.input === undefined
+      ? (internalProcess.toProcessLogic as any)(machine)
+      : (internalProcess.toProcessLogic as any)(machine, input))
+
+const makeChild = <const Id extends string, M extends Machine.Any>(
+  id: Id,
+  machine: M,
+  makeLogic: (input?: unknown) => Logic<any, any, any, any, any, any>
 ): ChildMachine<Id, M> => ({
   [ChildMachineTypeId]: ChildMachineTypeId,
   id,
   machine,
-  [ChildMachineLogicTypeId]: (input) =>
+  [ChildMachineLogicTypeId]: makeLogic
+})
+
+export const childFamily = <M extends Machine.Any>(machine: M): ChildMachine.Family<M> => {
+  const makeLogic = (input?: unknown): Logic<any, any, any, any, any, any> =>
     machine.input === undefined
       ? (internalProcess.toProcessLogic as any)(machine)
       : (internalProcess.toProcessLogic as any)(machine, input)
-})
+  return (id) => makeChild(id, machine, makeLogic)
+}
 
 export const childAddress = <Event = never>(id: string): ChildAddress<Event> => id as ChildAddress<Event>
 
@@ -2174,10 +2237,7 @@ export const spawn: {
     SpawnError<Options>,
     ChildInitialError
   >
-} = ((
-  logic: Logic<any, any, any, any, any, any>,
-  options?: SpawnOptions
-) =>
+} = ((logic: Logic<any, any, any, any, any, any>, options?: SpawnOptions) =>
   Effect.flatMap(
     internalRuntime.MachineRuntime,
     (runtime) => options === undefined ? runtime.spawn(logic) : (runtime.spawn as any)(logic, options)

package/src/internal/machine/planner.ts

@@ -52,6 +52,7 @@ import {
   isInitialTarget,
   isNoTarget,
   isSnapshot,
+  isStateUpdate,
   isTarget,
   makeChoiceTarget,
   makeTarget,
@@ -78,6 +79,11 @@ export type MicrostepPlan<State, Event, E, R> = {
   readonly changed: boolean
 }
 
+type SettlingMicrostep<State, Event, E, R> = MicrostepPlan<State, Event, E, R> & {
+  /** Internal signal that eventless stabilization must run again. */
+  readonly stabilize: boolean
+}
+
 export type MacrostepPlan<State, Event, E, R, Output> =
   & {
     readonly next: State
@@ -580,10 +586,15 @@ export type EvaluatedTransition<States extends Machine.StateSchemas, Event, E, R
     | Machine.Snapshot<States>
     | Machine.Target<States, Machine.StateIdentifier<States>>
     | undefined
+  readonly update: {
+    readonly path: string
+    readonly value: unknown
+  } | undefined
   readonly commands: ReadonlyArray<RuntimeCommand>
   readonly raisedEvents: ReadonlyArray<Event>
   readonly emittedEvents: ReadonlyArray<unknown>
   readonly changed: boolean
+  readonly stabilize: boolean
   readonly exitPaths: ReadonlyArray<string>
   readonly entryPaths: ReadonlyArray<string>
   readonly choiceTransitions: ReadonlyArray<{
@@ -1143,7 +1154,9 @@ export const removeConflictingTransitions = <
     let preempted = false
     const transitionsToRemove = new Set<EvaluatedTransition<States, Event, E, R, Context>>()
     for (const selected of filtered) {
-      if (hasPathIntersection(transition.exitPaths, selected.exitPaths)) {
+      const writesSameState = transition.update !== undefined && selected.update !== undefined &&
+        transition.update.path === selected.update.path
+      if (hasPathIntersection(transition.exitPaths, selected.exitPaths) || writesSameState) {
         if (isDescendantOf(transition.selection.sourcePath, selected.selection.sourcePath)) {
           transitionsToRemove.add(selected)
         } else {
@@ -1344,6 +1357,7 @@ const collectEvaluatedTransition = <
     throw new Error("Machine transition returned decline without declaring declinable: true")
   }
   const unresolvedTarget = transitionResult.state === undefined
+      || isStateUpdate(transitionResult.state)
     ? undefined
     : transitionResult.state as
       | Machine.Snapshot<States>
@@ -1356,6 +1370,21 @@ const collectEvaluatedTransition = <
     selection.transition.targets,
     unresolvedTarget
   )
+  const update = isStateUpdate(transitionResult.state)
+    ? (() => {
+      const node = getNode(machine, transitionResult.state.path)
+      if (
+        !state.active.has(node.path) || node.schema === undefined ||
+        (node.type !== "compound" && node.type !== "parallel")
+      ) {
+        throw new Error(`Machine state update owner "${node.path}" must be an active valued compound or parallel state`)
+      }
+      return {
+        path: node.path,
+        value: decodeStateValueSync(machine, node, transitionResult.state.value)
+      }
+    })()
+    : undefined
   const choiceResolution = unresolvedTarget === undefined
     ? undefined
     : resolveChoiceTarget(
@@ -1456,7 +1485,10 @@ const collectEvaluatedTransition = <
     ? getTargetNodePath(target)
     : getTargetNodePath(unresolvedTarget)
   let stateAfterTransition = target === undefined
-    ? state
+    ? update === undefined ? state : {
+      ...state,
+      values: new Map(state.values).set(update.path, update.value)
+    }
     : normalizeTargetConfigurationSync<States>(machine, state, target)
   for (const additionalTarget of additionalChoiceTargets) {
     stateAfterTransition = normalizeTargetConfigurationSync<States>(
@@ -1466,6 +1498,7 @@ const collectEvaluatedTransition = <
     )
   }
   const changed = selection.transition.reenter || !hasSameActivePaths(state, stateAfterTransition)
+  const stabilize = changed || update !== undefined
 
   if (!changed) {
     return {
@@ -1474,6 +1507,7 @@ const collectEvaluatedTransition = <
       branchKey: transitionResult.branchKey,
       unresolvedTarget,
       target,
+      update,
       commands: [
         ...transitionResult.commands,
         ...(choiceResolution?.commands ?? []),
@@ -1496,6 +1530,7 @@ const collectEvaluatedTransition = <
         ...additionalTargetEmittedEvents
       ],
       changed,
+      stabilize,
       exitPaths: [],
       entryPaths: [],
       choiceTransitions: [
@@ -1521,6 +1556,7 @@ const collectEvaluatedTransition = <
     branchKey: transitionResult.branchKey,
     unresolvedTarget,
     target,
+    update,
     commands: [
       ...transitionResult.commands,
       ...(choiceResolution?.commands ?? []),
@@ -1543,6 +1579,7 @@ const collectEvaluatedTransition = <
       ...additionalTargetEmittedEvents
     ],
     changed,
+    stabilize,
     exitPaths: reenteredHistoryTarget !== undefined
       ? sortExitPaths(
         machine,
@@ -1744,7 +1781,8 @@ export const planInitialSync = <
       emittedEvents: [...choiceResolution.emittedEvents, ...initialHistoryEmittedEvents],
       exitPaths: [],
       entryPaths: [],
-      changed: false
+      changed: false,
+      stabilize: false
     }]
   )
 
@@ -1850,7 +1888,8 @@ const microstep = <
       emittedEvents: [],
       exitPaths: [],
       entryPaths: [],
-      changed: false
+      changed: false,
+      stabilize: false
     }
   }
 
@@ -1881,6 +1920,17 @@ const microstep = <
     ...transition.choiceTransitions
   ])
   let stateAfterTransition = state
+  // Updates never reactivate topology. Apply every retained value write to the
+  // original active configuration before any control target becomes
+  // authoritative.
+  for (const transition of sortedTransitions) {
+    if (transition.update !== undefined) {
+      stateAfterTransition = {
+        ...stateAfterTransition,
+        values: new Map(stateAfterTransition.values).set(transition.update.path, transition.update.value)
+      }
+    }
+  }
   // Value-only targets are evaluated against the original configuration. If
   // one is applied after a control-changing transition, it can resurrect a
   // branch that the changing transition exited. Apply value-only updates
@@ -1901,6 +1951,7 @@ const microstep = <
   }
 
   const changed = transitions.some((transition) => transition.changed)
+  const stabilize = transitions.some((transition) => transition.stabilize)
   const transitionActions = sortedTransitions
     .flatMap((transition) => transition.commands)
   const transitionRaisedEvents = sortedTransitions
@@ -1918,7 +1969,8 @@ const microstep = <
       emittedEvents: transitionEmittedEvents,
       exitPaths: [],
       entryPaths: [],
-      changed: false
+      changed: false,
+      stabilize
     }
   }
 
@@ -1951,7 +2003,8 @@ const microstep = <
     emittedEvents: [...exit.emittedEvents, ...transitionEmittedEvents, ...entry.emittedEvents],
     exitPaths,
     entryPaths,
-    changed: true
+    changed: true,
+    stabilize
   }
 }
 
@@ -1974,7 +2027,7 @@ const settle = <
   commands: Array<RuntimeCommand>,
   raisedEvents: Array<Machine.EventOf<Events>>,
   emittedEvents: Array<unknown>,
-  microsteps: Array<MicrostepPlan<ActiveConfiguration, Machine.EventOf<Events>, E, R>>
+  microsteps: Array<SettlingMicrostep<ActiveConfiguration, Machine.EventOf<Events>, E, R>>
 ) => {
   let currentState = state
   let currentEvent = event
@@ -2010,7 +2063,7 @@ const settle = <
       pendingCompletions.length === 0 ? [] : [pendingCompletions.shift()!]
     )
     if (done.length > 0) {
-      const doneStep: MicrostepPlan<ActiveConfiguration, Machine.EventOf<Events>, E, R> = microstep(
+      const doneStep: SettlingMicrostep<ActiveConfiguration, Machine.EventOf<Events>, E, R> = microstep(
         machine,
         currentState,
         currentEvent,
@@ -2021,7 +2074,7 @@ const settle = <
       emittedEvents.push(...doneStep.emittedEvents)
       microsteps.push(doneStep)
       currentState = doneStep.next
-      shouldRunAlways = doneStep.changed
+      shouldRunAlways = doneStep.stabilize
       continue
     }
     if (isActiveFinalConfiguration(machine, currentState)) {
@@ -2038,7 +2091,7 @@ const settle = <
       ? selectAlwaysTransitions<States, Events, Emits, E, R>(machine, currentState, currentEvent)
       : []
     if (always.length > 0) {
-      const alwaysStep: MicrostepPlan<ActiveConfiguration, Machine.EventOf<Events>, E, R> = microstep(
+      const alwaysStep: SettlingMicrostep<ActiveConfiguration, Machine.EventOf<Events>, E, R> = microstep(
         machine,
         currentState,
         currentEvent,
@@ -2049,7 +2102,7 @@ const settle = <
       emittedEvents.push(...alwaysStep.emittedEvents)
       microsteps.push(alwaysStep)
       currentState = alwaysStep.next
-      shouldRunAlways = alwaysStep.changed
+      shouldRunAlways = alwaysStep.stabilize
       continue
     }
 

package/src/internal/machine/runtime.ts

@@ -18,9 +18,10 @@ import * as Scope from "effect/Scope"
 import * as Stream from "effect/Stream"
 import * as SynchronizedRef from "effect/SynchronizedRef"
 import type * as Take from "effect/Take"
-import type { Inspection, Machine as MachineDefinition, MachineTarget } from "../../Machine.js"
+import type { ChildMachine, Inspection, Machine as MachineDefinition, MachineTarget } from "../../Machine.js"
 import { ChildAlreadyExistsError, StoppedError } from "./errors.js"
 import * as InspectionRuntime from "./inspectionRuntime.js"
+import { ChildMachineLogicTypeId } from "./symbols.js"
 
 type ChildDescriptor = {
   readonly id: string
@@ -376,7 +377,7 @@ const sendMachineTarget = (
 export interface ProcessScope<Event> {
   readonly self: ProcessAddress<Event>
   readonly parent: ProcessAddress<unknown> | undefined
-  readonly spawn: ProcessSpawn
+  readonly spawn: ProcessSpawn<Event>
   readonly sendParent: (event: unknown) => Effect.Effect<void, StoppedError>
   readonly emit: (event: unknown) => Effect.Effect<void>
   readonly sendTo: {
@@ -552,7 +553,15 @@ export interface ProcessLogic<
   run(context: ProcessContext<State, Event>): Effect.Effect<Output, Error, Requirements>
 }
 
-export interface ProcessSpawn {
+export interface ProcessSpawn<OwnerEvent = unknown> {
+  <const Child extends ChildMachine.Any>(
+    child: Child & ChildMachine.Executable<Child> & ChildMachine.ParentCompatibility<Child, OwnerEvent>,
+    ...options: ChildMachine.SpawnArgs<Child>
+  ): Effect.Effect<
+    ChildMachine.Ref<Child>,
+    ChildAlreadyExistsError | ChildMachine.StartError<Child>,
+    ChildMachine.StartRequirements<Child>
+  >
   <ChildState, ChildEvent, ChildError, ChildRequirements, ChildOutput, ChildInitialError = never>(
     logic: ProcessLogic<ChildState, ChildEvent, ChildError, ChildRequirements, ChildOutput, ChildInitialError>
   ): Effect.Effect<
@@ -1207,6 +1216,14 @@ const makeChildRuntimeSync = (
     })
   }
 
+  function spawn<const Child extends ChildMachine.Any>(
+    child: Child & ChildMachine.Executable<Child> & ChildMachine.ParentCompatibility<Child, unknown>,
+    ...options: ChildMachine.SpawnArgs<Child>
+  ): Effect.Effect<
+    ChildMachine.Ref<Child>,
+    ChildAlreadyExistsError | ChildMachine.StartError<Child>,
+    ChildMachine.StartRequirements<Child>
+  >
   function spawn<ChildState, ChildEvent, ChildError, ChildRequirements, ChildOutput, ChildInitialError = never>(
     logic: ProcessLogic<ChildState, ChildEvent, ChildError, ChildRequirements, ChildOutput, ChildInitialError>
   ): Effect.Effect<
@@ -1232,32 +1249,44 @@ const makeChildRuntimeSync = (
     ChildAlreadyExistsError | ChildInitialError,
     Exclude<ChildRequirements, Scope.Scope>
   >
-  function spawn<ChildState, ChildEvent, ChildError, ChildRequirements, ChildOutput, ChildInitialError = never>(
-    logic: ProcessLogic<ChildState, ChildEvent, ChildError, ChildRequirements, ChildOutput, ChildInitialError>,
-    spawnOptions?: {
+  function spawn(
+    logicOrChild: ProcessLogic<any, any, any, any, any, any> | ChildMachine.Any,
+    options?: {
       readonly id: string
       readonly descriptor?: ChildDescriptor
       readonly onOutcome?: (
-        outcome: RuntimeOutcome<ChildState, ChildError, ChildOutput>
+        outcome: RuntimeOutcome<any, any, any>
       ) => Effect.Effect<void>
       readonly [activeSnapshotObserver]?: (
-        snapshot: Extract<RuntimeSnapshot<ChildState, ChildError, ChildOutput>, { readonly status: "active" }>
+        snapshot: Extract<RuntimeSnapshot<any, any, any>, { readonly status: "active" }>
       ) => Effect.Effect<void>
       readonly [sendParentOverride]?: (event: unknown) => Effect.Effect<void, StoppedError>
-    }
-  ): Effect.Effect<
-    MachineRef<ChildState, ChildEvent, ChildError, ChildOutput>,
-    ChildAlreadyExistsError | ChildInitialError,
-    Exclude<ChildRequirements, Scope.Scope>
-  > {
+    } | { readonly input?: unknown }
+  ): Effect.Effect<MachineRef<any, any, any, any>, any, any> {
+    const descriptor = typeof logicOrChild === "object" && logicOrChild !== null &&
+        ChildMachineLogicTypeId in logicOrChild
+      ? logicOrChild as ChildMachine.Any
+      : undefined
+    const logic = descriptor === undefined
+      ? logicOrChild as ProcessLogic<any, any, any, any, any, any>
+      : descriptor[ChildMachineLogicTypeId](
+        (options as { readonly input?: unknown } | undefined)?.input
+      ) as unknown as ProcessLogic<any, any, any, any, any, any>
+    const spawnOptions = descriptor === undefined
+      ? options as {
+        readonly id: string
+        readonly descriptor?: ChildDescriptor
+        readonly onOutcome?: (outcome: RuntimeOutcome<any, any, any>) => Effect.Effect<void>
+        readonly [activeSnapshotObserver]?: (
+          snapshot: Extract<RuntimeSnapshot<any, any, any>, { readonly status: "active" }>
+        ) => Effect.Effect<void>
+        readonly [sendParentOverride]?: (event: unknown) => Effect.Effect<void, StoppedError>
+      } | undefined
+      : { id: descriptor.id, descriptor }
     const token = Symbol()
     const key = spawnOptions?.id ?? token
     let startedChild: MachineRef<any, any, any, any> | undefined
-    return Effect.suspend((): Effect.Effect<
-      MachineRef<ChildState, ChildEvent, ChildError, ChildOutput>,
-      ChildAlreadyExistsError | ChildInitialError,
-      Exclude<ChildRequirements, Scope.Scope>
-    > => {
+    return Effect.suspend(() => {
       if (registry.closed) {
         return Effect.interrupt
       }