xstate 6.0.0-alpha.45 → 6.0.0-alpha.46

package/dist/{StateMachine-2eecedfe.cjs.js → StateMachine-756e1335.cjs.js}

@@ -1,11 +1,11 @@
 'use strict';
 
-var createActor = require('./createActor-48401456.cjs.js');
-var dist_xstateActors = require('./index-fce4ea5c.cjs.js');
+var createActor = require('./createActor-0816a84b.cjs.js');
+var dist_xstateActors = require('./index-7b9c4f77.cjs.js');
 
 function createSpawner(actorScope, actors, spawnedChildren) {
   return (src, options) => {
-    const referencedSrc = Object.entries(actors).find(([, logic]) => logic === src)?.[0];
+    const referencedSrc = createActor.resolveRegisteredActorSource(actors, src);
     // Generated ids come from the same transaction allocator as `enq.spawn`,
     // so context-factory allocations persist with the snapshot and never
     // collide with later spawns.

package/dist/{StateMachine-d2fcf2e8.esm.js → StateMachine-9509c0bd.esm.js}

@@ -1,9 +1,9 @@
-import { Q as allocateChildId, R as assertChildIdFree, S as reserveChildId, T as STATE_DELIMITER, U as mapValues, t as toArray, V as createInvokeId, W as getDelayedTransitions, Y as getEventDescriptorKey, Z as getCandidates, _ as evaluateCandidate, $ as formatTransition, a0 as NULL_EVENT, a1 as toTransitionConfigArray, a2 as createInvokeTimeoutEventId, a3 as matchesActorSession, a4 as formatRouteTransitions, a5 as resolveStateValue, a6 as getAllStateNodes, x as getStateNodes, a7 as createMachineSnapshot, a8 as isInFinalState, a9 as createInertActorScope, aa as setInertActorScopeSnapshot, a as beginSpawnAllocation, ab as attachSnapshotActorRef, ac as macrostep, ad as isInertActorScope, ae as setSnapshotActorRef, af as cloneMachineSnapshot, ag as transitionNode, g as XSTATE_TIMER, m as matchesEventDescriptor, ah as getTransitionResult, ai as hasEffect, aj as createErrorPlatformEvent, ak as withActorSelf, r as resolveActionsWithContext, al as takeSpawnAllocationCounters, am as mergeActorIdCounters, K as createInitEvent, an as createSpawnEffect, ao as initialMicrostep, ap as toStatePath, aq as isStateId, ar as getStateNodeByPath, as as getPersistedSnapshot, at as createRemoteActorRef, au as resolveReferencedActor, av as createInvokeTimeoutEvent, aw as parseGeneratedActorId, ax as ACTOR_REF_TYPE, k as createActor } from './createActor-641ab5f7.esm.js';
-import { g as assertValid } from './index-8f19f242.esm.js';
+import { Q as resolveRegisteredActorSource, R as allocateChildId, S as assertChildIdFree, T as reserveChildId, U as STATE_DELIMITER, V as mapValues, t as toArray, W as createInvokeId, Y as getDelayedTransitions, Z as getEventDescriptorKey, _ as getCandidates, $ as evaluateCandidate, a0 as formatTransition, a1 as NULL_EVENT, a2 as toTransitionConfigArray, a3 as createInvokeTimeoutEventId, a4 as matchesActorSession, a5 as formatRouteTransitions, a6 as resolveStateValue, a7 as getAllStateNodes, x as getStateNodes, a8 as createMachineSnapshot, a9 as isInFinalState, aa as createInertActorScope, ab as setInertActorScopeSnapshot, a as beginSpawnAllocation, ac as attachSnapshotActorRef, ad as macrostep, ae as isInertActorScope, af as setSnapshotActorRef, ag as cloneMachineSnapshot, ah as transitionNode, g as XSTATE_TIMER, m as matchesEventDescriptor, ai as getTransitionResult, aj as hasEffect, ak as createErrorPlatformEvent, al as withActorSelf, r as resolveActionsWithContext, am as takeSpawnAllocationCounters, an as mergeActorIdCounters, K as createInitEvent, ao as createSpawnEffect, ap as initialMicrostep, aq as toStatePath, ar as isStateId, as as getStateNodeByPath, at as getPersistedSnapshot, au as createRemoteActorRef, av as resolveReferencedActor, aw as createInvokeTimeoutEvent, ax as parseGeneratedActorId, ay as ACTOR_REF_TYPE, k as createActor } from './createActor-9523f716.esm.js';
+import { g as assertValid } from './index-c7431a16.esm.js';
 
 function createSpawner(actorScope, actors, spawnedChildren) {
   return (src, options) => {
-    const referencedSrc = Object.entries(actors).find(([, logic]) => logic === src)?.[0];
+    const referencedSrc = resolveRegisteredActorSource(actors, src);
     // Generated ids come from the same transaction allocator as `enq.spawn`,
     // so context-factory allocations persist with the snapshot and never
     // collide with later spawns.

package/dist/{StateMachine-4bf86161.development.esm.js → StateMachine-a5ede014.development.esm.js}

@@ -1,9 +1,9 @@
-import { Q as allocateChildId, R as assertChildIdFree, S as reserveChildId, T as STATE_DELIMITER, U as mapValues, t as toArray, V as createInvokeId, W as getDelayedTransitions, Y as getEventDescriptorKey, Z as getCandidates, _ as evaluateCandidate, $ as formatTransition, a0 as NULL_EVENT, a1 as toTransitionConfigArray, a2 as createInvokeTimeoutEventId, a3 as matchesActorSession, a4 as formatRouteTransitions, a5 as resolveStateValue, a6 as getAllStateNodes, x as getStateNodes, a7 as createMachineSnapshot, a8 as isInFinalState, a9 as createInertActorScope, aa as setInertActorScopeSnapshot, a as beginSpawnAllocation, ab as attachSnapshotActorRef, ac as macrostep, ad as isInertActorScope, ae as setSnapshotActorRef, af as cloneMachineSnapshot, ag as transitionNode, g as XSTATE_TIMER, m as matchesEventDescriptor, ah as getTransitionResult, ai as hasEffect, aj as createErrorPlatformEvent, ak as withActorSelf, r as resolveActionsWithContext, al as takeSpawnAllocationCounters, am as mergeActorIdCounters, K as createInitEvent, an as createSpawnEffect, ao as initialMicrostep, ap as toStatePath, aq as isStateId, ar as getStateNodeByPath, as as getPersistedSnapshot, at as createRemoteActorRef, au as resolveReferencedActor, av as createInvokeTimeoutEvent, aw as parseGeneratedActorId, ax as ACTOR_REF_TYPE, k as createActor } from './createActor-60ee6b5b.development.esm.js';
-import { g as assertValid } from './index-158e7c37.development.esm.js';
+import { Q as resolveRegisteredActorSource, R as allocateChildId, S as assertChildIdFree, T as reserveChildId, U as STATE_DELIMITER, V as mapValues, t as toArray, W as createInvokeId, Y as getDelayedTransitions, Z as getEventDescriptorKey, _ as getCandidates, $ as evaluateCandidate, a0 as formatTransition, a1 as NULL_EVENT, a2 as toTransitionConfigArray, a3 as createInvokeTimeoutEventId, a4 as matchesActorSession, a5 as formatRouteTransitions, a6 as resolveStateValue, a7 as getAllStateNodes, x as getStateNodes, a8 as createMachineSnapshot, a9 as isInFinalState, aa as createInertActorScope, ab as setInertActorScopeSnapshot, a as beginSpawnAllocation, ac as attachSnapshotActorRef, ad as macrostep, ae as isInertActorScope, af as setSnapshotActorRef, ag as cloneMachineSnapshot, ah as transitionNode, g as XSTATE_TIMER, m as matchesEventDescriptor, ai as getTransitionResult, aj as hasEffect, ak as createErrorPlatformEvent, al as withActorSelf, r as resolveActionsWithContext, am as takeSpawnAllocationCounters, an as mergeActorIdCounters, K as createInitEvent, ao as createSpawnEffect, ap as initialMicrostep, aq as toStatePath, ar as isStateId, as as getStateNodeByPath, at as getPersistedSnapshot, au as createRemoteActorRef, av as resolveReferencedActor, aw as createInvokeTimeoutEvent, ax as parseGeneratedActorId, ay as ACTOR_REF_TYPE, k as createActor } from './createActor-f5277b31.development.esm.js';
+import { g as assertValid } from './index-3907b7aa.development.esm.js';
 
 function createSpawner(actorScope, actors, spawnedChildren) {
   return (src, options) => {
-    const referencedSrc = Object.entries(actors).find(([, logic]) => logic === src)?.[0];
+    const referencedSrc = resolveRegisteredActorSource(actors, src);
     // Generated ids come from the same transaction allocator as `enq.spawn`,
     // so context-factory allocations persist with the snapshot and never
     // collide with later spawns.

package/dist/{StateMachine-5b915fb1.development.cjs.js → StateMachine-fa133051.development.cjs.js}

@@ -1,11 +1,11 @@
 'use strict';
 
-var createActor = require('./createActor-5c9fa117.development.cjs.js');
-var dist_xstateActors = require('./index-662114ff.development.cjs.js');
+var createActor = require('./createActor-f6e6146f.development.cjs.js');
+var dist_xstateActors = require('./index-1e1e1cba.development.cjs.js');
 
 function createSpawner(actorScope, actors, spawnedChildren) {
   return (src, options) => {
-    const referencedSrc = Object.entries(actors).find(([, logic]) => logic === src)?.[0];
+    const referencedSrc = createActor.resolveRegisteredActorSource(actors, src);
     // Generated ids come from the same transaction allocator as `enq.spawn`,
     // so context-factory allocations persist with the snapshot and never
     // collide with later spawns.

package/dist/{createActor-48401456.cjs.js → createActor-0816a84b.cjs.js}

@@ -219,6 +219,27 @@ const builtInActions = {
   }
 };
 
+const sourceKeyCaches = new WeakMap();
+
+/** @internal */
+function resolveRegisteredActorSource(actors, logic) {
+  let cache = sourceKeyCaches.get(actors);
+  if (!cache) {
+    cache = new Map();
+    for (const key of Object.keys(actors)) {
+      const registeredLogic = actors[key];
+      // Several source keys may intentionally share one implementation. The
+      // first key is its canonical persistence identity when spawning by the
+      // raw logic value, which cannot retain which alias was used to access it.
+      if (!cache.has(registeredLogic)) {
+        cache.set(registeredLogic, key);
+      }
+    }
+    sourceKeyCaches.set(actors, cache);
+  }
+  return cache.get(logic);
+}
+
 const subscriptions = /* #__PURE__ */new WeakMap();
 
 /**
@@ -666,21 +687,31 @@ function beginSpawnAllocation(actorScope) {
 function getWorkingSnapshotOf(actorScope) {
   return actorScope.self._snapshot;
 }
-const srcKeyCaches = new WeakMap();
-function getRegisteredSrcKey(actorScope, logic) {
-  const registeredActors = actorScope.self.logic?.sources?.actors;
-  if (!registeredActors) {
-    return undefined;
-  }
-  let cache = srcKeyCaches.get(registeredActors);
-  if (!cache) {
-    cache = new Map();
-    for (const key of Object.keys(registeredActors)) {
-      cache.set(registeredActors[key], key);
+function getRegisteredActors(actorScope) {
+  return actorScope.self.logic?.sources?.actors;
+}
+function resolveTransitionSpawnSource(actorScope, source) {
+  const registeredActors = getRegisteredActors(actorScope);
+  if (typeof source === 'string') {
+    const logic = registeredActors?.[source];
+    if (!logic) {
+      throw new Error(`Actor source '${source}' is not provided`);
     }
-    srcKeyCaches.set(registeredActors, cache);
+    return {
+      logic,
+      src: source
+    };
   }
-  return cache.get(logic);
+  if (!registeredActors) {
+    return {
+      logic: source,
+      src: undefined
+    };
+  }
+  return {
+    logic: source,
+    src: resolveRegisteredActorSource(registeredActors, source)
+  };
 }
 
 /**
@@ -821,17 +852,17 @@ function createTransitionEnqueue(actorScope, actions, internalEvents, actorSubsc
         internalEvents.push(raisedEvent);
       }
     },
-    spawn: (logic, options) => {
+    spawn: (source, options) => {
+      const {
+        logic,
+        src
+      } = resolveTransitionSpawnSource(actorScope, source);
       if (!createActors) {
         // TODO: replace this speculative placeholder with a typed inert actor ref.
         return {
-          id: options?.id ?? options?.registryKey ?? logic.id
+          id: options?.id ?? options?.registryKey ?? src ?? logic.id
         };
       }
-      // Recover the registered source key for setup-provided logic so the
-      // spawned child persists (and gets a deterministic id prefix) by key
-      // instead of by inline logic reference.
-      const src = getRegisteredSrcKey(actorScope, logic);
       // Generated ids allocate from the parent snapshot's own counters
       // through the transition's allocation transaction; explicit
       // generated-shaped ids reserve their numbering the same way.
@@ -3699,6 +3730,9 @@ function getPersistedSnapshot(snapshot, options) {
   const embedChildren = options?.embedChildren !== false;
   for (const id in children) {
     const child = children[id];
+    if (typeof child.src !== 'string' && (!options || !('__unsafeAllowInlineActors' in options))) {
+      throw new Error('An inline child actor cannot be persisted.');
+    }
     // Children are referenced by their logical address. Embedding the child
     // state is the co-locating runtime's whole-tree checkpoint capability;
     // remote handles never embed — their state lives with another runtime.
@@ -5747,6 +5781,7 @@ exports.pathToStateValue = pathToStateValue;
 exports.reserveChildId = reserveChildId;
 exports.resolveActionsWithContext = resolveActionsWithContext;
 exports.resolveReferencedActor = resolveReferencedActor;
+exports.resolveRegisteredActorSource = resolveRegisteredActorSource;
 exports.resolveStateValue = resolveStateValue;
 exports.runStep = runStep;
 exports.setInertActorScopeSnapshot = setInertActorScopeSnapshot;

package/dist/{createActor-641ab5f7.esm.js → createActor-9523f716.esm.js}

@@ -217,6 +217,27 @@ const builtInActions = {
   }
 };
 
+const sourceKeyCaches = new WeakMap();
+
+/** @internal */
+function resolveRegisteredActorSource(actors, logic) {
+  let cache = sourceKeyCaches.get(actors);
+  if (!cache) {
+    cache = new Map();
+    for (const key of Object.keys(actors)) {
+      const registeredLogic = actors[key];
+      // Several source keys may intentionally share one implementation. The
+      // first key is its canonical persistence identity when spawning by the
+      // raw logic value, which cannot retain which alias was used to access it.
+      if (!cache.has(registeredLogic)) {
+        cache.set(registeredLogic, key);
+      }
+    }
+    sourceKeyCaches.set(actors, cache);
+  }
+  return cache.get(logic);
+}
+
 const subscriptions = /* #__PURE__ */new WeakMap();
 
 /**
@@ -664,21 +685,31 @@ function beginSpawnAllocation(actorScope) {
 function getWorkingSnapshotOf(actorScope) {
   return actorScope.self._snapshot;
 }
-const srcKeyCaches = new WeakMap();
-function getRegisteredSrcKey(actorScope, logic) {
-  const registeredActors = actorScope.self.logic?.sources?.actors;
-  if (!registeredActors) {
-    return undefined;
-  }
-  let cache = srcKeyCaches.get(registeredActors);
-  if (!cache) {
-    cache = new Map();
-    for (const key of Object.keys(registeredActors)) {
-      cache.set(registeredActors[key], key);
+function getRegisteredActors(actorScope) {
+  return actorScope.self.logic?.sources?.actors;
+}
+function resolveTransitionSpawnSource(actorScope, source) {
+  const registeredActors = getRegisteredActors(actorScope);
+  if (typeof source === 'string') {
+    const logic = registeredActors?.[source];
+    if (!logic) {
+      throw new Error(`Actor source '${source}' is not provided`);
     }
-    srcKeyCaches.set(registeredActors, cache);
+    return {
+      logic,
+      src: source
+    };
   }
-  return cache.get(logic);
+  if (!registeredActors) {
+    return {
+      logic: source,
+      src: undefined
+    };
+  }
+  return {
+    logic: source,
+    src: resolveRegisteredActorSource(registeredActors, source)
+  };
 }
 
 /**
@@ -819,17 +850,17 @@ function createTransitionEnqueue(actorScope, actions, internalEvents, actorSubsc
         internalEvents.push(raisedEvent);
       }
     },
-    spawn: (logic, options) => {
+    spawn: (source, options) => {
+      const {
+        logic,
+        src
+      } = resolveTransitionSpawnSource(actorScope, source);
       if (!createActors) {
         // TODO: replace this speculative placeholder with a typed inert actor ref.
         return {
-          id: options?.id ?? options?.registryKey ?? logic.id
+          id: options?.id ?? options?.registryKey ?? src ?? logic.id
         };
       }
-      // Recover the registered source key for setup-provided logic so the
-      // spawned child persists (and gets a deterministic id prefix) by key
-      // instead of by inline logic reference.
-      const src = getRegisteredSrcKey(actorScope, logic);
       // Generated ids allocate from the parent snapshot's own counters
       // through the transition's allocation transaction; explicit
       // generated-shaped ids reserve their numbering the same way.
@@ -3697,6 +3728,9 @@ function getPersistedSnapshot(snapshot, options) {
   const embedChildren = options?.embedChildren !== false;
   for (const id in children) {
     const child = children[id];
+    if (typeof child.src !== 'string' && (!options || !('__unsafeAllowInlineActors' in options))) {
+      throw new Error('An inline child actor cannot be persisted.');
+    }
     // Children are referenced by their logical address. Embedding the child
     // state is the co-locating runtime's whole-tree checkpoint capability;
     // remote handles never embed — their state lives with another runtime.
@@ -5662,4 +5696,4 @@ function createActor(logic, options) {
   return new Actor(logic, options);
 }
 
-export { formatTransition as $, Actor as A, checkStateIn as B, pathToStateValue as C, toObserver as D, executeEffects as E, isBuiltInExecutableAction as F, deliverEvent as G, runStep as H, stopActor as I, terminateActor as J, createInitEvent as K, createCustomEffect as L, XSTATE_LOGIC_EFFECT_START as M, XSTATE_LOGIC_EFFECT_RESOLVE as N, XSTATE_LOGIC_EFFECT_REJECT as O, createEmitEffect as P, allocateChildId as Q, assertChildIdFree as R, reserveChildId as S, STATE_DELIMITER as T, mapValues as U, createInvokeId as V, getDelayedTransitions as W, XSTATE_INIT as X, getEventDescriptorKey as Y, getCandidates as Z, evaluateCandidate as _, beginSpawnAllocation as a, NULL_EVENT as a0, toTransitionConfigArray as a1, createInvokeTimeoutEventId as a2, matchesActorSession as a3, formatRouteTransitions as a4, resolveStateValue as a5, getAllStateNodes as a6, createMachineSnapshot as a7, isInFinalState as a8, createInertActorScope as a9, isRemoteActorRef as aA, getActorIdPrefix as aB, getAllOwnEvents as aC, matchesEvent as aD, encodeAddressSegment as aE, getRootActorId as aF, RUNTIME_OPERATIONS as aG, withSystemInspector as aH, getSnapshotActorRef as aI, withExecutionIdentity as aJ, setInertActorScopeSnapshot as aa, attachSnapshotActorRef as ab, macrostep as ac, isInertActorScope as ad, setSnapshotActorRef as ae, cloneMachineSnapshot as af, transitionNode as ag, getTransitionResult as ah, hasEffect as ai, createErrorPlatformEvent as aj, withActorSelf as ak, takeSpawnAllocationCounters as al, mergeActorIdCounters as am, createSpawnEffect as an, initialMicrostep as ao, toStatePath as ap, isStateId as aq, getStateNodeByPath as ar, getPersistedSnapshot as as, createRemoteActorRef as at, resolveReferencedActor as au, createInvokeTimeoutEvent as av, parseGeneratedActorId as aw, ACTOR_REF_TYPE as ax, hasAmbientInspector as ay, getProperAncestors as az, builtInActions as b, createTransitionEnqueue as c, deriveDeferredStarts as d, XSTATE_STOP as e, finalizeTransitionResult as f, XSTATE_TIMER as g, createSendToEffect as h, isLazyActorScope as i, isAtomicStateNode as j, createActor as k, createListenerLogic as l, matchesEventDescriptor as m, createSubscriptionLogic as n, listenerLogic as o, parseDelayToMilliseconds as p, getInitialSnapshot as q, resolveActionsWithContext as r, subscriptionLogic as s, toArray as t, getNextSnapshot as u, isMachineSnapshot as v, withActorScope as w, getStateNodes as x, getAllOwnEventDescriptors as y, matchesState as z };
+export { evaluateCandidate as $, Actor as A, checkStateIn as B, pathToStateValue as C, toObserver as D, executeEffects as E, isBuiltInExecutableAction as F, deliverEvent as G, runStep as H, stopActor as I, terminateActor as J, createInitEvent as K, createCustomEffect as L, XSTATE_LOGIC_EFFECT_START as M, XSTATE_LOGIC_EFFECT_RESOLVE as N, XSTATE_LOGIC_EFFECT_REJECT as O, createEmitEffect as P, resolveRegisteredActorSource as Q, allocateChildId as R, assertChildIdFree as S, reserveChildId as T, STATE_DELIMITER as U, mapValues as V, createInvokeId as W, XSTATE_INIT as X, getDelayedTransitions as Y, getEventDescriptorKey as Z, getCandidates as _, beginSpawnAllocation as a, formatTransition as a0, NULL_EVENT as a1, toTransitionConfigArray as a2, createInvokeTimeoutEventId as a3, matchesActorSession as a4, formatRouteTransitions as a5, resolveStateValue as a6, getAllStateNodes as a7, createMachineSnapshot as a8, isInFinalState as a9, getProperAncestors as aA, isRemoteActorRef as aB, getActorIdPrefix as aC, getAllOwnEvents as aD, matchesEvent as aE, encodeAddressSegment as aF, getRootActorId as aG, RUNTIME_OPERATIONS as aH, withSystemInspector as aI, getSnapshotActorRef as aJ, withExecutionIdentity as aK, createInertActorScope as aa, setInertActorScopeSnapshot as ab, attachSnapshotActorRef as ac, macrostep as ad, isInertActorScope as ae, setSnapshotActorRef as af, cloneMachineSnapshot as ag, transitionNode as ah, getTransitionResult as ai, hasEffect as aj, createErrorPlatformEvent as ak, withActorSelf as al, takeSpawnAllocationCounters as am, mergeActorIdCounters as an, createSpawnEffect as ao, initialMicrostep as ap, toStatePath as aq, isStateId as ar, getStateNodeByPath as as, getPersistedSnapshot as at, createRemoteActorRef as au, resolveReferencedActor as av, createInvokeTimeoutEvent as aw, parseGeneratedActorId as ax, ACTOR_REF_TYPE as ay, hasAmbientInspector as az, builtInActions as b, createTransitionEnqueue as c, deriveDeferredStarts as d, XSTATE_STOP as e, finalizeTransitionResult as f, XSTATE_TIMER as g, createSendToEffect as h, isLazyActorScope as i, isAtomicStateNode as j, createActor as k, createListenerLogic as l, matchesEventDescriptor as m, createSubscriptionLogic as n, listenerLogic as o, parseDelayToMilliseconds as p, getInitialSnapshot as q, resolveActionsWithContext as r, subscriptionLogic as s, toArray as t, getNextSnapshot as u, isMachineSnapshot as v, withActorScope as w, getStateNodes as x, getAllOwnEventDescriptors as y, matchesState as z };

package/dist/{createActor-60ee6b5b.development.esm.js → createActor-f5277b31.development.esm.js}

@@ -218,6 +218,27 @@ const builtInActions = {
   }
 };
 
+const sourceKeyCaches = new WeakMap();
+
+/** @internal */
+function resolveRegisteredActorSource(actors, logic) {
+  let cache = sourceKeyCaches.get(actors);
+  if (!cache) {
+    cache = new Map();
+    for (const key of Object.keys(actors)) {
+      const registeredLogic = actors[key];
+      // Several source keys may intentionally share one implementation. The
+      // first key is its canonical persistence identity when spawning by the
+      // raw logic value, which cannot retain which alias was used to access it.
+      if (!cache.has(registeredLogic)) {
+        cache.set(registeredLogic, key);
+      }
+    }
+    sourceKeyCaches.set(actors, cache);
+  }
+  return cache.get(logic);
+}
+
 const subscriptions = /* #__PURE__ */new WeakMap();
 
 /**
@@ -665,21 +686,31 @@ function beginSpawnAllocation(actorScope) {
 function getWorkingSnapshotOf(actorScope) {
   return actorScope.self._snapshot;
 }
-const srcKeyCaches = new WeakMap();
-function getRegisteredSrcKey(actorScope, logic) {
-  const registeredActors = actorScope.self.logic?.sources?.actors;
-  if (!registeredActors) {
-    return undefined;
-  }
-  let cache = srcKeyCaches.get(registeredActors);
-  if (!cache) {
-    cache = new Map();
-    for (const key of Object.keys(registeredActors)) {
-      cache.set(registeredActors[key], key);
+function getRegisteredActors(actorScope) {
+  return actorScope.self.logic?.sources?.actors;
+}
+function resolveTransitionSpawnSource(actorScope, source) {
+  const registeredActors = getRegisteredActors(actorScope);
+  if (typeof source === 'string') {
+    const logic = registeredActors?.[source];
+    if (!logic) {
+      throw new Error(`Actor source '${source}' is not provided`);
     }
-    srcKeyCaches.set(registeredActors, cache);
+    return {
+      logic,
+      src: source
+    };
   }
-  return cache.get(logic);
+  if (!registeredActors) {
+    return {
+      logic: source,
+      src: undefined
+    };
+  }
+  return {
+    logic: source,
+    src: resolveRegisteredActorSource(registeredActors, source)
+  };
 }
 
 /**
@@ -827,17 +858,17 @@ function createTransitionEnqueue(actorScope, actions, internalEvents, actorSubsc
         internalEvents.push(raisedEvent);
       }
     },
-    spawn: (logic, options) => {
+    spawn: (source, options) => {
+      const {
+        logic,
+        src
+      } = resolveTransitionSpawnSource(actorScope, source);
       if (!createActors) {
         // TODO: replace this speculative placeholder with a typed inert actor ref.
         return {
-          id: options?.id ?? options?.registryKey ?? logic.id
+          id: options?.id ?? options?.registryKey ?? src ?? logic.id
         };
       }
-      // Recover the registered source key for setup-provided logic so the
-      // spawned child persists (and gets a deterministic id prefix) by key
-      // instead of by inline logic reference.
-      const src = getRegisteredSrcKey(actorScope, logic);
       // Generated ids allocate from the parent snapshot's own counters
       // through the transition's allocation transaction; explicit
       // generated-shaped ids reserve their numbering the same way.
@@ -5704,4 +5735,4 @@ function createActor(logic, options) {
   return new Actor(logic, options);
 }
 
-export { formatTransition as $, Actor as A, checkStateIn as B, pathToStateValue as C, toObserver as D, executeEffects as E, isBuiltInExecutableAction as F, deliverEvent as G, runStep as H, stopActor as I, terminateActor as J, createInitEvent as K, createCustomEffect as L, XSTATE_LOGIC_EFFECT_START as M, XSTATE_LOGIC_EFFECT_RESOLVE as N, XSTATE_LOGIC_EFFECT_REJECT as O, createEmitEffect as P, allocateChildId as Q, assertChildIdFree as R, reserveChildId as S, STATE_DELIMITER as T, mapValues as U, createInvokeId as V, getDelayedTransitions as W, XSTATE_INIT as X, getEventDescriptorKey as Y, getCandidates as Z, evaluateCandidate as _, beginSpawnAllocation as a, NULL_EVENT as a0, toTransitionConfigArray as a1, createInvokeTimeoutEventId as a2, matchesActorSession as a3, formatRouteTransitions as a4, resolveStateValue as a5, getAllStateNodes as a6, createMachineSnapshot as a7, isInFinalState as a8, createInertActorScope as a9, isRemoteActorRef as aA, getActorIdPrefix as aB, getAllOwnEvents as aC, matchesEvent as aD, encodeAddressSegment as aE, getRootActorId as aF, RUNTIME_OPERATIONS as aG, withSystemInspector as aH, getSnapshotActorRef as aI, withExecutionIdentity as aJ, setInertActorScopeSnapshot as aa, attachSnapshotActorRef as ab, macrostep as ac, isInertActorScope as ad, setSnapshotActorRef as ae, cloneMachineSnapshot as af, transitionNode as ag, getTransitionResult as ah, hasEffect as ai, createErrorPlatformEvent as aj, withActorSelf as ak, takeSpawnAllocationCounters as al, mergeActorIdCounters as am, createSpawnEffect as an, initialMicrostep as ao, toStatePath as ap, isStateId as aq, getStateNodeByPath as ar, getPersistedSnapshot as as, createRemoteActorRef as at, resolveReferencedActor as au, createInvokeTimeoutEvent as av, parseGeneratedActorId as aw, ACTOR_REF_TYPE as ax, hasAmbientInspector as ay, getProperAncestors as az, builtInActions as b, createTransitionEnqueue as c, deriveDeferredStarts as d, XSTATE_STOP as e, finalizeTransitionResult as f, XSTATE_TIMER as g, createSendToEffect as h, isLazyActorScope as i, isAtomicStateNode as j, createActor as k, createListenerLogic as l, matchesEventDescriptor as m, createSubscriptionLogic as n, listenerLogic as o, parseDelayToMilliseconds as p, getInitialSnapshot as q, resolveActionsWithContext as r, subscriptionLogic as s, toArray as t, getNextSnapshot as u, isMachineSnapshot as v, withActorScope as w, getStateNodes as x, getAllOwnEventDescriptors as y, matchesState as z };
+export { evaluateCandidate as $, Actor as A, checkStateIn as B, pathToStateValue as C, toObserver as D, executeEffects as E, isBuiltInExecutableAction as F, deliverEvent as G, runStep as H, stopActor as I, terminateActor as J, createInitEvent as K, createCustomEffect as L, XSTATE_LOGIC_EFFECT_START as M, XSTATE_LOGIC_EFFECT_RESOLVE as N, XSTATE_LOGIC_EFFECT_REJECT as O, createEmitEffect as P, resolveRegisteredActorSource as Q, allocateChildId as R, assertChildIdFree as S, reserveChildId as T, STATE_DELIMITER as U, mapValues as V, createInvokeId as W, XSTATE_INIT as X, getDelayedTransitions as Y, getEventDescriptorKey as Z, getCandidates as _, beginSpawnAllocation as a, formatTransition as a0, NULL_EVENT as a1, toTransitionConfigArray as a2, createInvokeTimeoutEventId as a3, matchesActorSession as a4, formatRouteTransitions as a5, resolveStateValue as a6, getAllStateNodes as a7, createMachineSnapshot as a8, isInFinalState as a9, getProperAncestors as aA, isRemoteActorRef as aB, getActorIdPrefix as aC, getAllOwnEvents as aD, matchesEvent as aE, encodeAddressSegment as aF, getRootActorId as aG, RUNTIME_OPERATIONS as aH, withSystemInspector as aI, getSnapshotActorRef as aJ, withExecutionIdentity as aK, createInertActorScope as aa, setInertActorScopeSnapshot as ab, attachSnapshotActorRef as ac, macrostep as ad, isInertActorScope as ae, setSnapshotActorRef as af, cloneMachineSnapshot as ag, transitionNode as ah, getTransitionResult as ai, hasEffect as aj, createErrorPlatformEvent as ak, withActorSelf as al, takeSpawnAllocationCounters as am, mergeActorIdCounters as an, createSpawnEffect as ao, initialMicrostep as ap, toStatePath as aq, isStateId as ar, getStateNodeByPath as as, getPersistedSnapshot as at, createRemoteActorRef as au, resolveReferencedActor as av, createInvokeTimeoutEvent as aw, parseGeneratedActorId as ax, ACTOR_REF_TYPE as ay, hasAmbientInspector as az, builtInActions as b, createTransitionEnqueue as c, deriveDeferredStarts as d, XSTATE_STOP as e, finalizeTransitionResult as f, XSTATE_TIMER as g, createSendToEffect as h, isLazyActorScope as i, isAtomicStateNode as j, createActor as k, createListenerLogic as l, matchesEventDescriptor as m, createSubscriptionLogic as n, listenerLogic as o, parseDelayToMilliseconds as p, getInitialSnapshot as q, resolveActionsWithContext as r, subscriptionLogic as s, toArray as t, getNextSnapshot as u, isMachineSnapshot as v, withActorScope as w, getStateNodes as x, getAllOwnEventDescriptors as y, matchesState as z };

package/dist/{createActor-5c9fa117.development.cjs.js → createActor-f6e6146f.development.cjs.js}

@@ -220,6 +220,27 @@ const builtInActions = {
   }
 };
 
+const sourceKeyCaches = new WeakMap();
+
+/** @internal */
+function resolveRegisteredActorSource(actors, logic) {
+  let cache = sourceKeyCaches.get(actors);
+  if (!cache) {
+    cache = new Map();
+    for (const key of Object.keys(actors)) {
+      const registeredLogic = actors[key];
+      // Several source keys may intentionally share one implementation. The
+      // first key is its canonical persistence identity when spawning by the
+      // raw logic value, which cannot retain which alias was used to access it.
+      if (!cache.has(registeredLogic)) {
+        cache.set(registeredLogic, key);
+      }
+    }
+    sourceKeyCaches.set(actors, cache);
+  }
+  return cache.get(logic);
+}
+
 const subscriptions = /* #__PURE__ */new WeakMap();
 
 /**
@@ -667,21 +688,31 @@ function beginSpawnAllocation(actorScope) {
 function getWorkingSnapshotOf(actorScope) {
   return actorScope.self._snapshot;
 }
-const srcKeyCaches = new WeakMap();
-function getRegisteredSrcKey(actorScope, logic) {
-  const registeredActors = actorScope.self.logic?.sources?.actors;
-  if (!registeredActors) {
-    return undefined;
-  }
-  let cache = srcKeyCaches.get(registeredActors);
-  if (!cache) {
-    cache = new Map();
-    for (const key of Object.keys(registeredActors)) {
-      cache.set(registeredActors[key], key);
+function getRegisteredActors(actorScope) {
+  return actorScope.self.logic?.sources?.actors;
+}
+function resolveTransitionSpawnSource(actorScope, source) {
+  const registeredActors = getRegisteredActors(actorScope);
+  if (typeof source === 'string') {
+    const logic = registeredActors?.[source];
+    if (!logic) {
+      throw new Error(`Actor source '${source}' is not provided`);
     }
-    srcKeyCaches.set(registeredActors, cache);
+    return {
+      logic,
+      src: source
+    };
   }
-  return cache.get(logic);
+  if (!registeredActors) {
+    return {
+      logic: source,
+      src: undefined
+    };
+  }
+  return {
+    logic: source,
+    src: resolveRegisteredActorSource(registeredActors, source)
+  };
 }
 
 /**
@@ -829,17 +860,17 @@ function createTransitionEnqueue(actorScope, actions, internalEvents, actorSubsc
         internalEvents.push(raisedEvent);
       }
     },
-    spawn: (logic, options) => {
+    spawn: (source, options) => {
+      const {
+        logic,
+        src
+      } = resolveTransitionSpawnSource(actorScope, source);
       if (!createActors) {
         // TODO: replace this speculative placeholder with a typed inert actor ref.
         return {
-          id: options?.id ?? options?.registryKey ?? logic.id
+          id: options?.id ?? options?.registryKey ?? src ?? logic.id
         };
       }
-      // Recover the registered source key for setup-provided logic so the
-      // spawned child persists (and gets a deterministic id prefix) by key
-      // instead of by inline logic reference.
-      const src = getRegisteredSrcKey(actorScope, logic);
       // Generated ids allocate from the parent snapshot's own counters
       // through the transition's allocation transaction; explicit
       // generated-shaped ids reserve their numbering the same way.
@@ -5789,6 +5820,7 @@ exports.pathToStateValue = pathToStateValue;
 exports.reserveChildId = reserveChildId;
 exports.resolveActionsWithContext = resolveActionsWithContext;
 exports.resolveReferencedActor = resolveReferencedActor;
+exports.resolveRegisteredActorSource = resolveRegisteredActorSource;
 exports.resolveStateValue = resolveStateValue;
 exports.runStep = runStep;
 exports.setInertActorScopeSnapshot = setInertActorScopeSnapshot;

package/dist/declarations/src/setup.d.ts

@@ -424,7 +424,7 @@ type StateTransitionFunction<TStateSchemas extends Record<string, SetupStateSche
     guards: TGuardMap;
     delays: TDelayMap;
     input: TInput;
-} & OutputArg<TExpressionEvent>, enq: EnqueueObject<TEvent, TEmitted, TSystemRegistry>) => StateTransitionResult<TStateSchemas, TContext, TContextShape, TMeta, TExpressionEvent, TChildren, TActionMap, TActorMap, TGuardMap, TDelayMap, TSystemRegistry, false> | void;
+} & OutputArg<TExpressionEvent>, enq: EnqueueObject<TEvent, TEmitted, TSystemRegistry, TActorMap>) => StateTransitionResult<TStateSchemas, TContext, TContextShape, TMeta, TExpressionEvent, TChildren, TActionMap, TActorMap, TGuardMap, TDelayMap, TSystemRegistry, false> | void;
 type StateTransitionResult<TStateSchemas extends Record<string, SetupStateSchema>, TContext extends MachineContext, TContextShape, TMeta extends MetaObject, TExpressionEvent extends EventObject, TChildren extends Record<string, AnyActorRef | undefined>, TActionMap extends Sources['actions'], TActorMap extends Sources['actors'], TGuardMap extends Sources['guards'], TDelayMap extends Sources['delays'], TSystemRegistry extends SystemRegistry, TAllowContextMapper extends boolean> = {
     target?: never;
     context?: StateTransitionContext<TAllowContextMapper, TContext, TContextShape, TContextShape, TContext, TExpressionEvent, TChildren, TActionMap, TActorMap, TGuardMap, TDelayMap, TSystemRegistry>;

package/dist/declarations/src/types.d.ts

@@ -209,7 +209,7 @@ export type TransitionConfigTarget = string | undefined;
 export type TransitionConfigOrTarget<TContext extends MachineContext, TExpressionEvent extends EventObject, TEvent extends EventObject, TEmitted extends EventObject, TMeta extends MetaObject, TActionMap extends Sources['actions'], TActorMap extends Sources['actors'], TGuardMap extends Sources['guards'], TDelayMap extends Sources['delays']> = SingleOrArray<TransitionConfigTarget | TransitionConfig<TContext, TExpressionEvent, TEvent, TEmitted, TMeta, TActionMap, TActorMap, TGuardMap, TDelayMap> | TransitionConfigFunction<TContext, TExpressionEvent, TEvent, TEmitted, TActionMap, TActorMap, TGuardMap, TDelayMap, TMeta>>;
 export type TransitionConfigFunction<TContext extends MachineContext, TCurrentEvent extends EventObject, TEvent extends EventObject, TEmitted extends EventObject, TActionMap extends Sources['actions'], TActorMap extends Sources['actors'], TGuardMap extends Sources['guards'], TDelayMap extends Sources['delays'], TMeta extends MetaObject, TInput = undefined, _TCtx extends MachineContext = [TContext] extends [never] ? any : TContext> = (args: TransitionFunctionArgs<_TCtx, TCurrentEvent, TEvent, TActionMap, TActorMap, TGuardMap, TDelayMap> & {
     input: TInput;
-}, enq: EnqueueObject<TEvent, TEmitted>) => {
+}, enq: EnqueueObject<TEvent, TEmitted, SystemRegistry, TActorMap>) => {
     target?: string | string[];
     context?: TransitionContextPatch<_TCtx>;
     reenter?: boolean;
@@ -1210,24 +1210,34 @@ export interface SubscribeToMappers<TSnapshot extends Snapshot<unknown>, TOutput
     done?: (output: TOutput) => TMappedEvent;
     error?: (error: unknown) => TMappedEvent;
 }
-export type EnqueueObject<TEvent extends EventObject, TEmittedEvent extends EventObject, TSystemRegistry extends SystemRegistry = SystemRegistry> = {
+type EnqueueSpawnOptions<TLogic extends AnyActorLogic, TSystemRegistry extends SystemRegistry> = {
+    input?: InputFrom<TLogic>;
+    id?: string;
+    syncSnapshot?: boolean;
+    registryKey?: RegistryKeyForLogic<TLogic, TSystemRegistry>;
+};
+type EnqueueSpawnArgs<TLogic extends AnyActorLogic, TSystemRegistry extends SystemRegistry> = ConditionalRequired<[
+    options?: EnqueueSpawnOptions<TLogic, TSystemRegistry> & {
+        [K in RequiredLogicInput<TLogic>]: unknown;
+    }
+], IsNotNever<RequiredLogicInput<TLogic>>>;
+type EnqueueSpawner<TActorMap extends Sources['actors'], TSystemRegistry extends SystemRegistry> = {
+    <TSource extends keyof TActorMap & string>(src: TSource, ...[options]: EnqueueSpawnArgs<TActorMap[TSource], TSystemRegistry>): ActorFromLogic<TActorMap[TSource]>;
+    <TLogic extends AnyActorLogic>(logic: TLogic, ...[options]: EnqueueSpawnArgs<TLogic, TSystemRegistry>): ActorFromLogic<TLogic>;
+};
+export type EnqueueObject<TEvent extends EventObject, TEmittedEvent extends EventObject, TSystemRegistry extends SystemRegistry = SystemRegistry, TActorMap extends Sources['actors'] = Sources['actors']> = {
     cancel: (id: string) => void;
     raise: (ev: TEvent, options?: {
         id?: string;
         delay?: number;
     }) => void;
     /**
-     * Spawns a child actor from the given logic. Without an explicit `id`, the
-     * child gets a deterministic src-keyed id (`worker:0`, `worker:1`, …)
-     * allocated from the parent snapshot's own counters, so ids replay
-     * identically and persist with the parent.
+     * Spawns a child actor from a registered source key or logic. Without an
+     * explicit `id`, the child gets a deterministic src-keyed id (`worker:0`,
+     * `worker:1`, …) allocated from the parent snapshot's own counters, so ids
+     * replay identically and persist with the parent.
      */
-    spawn: <T extends AnyActorLogic>(logic: T, options?: {
-        input?: InputFrom<T>;
-        id?: string;
-        syncSnapshot?: boolean;
-        registryKey?: RegistryKeyForLogic<T, TSystemRegistry>;
-    }) => ActorFromLogic<T>;
+    spawn: EnqueueSpawner<TActorMap, TSystemRegistry>;
     emit: (emittedEvent: TEmittedEvent) => void;
     <T extends (...args: any[]) => any>(fn: T, ...args: Parameters<T>): void;
     log: (...args: any[]) => void;
@@ -1270,7 +1280,7 @@ export type Action<TContext extends MachineContext, TEvent extends EventObject,
     delays: TDelayMap;
     system?: AnyActorSystem;
     params: TParams;
-}, enqueue: EnqueueObject<TEvent, TEmittedEvent>) => {
+}, enqueue: EnqueueObject<TEvent, TEmittedEvent, SystemRegistry, TActorMap>) => {
     context?: Partial<_TCtx>;
     children?: Record<string, AnyActor | undefined>;
 } | void;

package/dist/{effectDescriptor-adb27412.cjs.js → effectDescriptor-3a016bbe.cjs.js}

@@ -1,6 +1,6 @@
 'use strict';
 
-var createActor = require('./createActor-48401456.cjs.js');
+var createActor = require('./createActor-0816a84b.cjs.js');
 
 function attachMicrostepActorRefs(microsteps, actorScope, inputSnapshot) {
   if (!microsteps.length) {

package/dist/{effectDescriptor-dffb91a8.esm.js → effectDescriptor-87826c41.esm.js}

@@ -1,4 +1,4 @@
-import { a9 as createInertActorScope, aa as setInertActorScopeSnapshot, f as finalizeTransitionResult, ab as attachSnapshotActorRef, K as createInitEvent, ay as hasAmbientInspector, a as beginSpawnAllocation, ac as macrostep, an as createSpawnEffect, ao as initialMicrostep, j as isAtomicStateNode, az as getProperAncestors, aA as isRemoteActorRef, aB as getActorIdPrefix } from './createActor-641ab5f7.esm.js';
+import { aa as createInertActorScope, ab as setInertActorScopeSnapshot, f as finalizeTransitionResult, ac as attachSnapshotActorRef, K as createInitEvent, az as hasAmbientInspector, a as beginSpawnAllocation, ad as macrostep, ao as createSpawnEffect, ap as initialMicrostep, j as isAtomicStateNode, aA as getProperAncestors, aB as isRemoteActorRef, aC as getActorIdPrefix } from './createActor-9523f716.esm.js';
 
 function attachMicrostepActorRefs(microsteps, actorScope, inputSnapshot) {
   if (!microsteps.length) {

package/dist/{effectDescriptor-0cba79a1.development.cjs.js → effectDescriptor-8a5d62e0.development.cjs.js}

@@ -1,6 +1,6 @@
 'use strict';
 
-var createActor = require('./createActor-5c9fa117.development.cjs.js');
+var createActor = require('./createActor-f6e6146f.development.cjs.js');
 
 function attachMicrostepActorRefs(microsteps, actorScope, inputSnapshot) {
   if (!microsteps.length) {

package/dist/{effectDescriptor-fed26db6.development.esm.js → effectDescriptor-9a14147f.development.esm.js}

@@ -1,4 +1,4 @@
-import { a9 as createInertActorScope, aa as setInertActorScopeSnapshot, f as finalizeTransitionResult, ab as attachSnapshotActorRef, K as createInitEvent, ay as hasAmbientInspector, a as beginSpawnAllocation, ac as macrostep, an as createSpawnEffect, ao as initialMicrostep, j as isAtomicStateNode, az as getProperAncestors, aA as isRemoteActorRef, aB as getActorIdPrefix } from './createActor-60ee6b5b.development.esm.js';
+import { aa as createInertActorScope, ab as setInertActorScopeSnapshot, f as finalizeTransitionResult, ac as attachSnapshotActorRef, K as createInitEvent, az as hasAmbientInspector, a as beginSpawnAllocation, ad as macrostep, ao as createSpawnEffect, ap as initialMicrostep, j as isAtomicStateNode, aA as getProperAncestors, aB as isRemoteActorRef, aC as getActorIdPrefix } from './createActor-f5277b31.development.esm.js';
 
 function attachMicrostepActorRefs(microsteps, actorScope, inputSnapshot) {
   if (!microsteps.length) {