@typeonce/effect-machine 0.11.0 → 0.12.0

package/src/Machine.ts

@@ -175,18 +175,18 @@ export interface Machine<
   >
 
   /**
-   * Ephemeral outward notifications published to this actor's observers.
-   * Emissions are never delivered implicitly to an owning actor.
+   * Ephemeral outward notifications published to this machine's observers.
+   * Emissions are never delivered implicitly to an owning machine.
    *
    * @since 0.4.0
    */
   readonly emittedEvents: Machine.EventProtocol<"emitted", Emits>
 
   /**
-   * Public input events accepted by an owning actor when this machine is
+   * Public input events accepted by an owning machine when this machine is
    * running as a child.
    *
-   * The protocol types the optional `parent` actor reference exposed to
+   * The protocol types the optional `parent` machine target exposed to
    * handlers and is checked against a concrete parent's public events at
    * composition boundaries.
    *
@@ -387,7 +387,7 @@ export interface Runtime<in Events, in Emits> {
   readonly raise: (event: Machine.EventInput<Events>) => Effect.Effect<void, MachineSchemaDecodeError | StoppedError>
 
   /**
-   * Publishes an ephemeral notification to the running actor's observers.
+   * Publishes an ephemeral notification to the running machine's observers.
    *
    * @since 0.4.0
    */
@@ -397,37 +397,37 @@ export interface Runtime<in Events, in Emits> {
 }
 
 /**
- * Minimal typed reference accepted by targeted actor commands.
+ * Minimal typed target accepted by inter-machine send commands.
  *
  * @category models
- * @since 0.10.0
+ * @since 0.12.0
  */
