@typeonce/effect-machine 0.9.0 → 0.11.0

package/src/internal/machine/machine.ts

@@ -86,7 +86,8 @@ interface DefineStates {
   ): Machine.DefinedStates<States>
   <const States extends Machine.StateSchemas>(states: InvalidDefinedStateTreeInput<States>): never
 }
-type ValidateInputEventProtocol<InputEvents extends ReadonlyArray<Machine.TaggedSchema>> = InputEvents
+type ValidateInputEventProtocol<InputEvents extends ReadonlyArray<Machine.TaggedSchema>> = InputEvents extends
+  ReadonlyArray<Machine.TaggedSchema> ? unknown : never
 type ValidateInternalEventProtocol<
   InputEvents extends ReadonlyArray<Machine.TaggedSchema>,
   InternalEvents extends ReadonlyArray<Machine.TaggedSchema>
@@ -103,6 +104,8 @@ const Proto = {
   }
 }
 
+const makeBoundInvoke = (config: unknown): unknown => config
+
 const cloneWithHandlers = (
   self: Machine.Any,
   handlers: Machine.StateConfigs<any, any, any, any, any, any, any>
@@ -111,7 +114,8 @@ const cloneWithHandlers = (
   machine.states = self.states
   machine.events = self.events
   machine.internalEvents = self.internalEvents
-  machine.emits = self.emits
+  machine.emittedEvents = self.emittedEvents
+  machine.parentEvents = self.parentEvents
   machine.input = self.input
   machine.id = self.id
   machine.initial = self.initial
@@ -119,6 +123,7 @@ const cloneWithHandlers = (
   machine.makeTargetBuilder = self.makeTargetBuilder
   machine.handlers = handlers
   machine.handle = makeHandle(machine)
+  machine.invoke = makeBoundInvoke
   Protocol.copyProtocol(self, machine)
   return machine
 }
@@ -726,6 +731,7 @@ const makeTargetBuilder = <const States extends Machine.StateSchemas>(
   const history = makeHistoryTargetBuilder(states, "") as Machine.HistoryTargetBuilder<States>
   return <Source extends Machine.StateNodeIdentifier<States>>(source: Source): Machine.TargetBuilder<States, Source> =>
     ({
+      none: Topology.makeNoTarget,
       local: makeLocalTargetBuilder(states, stateNodes, source),
       branch: makeBranchTargetBuilder(states, stateNodes, source),
       full,
@@ -765,18 +771,22 @@ type MakeConfig<
   Input extends Schema.Top,
   InitialE,
   InitialR,
-  InternalEvents extends ReadonlyArray<Machine.TaggedSchema>
+  InternalEvents extends ReadonlyArray<Machine.TaggedSchema>,
+  ParentEvents extends ReadonlyArray<Machine.TaggedSchema>
 > = {
   readonly id?: string
   readonly states: States & DefineStateTreeInput<NoInfer<States>>
-  readonly events: InputEvents & ValidateInputEventProtocol<NoInfer<InputEvents>>
+  readonly events:
+    & Machine.EventProtocol<"public", InputEvents>
+    & ValidateInputEventProtocol<NoInfer<InputEvents>>
   readonly internalEvents?:
-    & InternalEvents
+    & Machine.EventProtocol<"internal", InternalEvents>
     & ValidateInternalEventProtocol<
       NoInfer<InputEvents>,
       NoInfer<InternalEvents>
     >
-  readonly emits?: Emits
+  readonly emittedEvents?: Machine.EventProtocol<"emitted", Emits>
+  readonly parentEvents?: Machine.EventProtocol<"public", ParentEvents>
   readonly input?: Input
   readonly initial: (...args: [...Machine.InputArgs<Input>]) => Machine.InitialResult<States, InitialE, InitialR>
 }
@@ -788,7 +798,8 @@ type MakeResult<
   Input extends Schema.Top,
   InitialE,
   InitialR,
-  InternalEvents extends ReadonlyArray<Machine.TaggedSchema>
+  InternalEvents extends ReadonlyArray<Machine.TaggedSchema>,
+  ParentEvents extends ReadonlyArray<Machine.TaggedSchema>
 > = Machine<
   States,
   readonly [...InputEvents, ...InternalEvents],
@@ -802,7 +813,8 @@ type MakeResult<
   Machine.TerminalOutput<States>,
   Emits,
   never,
-  InputEvents
+  InputEvents,
+  ParentEvents
 >
 
 interface Make {
@@ -813,11 +825,12 @@ interface Make {
     const Input extends Schema.Top = typeof Schema.Void,
     InitialE = never,
     InitialR = never,
-    const InternalEvents extends ReadonlyArray<Machine.TaggedSchema> = readonly []
+    const InternalEvents extends ReadonlyArray<Machine.TaggedSchema> = readonly [],
+    const ParentEvents extends ReadonlyArray<Machine.TaggedSchema> = readonly []
   >(
-    config: MakeConfig<States, InputEvents, Emits, Input, InitialE, InitialR, InternalEvents>,
+    config: MakeConfig<States, InputEvents, Emits, Input, InitialE, InitialR, InternalEvents, ParentEvents>,
     ..._validation: ValidateDefinedStates<NoInfer<States>>
-  ): MakeResult<States, InputEvents, Emits, Input, InitialE, InitialR, InternalEvents>
+  ): MakeResult<States, InputEvents, Emits, Input, InitialE, InitialR, InternalEvents, ParentEvents>
   <
     const States extends Machine.StateSchemas,
     const InputEvents extends ReadonlyArray<Machine.TaggedSchema>,
@@ -825,10 +838,11 @@ interface Make {
     const Input extends Schema.Top = typeof Schema.Void,
     InitialE = never,
     InitialR = never,
-    const InternalEvents extends ReadonlyArray<Machine.TaggedSchema> = readonly []
+    const InternalEvents extends ReadonlyArray<Machine.TaggedSchema> = readonly [],
+    const ParentEvents extends ReadonlyArray<Machine.TaggedSchema> = readonly []
   >(
     config:
-      & Omit<MakeConfig<States, InputEvents, Emits, Input, InitialE, InitialR, InternalEvents>, "states">
+      & Omit<MakeConfig<States, InputEvents, Emits, Input, InitialE, InitialR, InternalEvents, ParentEvents>, "states">
       & { readonly states: InvalidDefinedStateTreeInput<States> }
   ): never
 }
@@ -840,24 +854,27 @@ export const make: Make = (<
   const Input extends Schema.Top = typeof Schema.Void,
   InitialE = never,
   InitialR = never,
-  const InternalEvents extends ReadonlyArray<Machine.TaggedSchema> = readonly []
+  const InternalEvents extends ReadonlyArray<Machine.TaggedSchema> = readonly [],
+  const ParentEvents extends ReadonlyArray<Machine.TaggedSchema> = readonly []
 >(
   config: {
     readonly id?: string
     readonly states: States
-    readonly events: InputEvents
-    readonly internalEvents?: InternalEvents
-    readonly emits?: Emits
+    readonly events: Machine.EventProtocol<"public", InputEvents>
+    readonly internalEvents?: Machine.EventProtocol<"internal", InternalEvents>
+    readonly emittedEvents?: Machine.EventProtocol<"emitted", Emits>
+    readonly parentEvents?: Machine.EventProtocol<"public", ParentEvents>
     readonly input?: Input
     readonly initial: (...args: [...Machine.InputArgs<Input>]) => Machine.InitialResult<States, InitialE, InitialR>
   }
-): MakeResult<States, InputEvents, Emits, Input, InitialE, InitialR, InternalEvents> => {
+): MakeResult<States, InputEvents, Emits, Input, InitialE, InitialR, InternalEvents, ParentEvents> => {
   StateDefinition.validateStateDefinitions(config.states, "Machine.make")
   const self = Object.create(Proto)
   self.states = config.states
   self.events = config.events
-  self.internalEvents = config.internalEvents ?? []
-  self.emits = config.emits ?? []
+  self.internalEvents = config.internalEvents ?? Protocol.makeEventProtocol("internal", [] as const)
+  self.emittedEvents = config.emittedEvents ?? Protocol.makeEventProtocol("emitted", [] as const)
+  self.parentEvents = config.parentEvents ?? Protocol.makeEventProtocol("public", [] as const)
   self.input = config.input
   self.id = config.id
   self.initial = config.initial
@@ -865,32 +882,44 @@ export const make: Make = (<
   self.makeTargetBuilder = makeTargetBuilder(config.states, self.stateNodes)
   self.handlers = Object.create(null)
   self.handle = makeHandle(self)
+  self.invoke = makeBoundInvoke
   Protocol.setProtocol(self)
   return self
 }) as Make
 
-type EventConstructorArgs<EventSchema extends Machine.TaggedSchema> = {} extends EventSchema["~type.make.in"] ?
-  [input?: EventSchema["~type.make.in"]]
-  : [input: EventSchema["~type.make.in"]]
+const flattenEventProtocolInputs = <Kind extends Machine.EventProtocolKind>(
+  kind: Kind,
+  inputs: ReadonlyArray<Machine.EventProtocolInput<Kind>>
+): ReadonlyArray<Machine.TaggedSchema> =>
+  inputs.flatMap((input) =>
+    Protocol.isEventProtocol(input, kind)
+      ? Protocol.eventProtocolSchemas(input)
+      : [input as Machine.TaggedSchema]
+  )
 
-export const event = <
-  const M extends Machine.Any,
-  const EventSchema extends Machine.TaggedSchema
->(
-  machine: M,
-  schema: EventSchema & ([EventSchema["Type"]] extends [Machine.Event<M>] ? unknown : never),
-  ...args: EventConstructorArgs<EventSchema>
-): EventSchema["Type"] => Protocol.makeEvent(machine, schema, args.length === 0 ? {} : args[0])
+export const events = <const Inputs extends ReadonlyArray<Machine.EventProtocolInput<"public">>>(
+  ...inputs: Inputs
+): Machine.EventProtocol<"public", Machine.EventProtocolInputSchemasOf<"public", Inputs>> =>
+  Protocol.makeEventProtocol(
+    "public",
+    flattenEventProtocolInputs("public", inputs)
+  ) as Machine.EventProtocol<"public", Machine.EventProtocolInputSchemasOf<"public", Inputs>>
 
-export const events = <M extends Machine.Any>(
-  machine: M
-): Machine.EventConstructors<Machine.InputEvents<M>> =>
-  Protocol.eventConstructors(machine.events) as Machine.EventConstructors<Machine.InputEvents<M>>
+export const internalEvents = <const Inputs extends ReadonlyArray<Machine.EventProtocolInput<"internal">>>(
+  ...inputs: Inputs
+): Machine.EventProtocol<"internal", Machine.EventProtocolInputSchemasOf<"internal", Inputs>> =>
+  Protocol.makeEventProtocol(
+    "internal",
+    flattenEventProtocolInputs("internal", inputs)
+  ) as Machine.EventProtocol<"internal", Machine.EventProtocolInputSchemasOf<"internal", Inputs>>
 
-export const internalEvents = <M extends Machine.Any>(
-  machine: M
-): Machine.EventConstructors<Machine.InternalEvents<M>> =>
-  Protocol.eventConstructors(machine.internalEvents) as Machine.EventConstructors<Machine.InternalEvents<M>>
+export const emittedEvents = <const Inputs extends ReadonlyArray<Machine.EventProtocolInput<"emitted">>>(
+  ...inputs: Inputs
+): Machine.EventProtocol<"emitted", Machine.EventProtocolInputSchemasOf<"emitted", Inputs>> =>
+  Protocol.makeEventProtocol(
+    "emitted",
+    flattenEventProtocolInputs("emitted", inputs)
+  ) as Machine.EventProtocol<"emitted", Machine.EventProtocolInputSchemasOf<"emitted", Inputs>>
 
 export const encodeSnapshot: <
   const States extends Machine.StateSchemas,
@@ -966,14 +995,6 @@ export const decodeSnapshot: <
   Machine.SnapshotDecodingServices<States>
 > = Serialization.decodeSnapshot as any
 
-export const retag = (
-  target: Machine.TaggedSchema,
-  source: { readonly _tag: PropertyKey },
-  patch?: unknown
-): any => {
-  const { _tag: _, ...fields } = source
-  return target.make({ ...fields, ...((patch ?? {}) as object) } as never)
-}
 export const planInitial: <
   const States extends Machine.StateSchemas,
   const Events extends ReadonlyArray<Machine.TaggedSchema>,
@@ -1341,6 +1362,8 @@ export const watch = <State, Event, Error = never, Output = never>(
   ref: MachineRef<State, Event, Error, Output>
 ): Stream.Stream<RuntimeOutcome<State, Error, Output>> => internalRuntime.watch(ref)
 
+export const prepare = internalProcess.prepare
+
 export const start: <
   const States extends Machine.StateSchemas,
   const Events extends ReadonlyArray<Machine.TaggedSchema>,
@@ -1383,7 +1406,8 @@ export const start: <
     | InfiniteTransitionError
     | MachineSchemaDecodeError
     | StoppedError,
-    Output
+    Output,
+    Machine.EmittedEventOf<Emits>
   >,
   | InitialE
   | E
@@ -1441,7 +1465,8 @@ export const resume: <
     | InfiniteTransitionError
     | MachineSchemaDecodeError
     | StoppedError,
-    Output
+    Output,
+    Machine.EmittedEventOf<Emits>
   >,
   MachineSchemaDecodeError,
   ExcludeCompatibleRuntime<

package/src/internal/machine/planner.ts

@@ -7,7 +7,7 @@
 import * as Cause from "effect/Cause"
 import * as Effect from "effect/Effect"
 import type * as Schema from "effect/Schema"
-import type { Enqueue, InitialEvent as MachineInitialEvent, Machine } from "../../Machine.js"
+import type { ActorContext, ActorRef, Enqueue, InitialEvent as MachineInitialEvent, Machine } from "../../Machine.js"
 import { getTargetBuilder, makeCollector, type RuntimeCommand } from "./command.js"
 import {
   type ActiveConfiguration,
@@ -37,7 +37,7 @@ import {
   snapshotFromConfigurationAtPath,
   validateInitialConfiguration
 } from "./configuration.js"
-import { InfiniteTransitionError, MachineSchemaDecodeError, StartupError } from "./errors.js"
+import { InfiniteTransitionError, MachineSchemaDecodeError, StartupError, StoppedError } from "./errors.js"
 import * as InvocationEvent from "./invocationEvent.js"
 import { decodeEventSync, decodeInputSync, decodeStateValueSync } from "./protocol.js"
 import { InitialEventTypeId } from "./symbols.js"
@@ -45,6 +45,7 @@ import {
   getNode,
   isChoiceTarget,
   isHistoryTarget,
+  isNoTarget,
   isSnapshot,
   isTarget,
   makeChoiceTarget,
@@ -93,6 +94,38 @@ export type TransitionHandler<States extends Machine.StateSchemas, E, R, Context
   enqueue: Enqueue<any, any>
 ) => Machine.HandlerResult<States, E, R>
 
+const rootActorScopes = new WeakMap<Machine.Any, ActorContext<any, any>>()
+const machineActorScopes = new WeakMap<Machine.Any, ActorContext<any, any>>()
+
+export const withActorScope = (
+  machine: Machine.Any,
+  actorScope: ActorContext<any, any>
+): Machine.Any => {
+  const scoped = Object.create(machine) as Machine.Any
+  machineActorScopes.set(scoped, { self: actorScope.self, parent: actorScope.parent })
+  return scoped
+}
+
+const getActorContext = (
+  machine: Machine.Any,
+  configuration: ActiveConfiguration
+): ActorContext<any, any> => {
+  const scope = configuration.actorScope
+  if (scope !== undefined) return scope
+  const machineScope = machineActorScopes.get(machine)
+  if (machineScope !== undefined) return machineScope
+  const cached = rootActorScopes.get(machine)
+  if (cached !== undefined) return cached
+  const self: ActorRef<unknown> = {
+    id: machine.id ?? "Machine",
+    sessionId: "Machine.plan",
+    send: () => Effect.fail(new StoppedError())
+  }
+  const root = { self, parent: undefined }
+  rootActorScopes.set(machine, root)
+  return root
+}
+
 type EventTransition<States extends Machine.StateSchemas, E, R, Context> =
   | TransitionHandler<States, E, R, Context>
   | {
@@ -155,9 +188,9 @@ const collectTransition = <
   context: Context
 ) => {
   const collected = makeCollector<Event>(machine)
-  const state = transition(context, collected.enqueue)
+  const result = transition(context, collected.enqueue)
   return {
-    state,
+    state: isNoTarget(result) ? undefined : result,
     commands: collected.commands,
     raisedEvents: collected.raisedEvents,
     emittedEvents: collected.emittedEvents
@@ -206,7 +239,8 @@ const completeHistoryConfiguration = (
           active,
           values,
           outputs: configuration.outputs,
-          history: configuration.history
+          history: configuration.history,
+          actorScope: configuration.actorScope
         } as ActiveConfiguration
         active.add(child.path)
         if (child.schema !== undefined) {
@@ -215,9 +249,10 @@ const completeHistoryConfiguration = (
             throw new Error(`Machine shallow history requires an initial value implementation for state "${path}"`)
           }
           const initialized = collectStateInitializer(machine, initializer, {
+            ...getActorContext(machine, current),
             state: current.values.get(path),
-            parent: getParentValue(machine, current, path),
-            parents: getParentValues(machine, current, path),
+            containingState: getParentValue(machine, current, path),
+            ancestors: getParentValues(machine, current, path),
             event
           })
           values.set(child.path, decodeStateValueSync(machine, child, initialized.value))
@@ -235,16 +270,18 @@ const completeHistoryConfiguration = (
             active,
             values,
             outputs: configuration.outputs,
-            history: configuration.history
+            history: configuration.history,
+            actorScope: configuration.actorScope
           } as ActiveConfiguration
           const initializer = valuedMissing.length === 0 ? undefined : machine.handlers[path]?.initial
           if (valuedMissing.length > 0 && initializer === undefined) {
             throw new Error(`Machine shallow history requires an initial value implementation for state "${path}"`)
           }
           const initialized = initializer === undefined ? undefined : collectStateInitializer(machine, initializer, {
+            ...getActorContext(machine, current),
             state: current.values.get(path),
-            parent: getParentValue(machine, current, path),
-            parents: getParentValues(machine, current, path),
+            containingState: getParentValue(machine, current, path),
+            ancestors: getParentValues(machine, current, path),
             event
           })
           if (initialized !== undefined && (typeof initialized.value !== "object" || initialized.value === null)) {
@@ -328,7 +365,7 @@ const resolveHistoryTarget = (
   const collected = collectTransition(machine, fallback, {
     event,
     target: getTargetBuilder(machine, target.parent).full,
-    parent: target.parent
+    owner: target.parent
   })
   if (collected.state === undefined || isHistoryTarget(collected.state) || !isSnapshot(collected.state)) {
     throw new Error(`Machine history default for "${target.path}" must return a complete snapshot containing its owner`)
@@ -505,9 +542,10 @@ const makeStateActionContext = <
   path: string,
   event: Machine.LifecycleEvent<Events>
 ): Machine.StateActionContext<States, Events, Emits, StateId> => ({
+  ...getActorContext(machine, configuration),
   state: configuration.values.get(path) as Machine.StateByIdentifier<States, StateId>,
-  parent: getParentValue(machine, configuration, path) as Machine.ParentStateValue<States, StateId>,
-  parents: getParentValues(machine, configuration, path) as Machine.ParentStateValues<States, StateId>,
+  containingState: getParentValue(machine, configuration, path) as Machine.ParentStateValue<States, StateId>,
+  ancestors: getParentValues(machine, configuration, path) as Machine.ParentStateValues<States, StateId>,
   event
 })
 
@@ -524,9 +562,10 @@ const makeTransitionContext = <
   event: Machine.EventByTag<Events, EventTag>,
   snapshot: Machine.Snapshot<States>
 ): Machine.HandlerContext<States, Events, Emits, StateId, EventTag, any, any> => ({
+  ...getActorContext(machine, configuration),
   state: configuration.values.get(path) as Machine.StateByIdentifier<States, StateId>,
-  parent: getParentValue(machine, configuration, path) as Machine.ParentStateValue<States, StateId>,
-  parents: getParentValues(machine, configuration, path) as Machine.ParentStateValues<States, StateId>,
+  containingState: getParentValue(machine, configuration, path) as Machine.ParentStateValue<States, StateId>,
+  ancestors: getParentValues(machine, configuration, path) as Machine.ParentStateValues<States, StateId>,
   event,
   snapshot,
   target: getTargetBuilder(machine, path)
@@ -545,9 +584,10 @@ const makeDoneContext = <
   output: unknown,
   snapshot: Machine.Snapshot<States>
 ): Machine.DoneContext<States, Events, Emits, StateId> => ({
+  ...getActorContext(machine, configuration),
   state: configuration.values.get(path) as Machine.StateByIdentifier<States, StateId>,
-  parent: getParentValue(machine, configuration, path) as Machine.ParentStateValue<States, StateId>,
-  parents: getParentValues(machine, configuration, path) as Machine.ParentStateValues<States, StateId>,
+  containingState: getParentValue(machine, configuration, path) as Machine.ParentStateValue<States, StateId>,
+  ancestors: getParentValues(machine, configuration, path) as Machine.ParentStateValues<States, StateId>,
   event,
   output: output as Machine.CompletionOutputByIdentifier<States, StateId>,
   snapshot,
@@ -639,15 +679,16 @@ const selectAlwaysTransitions = <
               Machine.AlwaysContext<States, Events, Emits, Machine.StateIdentifier<States>>
             >,
             context: {
+              ...getActorContext(machine, configuration),
               state: configuration.values.get(path) as Machine.StateByIdentifier<
                 States,
                 Machine.StateIdentifier<States>
               >,
-              parent: getParentValue(machine, configuration, path) as Machine.ParentStateValue<
+              containingState: getParentValue(machine, configuration, path) as Machine.ParentStateValue<
                 States,
                 Machine.StateIdentifier<States>
               >,
-              parents: getParentValues(machine, configuration, path) as Machine.ParentStateValues<
+              ancestors: getParentValues(machine, configuration, path) as Machine.ParentStateValues<
                 States,
                 Machine.StateIdentifier<States>
               >,
@@ -826,9 +867,10 @@ const selectInvocationTransition = <
   if (transition === undefined) return []
   const snapshot = snapshotFromConfiguration<States>(machine, configuration)
   const context = {
+    ...getActorContext(machine, configuration),
     state: configuration.values.get(event.path),
-    parent: getParentValue(machine, configuration, event.path),
-    parents: getParentValues(machine, configuration, event.path),
+    containingState: getParentValue(machine, configuration, event.path),
+    ancestors: getParentValues(machine, configuration, event.path),
     snapshot,
     target: getTargetBuilder(machine, event.path),
     id: event.id,
@@ -1064,11 +1106,13 @@ const resolveChoiceTarget = (
           ...Object.entries(extracted.values)
         ]),
         outputs: configuration.outputs,
-        history: configuration.history
+        history: configuration.history,
+        ...(configuration.actorScope === undefined ? {} : { actorScope: configuration.actorScope })
       }
       const collected = collectTransition(machine, choice.transition, {
-        parent: getParentValue(machine, provisional, node.path),
-        parents: getParentValues(machine, provisional, node.path),
+        ...getActorContext(machine, provisional),
+        containingState: getParentValue(machine, provisional, node.path),
+        ancestors: getParentValues(machine, provisional, node.path),
         event,
         target: getTargetBuilder(machine, node.path)
       })

package/src/internal/machine/process.ts

@@ -131,7 +131,8 @@ const makeChildlessCompiledDrain = (
         planned = executionPlan.plan(
           configuration ?? executionPlan.fromConfiguration(Configuration.normalizeConfigurationSync(machine, current)),
           event,
-          acknowledged
+          acknowledged,
+          context.scope
         )
       } catch (error) {
         return error instanceof InfiniteTransitionError || error instanceof MachineSchemaDecodeError
@@ -255,7 +256,8 @@ const makeInvokingCompiledDrain = (
           configuration ??
             executionPlan.fromConfiguration(Configuration.normalizeConfigurationSync(machine, current)),
           event,
-          acknowledged
+          acknowledged,
+          scope
         )
       } catch (error) {
         return error instanceof InfiniteTransitionError || error instanceof MachineSchemaDecodeError
@@ -426,9 +428,11 @@ const makeProcessLogic: <
   const executionPlan = ExecutionPlan.compileExecutionPlan(machine)
   const initialArgs = entry._tag === "Initial" ? entry.args : []
   const compiledInitial = entry._tag === "Initial" ? executionPlan.initial : undefined
-  const makeCompiledInitial = compiledInitial === undefined ? undefined : () => {
+  const makeCompiledInitial = compiledInitial === undefined ? undefined : (
+    scope: internalRuntime.ProcessScope<Machine.EventOf<Events>>
+  ) => {
     try {
-      const planned = compiledInitial(initialArgs)
+      const planned = compiledInitial(initialArgs, scope)
       const result = {
         state: planned.state as Machine.Snapshot<States>,
         done: planned.done,
@@ -455,7 +459,7 @@ const makeProcessLogic: <
   ) =>
     compiledInitial === undefined
       ? internalRuntime.provideMachineRuntime(
-        internalPlanner.planInitial(machine, ...initialArgs).pipe(
+        internalPlanner.planInitial(internalPlanner.withActorScope(machine, scope), ...initialArgs).pipe(
           Effect.flatMap((planned) => {
             const commands = planned.commands.length === 0
               ? undefined
@@ -480,7 +484,7 @@ const makeProcessLogic: <
         ),
         scope
       )
-      : Effect.try({ try: makeCompiledInitial!, catch: (error) => error as any })
+      : Effect.try({ try: () => makeCompiledInitial!(scope), catch: (error) => error as any })
   return ({
     execution: {
       _tag: "Compiled",
@@ -536,7 +540,10 @@ const makeProcessLogic: <
               try {
                 planned = internalPlanner.planConfiguration(
                   machine,
-                  configuration ?? Configuration.normalizeConfigurationSync(machine, current),
+                  Configuration.withActorScope(
+                    configuration ?? Configuration.normalizeConfigurationSync(machine, current),
+                    context
+                  ),
                   event
                 )
               } catch (error) {
@@ -644,7 +651,10 @@ const makeProcessLogic: <
               try {
                 planned = internalPlanner.planConfiguration(
                   machine,
-                  configuration ?? Configuration.normalizeConfigurationSync(machine, current),
+                  Configuration.withActorScope(
+                    configuration ?? Configuration.normalizeConfigurationSync(machine, current),
+                    context
+                  ),
                   event
                 )
               } catch (error) {
@@ -815,6 +825,18 @@ export const startWithRuntimeStrategyForTesting = (
     machine.id === undefined ? undefined : { id: machine.id }
   )
 
+/** @internal Test-only prepared startup strategy selection for a fresh machine. */
+export const prepareWithRuntimeStrategyForTesting = (
+  machine: Machine.Any,
+  strategy: internalRuntime.ProcessRuntimeStrategy,
+  ...args: ReadonlyArray<unknown>
+): Effect.Effect<internalRuntime.PreparedProcess<any, any, any, any, any, any, any>, any, any> =>
+  internalRuntime.prepareProcessWithStrategyForTesting(
+    (toProcessLogic as any)(machine, ...args),
+    strategy,
+    machine.id === undefined ? undefined : { id: machine.id }
+  )
+
 /** @internal Test-only runtime strategy selection for a resumed machine. */
 export const resumeWithRuntimeStrategyForTesting = (
   machine: Machine.Any,
@@ -871,6 +893,51 @@ export const start: <
     machine.id === undefined ? undefined : { id: machine.id }
   ) as any
 
+export const prepare: <
+  const States extends Machine.StateSchemas,
+  const Events extends ReadonlyArray<Machine.TaggedSchema>,
+  const Emits extends ReadonlyArray<Machine.TaggedSchema> = readonly [],
+  const Input extends Schema.Top = typeof Schema.Void,
+  UnhandledStates extends Machine.StateIdentifier<States> = Machine.StateIdentifier<States>,
+  E = never,
+  R = never,
+  InitialE = never,
+  InitialR = never,
+  FinalStates extends Machine.StateIdentifier<States> = never,
+  Output = never
+>(
+  machine: Machine<States, Events, Input, UnhandledStates, E, R, InitialE, InitialR, FinalStates, Output, Emits>,
+  ...args: [...Machine.InputArgs<Input>]
+) => Effect.Effect<
+  internalRuntime.PreparedProcess<
+    Machine.Snapshot<States>,
+    Machine.EventOf<Events>,
+    | E
+    | ActionError<R>
+    | InfiniteTransitionError
+    | MachineSchemaDecodeError
+    | StoppedError,
+    Output,
+    Machine.EmittedEventOf<Emits>,
+    | InitialE
+    | E
+    | ActionError<InitialR | R>
+    | InfiniteTransitionError
+    | MachineSchemaDecodeError
+    | StartupError
+    | StoppedError,
+    ExcludeCompatibleRuntime<
+      Exclude<ExecutionServices<InitialR | R>, internalRuntime.MachineRuntime>,
+      Machine.EventOf<Events>,
+      Machine.EmitOf<Emits>
+    >
+  >
+> = (machine, ...args) =>
+  internalRuntime.prepareProcess(
+    toProcessLogic(machine, ...args),
+    machine.id === undefined ? undefined : { id: machine.id }
+  ) as any
+
 export const resume: <
   const States extends Machine.StateSchemas,
   const Events extends ReadonlyArray<Machine.TaggedSchema>,