xstate 6.0.0-alpha.45 → 6.0.0-alpha.47

package/dist/{StateMachine-2eecedfe.cjs.js → StateMachine-7046f677.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-bfe8b6bd.cjs.js');
+var dist_xstateActors = require('./index-b3fe59bc.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.
@@ -1020,7 +1020,11 @@ class StateMachine {
   restoreSnapshot(snapshot, actorScope) {
     const usesInertScope = !actorScope;
     const resolvedActorScope = actorScope ?? createActor.createInertActorScope(this);
-    const persistedMachine = snapshot.machine;
+    const snapshotMachine = snapshot.machine;
+    // A live machine snapshot carries its producing machine so helpers such as
+    // `matches()` can resolve state nodes. That runtime association is not the
+    // persisted `{ id, version }` identity written by getPersistedSnapshot().
+    const persistedMachine = snapshotMachine && typeof snapshotMachine === 'object' && typeof snapshotMachine.transition === 'function' && 'root' in snapshotMachine ? undefined : snapshotMachine;
     const legacyPersistedVersion = snapshot.version;
     const persistedVersion = typeof persistedMachine?.version === 'string' ? persistedMachine.version : legacyPersistedVersion;
     if (legacyPersistedVersion !== undefined && persistedMachine?.version !== undefined && persistedMachine.version !== legacyPersistedVersion) {

package/dist/{StateMachine-5b915fb1.development.cjs.js → StateMachine-70c06bdd.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-6736cbbe.development.cjs.js');
+var dist_xstateActors = require('./index-0f498ef2.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.
@@ -1049,7 +1049,11 @@ class StateMachine {
   restoreSnapshot(snapshot, actorScope) {
     const usesInertScope = !actorScope;
     const resolvedActorScope = actorScope ?? createActor.createInertActorScope(this);
-    const persistedMachine = snapshot.machine;
+    const snapshotMachine = snapshot.machine;
+    // A live machine snapshot carries its producing machine so helpers such as
+    // `matches()` can resolve state nodes. That runtime association is not the
+    // persisted `{ id, version }` identity written by getPersistedSnapshot().
+    const persistedMachine = snapshotMachine && typeof snapshotMachine === 'object' && typeof snapshotMachine.transition === 'function' && 'root' in snapshotMachine ? undefined : snapshotMachine;
     const legacyPersistedVersion = snapshot.version;
     const persistedVersion = typeof persistedMachine?.version === 'string' ? persistedMachine.version : legacyPersistedVersion;
     if (legacyPersistedVersion !== undefined && persistedMachine?.version !== undefined && persistedMachine.version !== legacyPersistedVersion) {

package/dist/{StateMachine-d2fcf2e8.esm.js → StateMachine-74929087.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-915ea40c.esm.js';
+import { g as assertValid } from './index-b051c924.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.
@@ -1018,7 +1018,11 @@ class StateMachine {
   restoreSnapshot(snapshot, actorScope) {
     const usesInertScope = !actorScope;
     const resolvedActorScope = actorScope ?? createInertActorScope(this);
-    const persistedMachine = snapshot.machine;
+    const snapshotMachine = snapshot.machine;
+    // A live machine snapshot carries its producing machine so helpers such as
+    // `matches()` can resolve state nodes. That runtime association is not the
+    // persisted `{ id, version }` identity written by getPersistedSnapshot().
+    const persistedMachine = snapshotMachine && typeof snapshotMachine === 'object' && typeof snapshotMachine.transition === 'function' && 'root' in snapshotMachine ? undefined : snapshotMachine;
     const legacyPersistedVersion = snapshot.version;
     const persistedVersion = typeof persistedMachine?.version === 'string' ? persistedMachine.version : legacyPersistedVersion;
     if (legacyPersistedVersion !== undefined && persistedMachine?.version !== undefined && persistedMachine.version !== legacyPersistedVersion) {

package/dist/{StateMachine-4bf86161.development.esm.js → StateMachine-ee10f67e.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-ff132afa.development.esm.js';
+import { g as assertValid } from './index-70d56425.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.
@@ -1047,7 +1047,11 @@ class StateMachine {
   restoreSnapshot(snapshot, actorScope) {
     const usesInertScope = !actorScope;
     const resolvedActorScope = actorScope ?? createInertActorScope(this);
-    const persistedMachine = snapshot.machine;
+    const snapshotMachine = snapshot.machine;
+    // A live machine snapshot carries its producing machine so helpers such as
+    // `matches()` can resolve state nodes. That runtime association is not the
+    // persisted `{ id, version }` identity written by getPersistedSnapshot().
+    const persistedMachine = snapshotMachine && typeof snapshotMachine === 'object' && typeof snapshotMachine.transition === 'function' && 'root' in snapshotMachine ? undefined : snapshotMachine;
     const legacyPersistedVersion = snapshot.version;
     const persistedVersion = typeof persistedMachine?.version === 'string' ? persistedMachine.version : legacyPersistedVersion;
     if (legacyPersistedVersion !== undefined && persistedMachine?.version !== undefined && persistedMachine.version !== legacyPersistedVersion) {

package/dist/{createActor-5c9fa117.development.cjs.js → createActor-6736cbbe.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.
@@ -877,12 +908,15 @@ function createTransitionEnqueue(actorScope, actions, internalEvents, actorSubsc
     },
     stop: actor => {
       if (actor) {
-        const action = pushBuiltInAction(actions, builtInActions['@xstate.stop'], actorScope, actor);
+        // enq.stop accepts the consumer ActorRef contract; refs handed to
+        // machine code are always full actor instances at runtime.
+        const actorInstance = actor;
+        const action = pushBuiltInAction(actions, builtInActions['@xstate.stop'], actorScope, actorInstance);
         action.childUpdate = {
           type: 'remove',
-          actor
+          actor: actorInstance
         };
-        recordStoppedChild(actorScope, actor);
+        recordStoppedChild(actorScope, actorInstance);
       }
     }
   };
@@ -5789,6 +5823,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-915ea40c.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.
@@ -867,12 +898,15 @@ function createTransitionEnqueue(actorScope, actions, internalEvents, actorSubsc
     },
     stop: actor => {
       if (actor) {
-        const action = pushBuiltInAction(actions, builtInActions['@xstate.stop'], actorScope, actor);
+        // enq.stop accepts the consumer ActorRef contract; refs handed to
+        // machine code are always full actor instances at runtime.
+        const actorInstance = actor;
+        const action = pushBuiltInAction(actions, builtInActions['@xstate.stop'], actorScope, actorInstance);
         action.childUpdate = {
           type: 'remove',
-          actor
+          actor: actorInstance
         };
-        recordStoppedChild(actorScope, actor);
+        recordStoppedChild(actorScope, actorInstance);
       }
     }
   };
@@ -3697,6 +3731,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 +5699,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-48401456.cjs.js → createActor-bfe8b6bd.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.
@@ -869,12 +900,15 @@ function createTransitionEnqueue(actorScope, actions, internalEvents, actorSubsc
     },
     stop: actor => {
       if (actor) {
-        const action = pushBuiltInAction(actions, builtInActions['@xstate.stop'], actorScope, actor);
+        // enq.stop accepts the consumer ActorRef contract; refs handed to
+        // machine code are always full actor instances at runtime.
+        const actorInstance = actor;
+        const action = pushBuiltInAction(actions, builtInActions['@xstate.stop'], actorScope, actorInstance);
         action.childUpdate = {
           type: 'remove',
-          actor
+          actor: actorInstance
         };
-        recordStoppedChild(actorScope, actor);
+        recordStoppedChild(actorScope, actorInstance);
       }
     }
   };
@@ -3699,6 +3733,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 +5784,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-60ee6b5b.development.esm.js → createActor-ff132afa.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.
@@ -875,12 +906,15 @@ function createTransitionEnqueue(actorScope, actions, internalEvents, actorSubsc
     },
     stop: actor => {
       if (actor) {
-        const action = pushBuiltInAction(actions, builtInActions['@xstate.stop'], actorScope, actor);
+        // enq.stop accepts the consumer ActorRef contract; refs handed to
+        // machine code are always full actor instances at runtime.
+        const actorInstance = actor;
+        const action = pushBuiltInAction(actions, builtInActions['@xstate.stop'], actorScope, actorInstance);
         action.childUpdate = {
           type: 'remove',
-          actor
+          actor: actorInstance
         };
-        recordStoppedChild(actorScope, actor);
+        recordStoppedChild(actorScope, actorInstance);
       }
     }
   };
@@ -5704,4 +5738,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 };