-export interface ActorRef<in Event> {
+export interface MachineTarget<in Event> {
   readonly id: string
   readonly sessionId: string
   readonly send: (event: Event) => Effect.Effect<void, StoppedError>
 }
 
 /**
- * Actor references available while evaluating machine behavior.
+ * Machine targets available while evaluating machine behavior.
  *
  * @category models
- * @since 0.10.0
+ * @since 0.12.0
  */
-export interface ActorContext<
+export interface MachineReferences<
   InputEvents extends ReadonlyArray<Machine.TaggedSchema>,
   ParentEvents extends ReadonlyArray<Machine.TaggedSchema>
 > {
-  /** Reference to the current actor. Sending queues a later mailbox event. */
-  readonly self: ActorRef<Machine.EventInputOf<InputEvents>>
+  /** Target for the current machine. Sending queues a later mailbox event. */
+  readonly self: MachineTarget<Machine.EventInputOf<InputEvents>>
 
-  /** Reference to the owning actor, or `undefined` when running as a root. */
-  readonly parent: ActorRef<Machine.EventInputOf<ParentEvents>> | undefined
+  /** Target for the owning machine, or `undefined` when running as a root. */
+  readonly parent: MachineTarget<Machine.EventInputOf<ParentEvents>> | undefined
 }
 
 /**
  * Synchronous commands available while a machine transition is being
- * selected. Enqueuing only records statechart and actor operations; it never
+ * selected. Enqueuing only records statechart and machine operations; it never
  * executes an Effect.
  *
  * @category models
@@ -437,12 +437,12 @@ export interface Enqueue<in Events, in Emits> {
   /** Raises an event inside the current macrostep. */
   readonly raise: (event: Machine.EventInput<Events>) => void
 
-  /** Publishes an ephemeral notification to this actor's observers. */
+  /** Publishes an ephemeral notification to this machine's observers. */
   readonly emit: (event: Machine.EmittedEventInput<Emits>) => void
 
   /** Sends an event to an invoked child after the transition is selected. */
   readonly sendTo: {
-    <Event>(target: ActorRef<Event>, event: Event): void
+    <Event>(target: MachineTarget<Event>, event: Event): void
     <Child extends ChildMachine.Any>(child: Child, event: ChildMachine.Event<Child>): void
     <Address extends ChildAddress<never>>(child: Address, event: ChildAddress.Event<Address>): void
   }
@@ -455,7 +455,7 @@ export interface Enqueue<in Events, in Emits> {
 }
 
 /**
- * A closed actor command recorded by a synchronous machine transition.
+ * A closed machine command recorded by a synchronous transition.
  *
  * @category models
  * @since 0.4.0
@@ -463,7 +463,7 @@ export interface Enqueue<in Events, in Emits> {
 export type Command =
   | {
     readonly _tag: "SendTo"
-    readonly target: ActorRef<unknown> | ChildMachine.Any | ChildAddress<never>
+    readonly target: MachineTarget<unknown> | ChildMachine.Any | ChildAddress<never>
     readonly event: unknown
   }
   | {
@@ -1745,7 +1745,7 @@ export interface Prepared<out State, in Event, out Error, out Output, out Emitte
  * @since 0.4.0
  */
 export interface MachineRef<out State, in Event, out Error = never, out Output = never, out Emitted = never>
-  extends ActorRef<Event>
+  extends MachineTarget<Event>
 {
   /** Stable machine definition id, or a generated fallback when none was declared. */
   readonly id: string
@@ -1764,7 +1764,7 @@ export interface MachineRef<out State, in Event, out Error = never, out Output =
 
   /**
    * Streams ephemeral notifications published after subscription. Emissions
-   * are not retained or replayed; the stream completes when the actor stops.
+   * are not retained or replayed; the stream completes when the machine stops.
    */
   readonly emissions: Stream.Stream<Emitted>
 
@@ -1892,9 +1892,9 @@ export declare namespace Logic {
     /** Starts a child process owned by this scope. */
     readonly spawn: Spawn
 
-    /** Sends an event to an actor reference or typed parent-local child address. */
+    /** Sends an event to a machine target or typed parent-local child address. */
     readonly sendTo: {
-      <TargetEvent>(target: ActorRef<TargetEvent>, event: TargetEvent): Effect.Effect<void, StoppedError>
+      <TargetEvent>(target: MachineTarget<TargetEvent>, event: TargetEvent): Effect.Effect<void, StoppedError>
       <Address extends ChildAddress<never>>(
         id: Address,
         event: ChildAddress.Event<Address>
@@ -2276,7 +2276,7 @@ export declare namespace Machine {
    */
   export type InputEvents<M extends Any> = M[typeof MachineTypeId]["inputEvents"]
 
-  /** Extracts the public input protocol required from an owning actor. */
+  /** Extracts the public input protocol required from an owning machine. */
   export type ParentEvents<M extends Any> = M[typeof MachineTypeId]["parentEvents"]
 
   /** Extracts an internal event schema tuple from the complete and public protocols. */
@@ -4011,7 +4011,7 @@ export declare namespace Machine {
     R,
     InputEvents extends ReadonlyArray<TaggedSchema> = Events,
     ParentEvents extends ReadonlyArray<TaggedSchema> = readonly []
-  > extends ActorContext<InputEvents, ParentEvents> {
+  > extends MachineReferences<InputEvents, ParentEvents> {
     readonly state: StateByIdentifier<States, StateId>
     readonly containingState: ParentStateValue<States, StateId>
     readonly ancestors: ParentStateValues<States, StateId>
@@ -4041,7 +4041,7 @@ export declare namespace Machine {
     StateId extends StateIdentifier<States>,
     InputEvents extends ReadonlyArray<TaggedSchema> = Events,
     ParentEvents extends ReadonlyArray<TaggedSchema> = readonly []
-  > extends ActorContext<InputEvents, ParentEvents> {
+  > extends MachineReferences<InputEvents, ParentEvents> {
     readonly state: StateByIdentifier<States, StateId>
     readonly containingState: ParentStateValue<States, StateId>
     readonly ancestors: ParentStateValues<States, StateId>
@@ -4061,7 +4061,7 @@ export declare namespace Machine {
     StateId extends StateIdentifier<States>,
     InputEvents extends ReadonlyArray<TaggedSchema> = Events,
     ParentEvents extends ReadonlyArray<TaggedSchema> = readonly []
-  > extends ActorContext<InputEvents, ParentEvents> {
+  > extends MachineReferences<InputEvents, ParentEvents> {
     readonly state: StateByIdentifier<States, StateId>
     readonly containingState: ParentStateValue<States, StateId>
     readonly ancestors: ParentStateValues<States, StateId>
@@ -4084,7 +4084,7 @@ export declare namespace Machine {
     Output,
     InputEvents extends ReadonlyArray<TaggedSchema> = Events,
     ParentEvents extends ReadonlyArray<TaggedSchema> = readonly []
-  > extends ActorContext<InputEvents, ParentEvents> {
+  > extends MachineReferences<InputEvents, ParentEvents> {
     readonly id: string
     readonly state: StateByIdentifier<States, StateId>
     readonly containingState: ParentStateValue<States, StateId>
@@ -4107,7 +4107,7 @@ export declare namespace Machine {
     Output,
     InputEvents extends ReadonlyArray<TaggedSchema> = Events,
     ParentEvents extends ReadonlyArray<TaggedSchema> = readonly []
-  > extends ActorContext<InputEvents, ParentEvents> {
+  > extends MachineReferences<InputEvents, ParentEvents> {
     readonly id: string
     readonly state: StateByIdentifier<States, StateId>
     readonly containingState: ParentStateValue<States, StateId>
@@ -4126,7 +4126,7 @@ export declare namespace Machine {
     Error,
     InputEvents extends ReadonlyArray<TaggedSchema> = Events,
     ParentEvents extends ReadonlyArray<TaggedSchema> = readonly []
-  > extends ActorContext<InputEvents, ParentEvents> {
+  > extends MachineReferences<InputEvents, ParentEvents> {
     readonly id: string
     readonly state: StateByIdentifier<States, StateId>
     readonly containingState: ParentStateValue<States, StateId>
@@ -4149,7 +4149,7 @@ export declare namespace Machine {
     StateId extends StateIdentifier<States>,
     InputEvents extends ReadonlyArray<TaggedSchema> = Events,
     ParentEvents extends ReadonlyArray<TaggedSchema> = readonly []
-  > extends ActorContext<InputEvents, ParentEvents> {
+  > extends MachineReferences<InputEvents, ParentEvents> {
     readonly state: StateByIdentifier<States, StateId>
     readonly containingState: ParentStateValue<States, StateId>
     readonly ancestors: ParentStateValues<States, StateId>
@@ -4180,7 +4180,7 @@ export declare namespace Machine {
     StateId extends StateIdentifier<States>,
     InputEvents extends ReadonlyArray<TaggedSchema> = Events,
     ParentEvents extends ReadonlyArray<TaggedSchema> = readonly []
-  > extends ActorContext<InputEvents, ParentEvents> {
+  > extends MachineReferences<InputEvents, ParentEvents> {
     readonly state: StateByIdentifier<States, StateId>
     readonly containingState: ParentStateValue<States, StateId>
     readonly ancestors: ParentStateValues<States, StateId>
@@ -4207,7 +4207,7 @@ export declare namespace Machine {
     ChoiceId extends ChoiceIdentifier<States>,
     InputEvents extends ReadonlyArray<TaggedSchema> = Events,
     ParentEvents extends ReadonlyArray<TaggedSchema> = readonly []
-  > extends ActorContext<InputEvents, ParentEvents> {
+  > extends MachineReferences<InputEvents, ParentEvents> {
     readonly containingState: StateByIdentifier<
       States,
       Extract<ImmediateParentStateIdentifier<ChoiceId>, StateIdentifier<States>>
@@ -6431,7 +6431,7 @@ interface Make {
  * adds raised events and other machine-local deliveries.
  * `Machine.emittedEvents` defines outward ephemeral notifications, while
  * `parentEvents` declares the inputs a child may explicitly send to its owning
- * actor. All descriptors expose deferred constructors while retaining their
+ * machine. All descriptors expose deferred constructors while retaining their
  * schemas opaquely for runtime validation. Public and internal tags must be
  * disjoint.
  *
@@ -6543,8 +6543,8 @@ export const internalEvents: {
 
 /**
  * Defines the ephemeral notifications a machine may publish to external
- * observers. Emitted events are separate from actor input and are never sent
- * implicitly to a parent actor. Observe them through `MachineRef.emissions` or
+ * observers. Emitted events are separate from machine input and are never sent
+ * implicitly to a parent machine. Observe them through `MachineRef.emissions` or
  * the AtomMachine emission stream adapters.
  *
  * @category constructors
@@ -7379,11 +7379,11 @@ export const invoke: {
     >
 } = ((config: unknown) => config) as any
 /**
- * Plans the initial state for a machine without executing actor commands.
+ * Plans the initial state for a machine without executing machine commands.
  *
  * **Details**
  *
- * The returned plan contains the settled initial snapshot, actor commands,
+ * The returned plan contains the settled initial snapshot, machine commands,
  * emitted events, optional final output, and every startup microstep. Planning
  * may evaluate transition logic and follow completion, eventless, and
  * raised-event steps. Transition callbacks are evaluated synchronously.
@@ -7392,8 +7392,8 @@ export const invoke: {
  *
  * **Gotchas**
  *
- * `start` executes the closed command list as part of the managed actor commit
- * protocol. Manual planners may inspect commands but need a running actor scope
+ * `start` executes the closed command list as part of the managed machine commit
+ * protocol. Manual planners may inspect commands but need running machine targets
  * to execute child-addressed operations.
  *
  * **Example**
@@ -7628,7 +7628,7 @@ export const enabled: <
  *
  * **Gotchas**
  *
- * `plan` returns data; it does not implement the actor commit protocol.
+ * `plan` returns data; it does not implement the managed machine commit protocol.
  * `start` executes child commands, publishes `next`, and then delivers
  * `emittedEvents`. Events with no enabled transition are ignored and produce
  * an unchanged plan.
@@ -8029,7 +8029,7 @@ export const prepare: <
  * **Details**
  *
  * For each accepted event the runtime plans the complete synchronous
- * macrostep, executes closed actor commands, stops invokes for exited states,
+ * macrostep, executes closed machine commands, stops invokes for exited states,
  * publishes the new state, delivers emitted events, and then starts invokes
  * for entered states.
  *

package/src/internal/machine/cluster.ts

@@ -317,7 +317,7 @@ export const make = <
             if (initial.commands.length > 0) {
               return yield* fail(
                 "UnsupportedProcessLocal",
-                "Machine actor commands require a managed local process"
+                "Machine commands require a managed local process"
               )
             }
             current = initial.state
@@ -329,7 +329,7 @@ export const make = <
             if (planned.commands.length > 0) {
               return yield* fail(
                 "UnsupportedProcessLocal",
-                "Machine actor commands require a managed local process"
+                "Machine commands require a managed local process"
               )
             }
             current = planned.next

package/src/internal/machine/commandRuntime.ts

@@ -10,7 +10,9 @@ import type { RuntimeCommand } from "./command.js"
 import { decodeEmit, decodeEvent } from "./protocol.js"
 import type { ProcessScope } from "./runtime.js"
 
-const isActorRef = (target: unknown): target is { readonly send: (event: unknown) => Effect.Effect<void, unknown> } =>
+const isMachineTarget = (
+  target: unknown
+): target is { readonly send: (event: unknown) => Effect.Effect<void, unknown> } =>
   typeof target === "object" && target !== null && "send" in target && typeof target.send === "function"
 
 export const makeLiveRuntime = <Events, Emits>(
@@ -33,7 +35,7 @@ export const runCommands = <Event>(
 ) =>
   Effect.forEach(commands, (command) =>
     command._tag === "SendTo"
-      ? isActorRef(command.target)
+      ? isMachineTarget(command.target)
         ? command.target.send(command.event)
         : scope.sendTo(command.target as never, command.event)
       : scope.stopChild(command.child as never), { discard: true })

package/src/internal/machine/configuration.ts

@@ -8,7 +8,7 @@ import * as Cause from "effect/Cause"
 import * as Effect from "effect/Effect"
 import * as Option from "effect/Option"
 import { hasProperty } from "effect/Predicate"
-import type { ActorRef, Machine } from "../../Machine.js"
+import type { Machine, MachineTarget } from "../../Machine.js"
 import { MachineSchemaDecodeError } from "./errors.js"
 import {
   decodeBoundary,
@@ -252,25 +252,25 @@ export interface ActiveConfiguration {
   readonly values: ReadonlyMap<string, unknown>
   readonly outputs: ReadonlyMap<string, unknown>
   readonly history: ReadonlyMap<string, HistoryRecord>
-  readonly actorScope?: PlanningActorScope
+  readonly machineReferences?: PlanningMachineReferences
 }
 
-export interface PlanningActorScope {
-  readonly self: ActorRef<any>
-  readonly parent: ActorRef<any> | undefined
+export interface PlanningMachineReferences {
+  readonly self: MachineTarget<any>
+  readonly parent: MachineTarget<any> | undefined
 }
 
-export const withActorScope = (
+export const withMachineReferences = (
   configuration: ActiveConfiguration,
-  actorScope: PlanningActorScope
+  machineReferences: PlanningMachineReferences
 ): ActiveConfiguration => ({
   ...configuration,
-  actorScope: { self: actorScope.self, parent: actorScope.parent }
+  machineReferences: { self: machineReferences.self, parent: machineReferences.parent }
 })
 
-export const getActorScope = (
+export const getMachineReferences = (
   configuration: ActiveConfiguration
-): PlanningActorScope | undefined => configuration.actorScope
+): PlanningMachineReferences | undefined => configuration.machineReferences
 
 export interface FinalCompletion {
   readonly path: string

package/src/internal/machine/executionPlan.ts

@@ -5,7 +5,7 @@
  */
 
 import * as Effect from "effect/Effect"
-import type { ActorRef, Machine } from "../../Machine.js"
+import type { Machine, MachineTarget } from "../../Machine.js"
 import { getTargetBuilder, type RuntimeCommand } from "./command.js"
 import {
   type ActiveConfiguration,
@@ -18,10 +18,10 @@ import {
   isDescendantOf,
   normalizeConfigurationSync,
   normalizeTargetConfigurationSync,
-  type PlanningActorScope,
+  type PlanningMachineReferences,
   snapshotFromConfiguration,
   validateInitialConfiguration,
-  withActorScope
+  withMachineReferences
 } from "./configuration.js"
 import { InfiniteTransitionError, StoppedError } from "./errors.js"
 import * as InvocationEvent from "./invocationEvent.js"
@@ -67,28 +67,28 @@ interface IndexedExecutionDescriptor {
   >
 }
 
-const planningActorScopes = new WeakMap<Machine.Any, PlanningActorScope>()
+const planningMachineReferences = new WeakMap<Machine.Any, PlanningMachineReferences>()
 
-const getPlanningActorScope = (machine: Machine.Any): PlanningActorScope => {
-  const cached = planningActorScopes.get(machine)
+const getPlanningMachineReferences = (machine: Machine.Any): PlanningMachineReferences => {
+  const cached = planningMachineReferences.get(machine)
   if (cached !== undefined) return cached
-  const self: ActorRef<unknown> = {
+  const self: MachineTarget<unknown> = {
     id: machine.id ?? "Machine",
     sessionId: "Machine.plan",
     send: () => Effect.fail(new StoppedError())
   }
   const scope = { self, parent: undefined }
-  planningActorScopes.set(machine, scope)
+  planningMachineReferences.set(machine, scope)
   return scope
 }
 
-const getActorContext = (
+const resolveMachineReferences = (
   machine: Machine.Any,
-  actorScope: PlanningActorScope | undefined
-): PlanningActorScope =>
-  actorScope === undefined
-    ? getPlanningActorScope(machine)
-    : { self: actorScope.self, parent: actorScope.parent }
+  machineReferences: PlanningMachineReferences | undefined
+): PlanningMachineReferences =>
+  machineReferences === undefined
+    ? getPlanningMachineReferences(machine)
+    : { self: machineReferences.self, parent: machineReferences.parent }
 
 const indexedStateConfigKeys: ReadonlySet<PropertyKey> = new Set([
   "initial",
@@ -363,7 +363,7 @@ const makeIndexedTransitionContext = (
   configuration: OwnedIndexedState,
   sourceIndex: number,
   event: any,
-  actorScope?: PlanningActorScope
+  machineReferences?: PlanningMachineReferences
 ): any => {
   const source = descriptor.nodes[sourceIndex]!
   const parentIndex = descriptor.parentIndices[sourceIndex]!
@@ -372,7 +372,7 @@ const makeIndexedTransitionContext = (
     ancestors[descriptor.nodes[ancestorIndex]!.path] = configuration.values[ancestorIndex]
   }
   return {
-    ...getActorContext(machine, actorScope),
+    ...resolveMachineReferences(machine, machineReferences),
     state: configuration.values[sourceIndex],
     containingState: parentIndex < 0 ? undefined : configuration.values[parentIndex],
     ancestors,
@@ -454,7 +454,7 @@ const selectIndexedEventTransitions = (
   descriptor: IndexedExecutionDescriptor,
   configuration: OwnedIndexedState,
   event: any,
-  actorScope?: PlanningActorScope
+  machineReferences?: PlanningMachineReferences
 ): ReadonlyArray<IndexedSelectedTransition> => {
   const selected: Array<IndexedSelectedTransition> = []
   for (const leafIndex of configuration.activeLeaves) {
@@ -476,7 +476,7 @@ const selectIndexedEventTransitions = (
             configuration,
             sourceIndex,
             event,
-            actorScope
+            machineReferences
           )
         })
       }
@@ -660,7 +660,7 @@ const planIndexedFlatState = (
   configuration: OwnedIndexedState,
   decoded: { readonly _tag: PropertyKey },
   retainMicrosteps: boolean,
-  actorScope?: PlanningActorScope
+  machineReferences?: PlanningMachineReferences
 ): ExecutionMacrostep<OwnedIndexedState> => {
   let current = configuration
   let event: any = decoded
@@ -712,7 +712,7 @@ const planIndexedFlatState = (
         machine,
         transition.transition,
         {
-          ...getActorContext(machine, actorScope),
+          ...resolveMachineReferences(machine, machineReferences),
           state: current.values[sourceIndex],
           containingState: undefined,
           ancestors: {},
@@ -807,7 +807,7 @@ const planIndexedState = (
   configuration: OwnedIndexedState,
   input: unknown,
   retainMicrosteps: boolean,
-  actorScope?: PlanningActorScope
+  machineReferences?: PlanningMachineReferences
 ): ExecutionMacrostep<OwnedIndexedState> => {
   if (InvocationEvent.isInvocationEvent(input)) {
     // Invocation lifecycle transitions retain the generic planner as their
@@ -816,9 +816,9 @@ const planIndexedState = (
     // the representation boundary.
     const planned = planConfiguration(
       machine as any,
-      actorScope === undefined
+      machineReferences === undefined
         ? activeConfigurationFromIndexedState(descriptor, configuration)
-        : withActorScope(activeConfigurationFromIndexedState(descriptor, configuration), actorScope),
+        : withMachineReferences(activeConfigurationFromIndexedState(descriptor, configuration), machineReferences),
       input
     )
     return {
@@ -841,7 +841,7 @@ const planIndexedState = (
   }
   const decoded = decodeEventSync(machine, input)
   if (descriptor.flat) {
-    return planIndexedFlatState(machine, descriptor, configuration, decoded, retainMicrosteps, actorScope)
+    return planIndexedFlatState(machine, descriptor, configuration, decoded, retainMicrosteps, machineReferences)
   }
   if (descriptor.finalIndices.some((index) => configuration.active[index] === 1)) {
     const active = activeConfigurationFromIndexedState(descriptor, configuration)
@@ -862,7 +862,7 @@ const planIndexedState = (
     }
   }
 
-  const selections = selectIndexedEventTransitions(machine, descriptor, configuration, decoded, actorScope)
+  const selections = selectIndexedEventTransitions(machine, descriptor, configuration, decoded, machineReferences)
   if (selections.length === 0) {
     return {
       next: configuration,
@@ -930,7 +930,7 @@ const planIndexedState = (
     }
     raisedIndex += 1
     currentEvent = raised
-    const raisedSelections = selectIndexedEventTransitions(machine, descriptor, current, raised, actorScope)
+    const raisedSelections = selectIndexedEventTransitions(machine, descriptor, current, raised, machineReferences)
     if (raisedSelections.length === 0) continue
     const step = indexedMicrostep(machine, descriptor, current, raised, raisedSelections)
     current = step.next
@@ -949,11 +949,11 @@ export interface CompiledExecutionPlan {
     state: unknown,
     event: unknown,
     retainMicrosteps?: boolean,
-    actorScope?: PlanningActorScope
+    machineReferences?: PlanningMachineReferences
   ) => ExecutionMacrostep
   readonly initial?: (
     args: ReadonlyArray<unknown>,
-    actorScope?: PlanningActorScope
+    machineReferences?: PlanningMachineReferences
   ) => {
     readonly state: Machine.Snapshot<any>
     readonly configuration: unknown
@@ -970,12 +970,12 @@ const makeActiveExecutionPlan = (machine: Machine.Any): CompiledExecutionPlan =>
   fromConfiguration: (configuration) => configuration,
   toConfiguration: (state) => state as ActiveConfiguration,
   snapshot: (state) => snapshotFromConfiguration(machine, state as ActiveConfiguration),
-  plan: (state, event, _retainMicrosteps, actorScope) =>
+  plan: (state, event, _retainMicrosteps, machineReferences) =>
     planConfiguration(
       machine as any,
-      actorScope === undefined
+      machineReferences === undefined
         ? state as ActiveConfiguration
-        : withActorScope(state as ActiveConfiguration, actorScope),
+        : withMachineReferences(state as ActiveConfiguration, machineReferences),
       event as any
     )
 })
@@ -987,9 +987,9 @@ const makeIndexedExecutionPlan = (
   fromConfiguration: (configuration) => ownedIndexedStateFromActive(indexed, configuration),
   toConfiguration: (state) => activeConfigurationFromIndexedState(indexed, state as OwnedIndexedState),
   snapshot: (state) => snapshotFromIndexedState(indexed, state as OwnedIndexedState),
-  plan: (state, event, retainMicrosteps = false, actorScope) =>
-    planIndexedState(machine, indexed, state as OwnedIndexedState, event, retainMicrosteps, actorScope),
-  initial: (args, actorScope) => {
+  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
@@ -997,7 +997,7 @@ const makeIndexedExecutionPlan = (
       : [decodeInputSync(machine, machine.input, args[0])]
     const initial = machine.initial(...inputArgs as any)
     const normalized = normalizeConfigurationSync(machine, initial as Machine.Snapshot<any>)
-    const active = actorScope === undefined ? normalized : withActorScope(normalized, actorScope)
+    const active = machineReferences === undefined ? normalized : withMachineReferences(normalized, machineReferences)
     validateInitialConfiguration(machine, active)
     const completed = completeConfigurationSync(machine, active, InitialEvent).configuration
     const configuration = ownedIndexedStateFromActive(indexed, completed)

package/src/internal/machine/invocation.ts

@@ -235,7 +235,7 @@ export const startAll = (
     .filter((path) => configuration.active.has(path))
     .flatMap((path) => {
       const context = {
-        ...(Configuration.getActorScope(configuration) ?? { self: scope.self, parent: scope.parent }),
+        ...(Configuration.getMachineReferences(configuration) ?? { self: scope.self, parent: scope.parent }),
         state: configuration.values.get(path),
         containingState: Configuration.getParentValue(machine, configuration, path),
         ancestors: Configuration.getParentValues(machine, configuration, path),