xstate 6.0.0-alpha.36 → 6.0.0-alpha.38

package/dist/{StateMachine-c6fc9d29.cjs.js → StateMachine-18e71e29.cjs.js}

@@ -1,6 +1,7 @@
 'use strict';
 
-var dist_xstateActors = require('./index-9683e24d.cjs.js');
+var createActor = require('./createActor-fd53ec92.cjs.js');
+var dist_xstateActors = require('./index-13e54113.cjs.js');
 
 function createSpawner(actorScope, actors, spawnedChildren) {
   return (src, options) => {
@@ -105,14 +106,14 @@ class StateNode {
     this.machine = options._machine;
     this.path = this.parent ? this.parent.path.concat(this.key) : [];
     const firstStateKey = this.config.states ? Object.keys(this.config.states)[0] : undefined;
-    this.id = this.config.id || [this.machine.id, ...this.path].join(dist_xstateActors.STATE_DELIMITER);
+    this.id = this.config.id || [this.machine.id, ...this.path].join(createActor.STATE_DELIMITER);
     this.type = this.config.type || (firstStateKey !== undefined ? 'compound' : this.config.history ? 'history' : 'atomic');
     this.description = this.config.description;
     this.schemas = this.config.schemas;
     validateStateNodeConfig(this);
     this.order = this.machine.idMap.size;
     this.machine.idMap.set(this.id, this);
-    this.states = this.config.states ? dist_xstateActors.mapValues(this.config.states, (stateConfig, key) => {
+    this.states = this.config.states ? createActor.mapValues(this.config.states, (stateConfig, key) => {
       const stateNode = new StateNode(stateConfig, {
         _parent: this,
         _key: key,
@@ -138,13 +139,13 @@ class StateNode {
     }
     this.meta = this.config.meta;
     this.output = this.type === 'final' || !this.parent ? this.config.output : undefined;
-    this.tags = dist_xstateActors.toArray(config.tags).slice();
-    this.invoke = dist_xstateActors.toArray(this.config.invoke).map((invokeConfig, i) => {
+    this.tags = createActor.toArray(config.tags).slice();
+    this.invoke = createActor.toArray(this.config.invoke).map((invokeConfig, i) => {
       const {
         src,
         registryKey
       } = invokeConfig;
-      const invokeId = dist_xstateActors.createInvokeId(this.id, i);
+      const invokeId = createActor.createInvokeId(this.id, i);
       const resolvedId = invokeConfig.id ?? invokeId;
       // Referenced (string) actors keep their logical name so persisted
       // snapshots reference `src: 'fetchUser'` rather than a positional id;
@@ -162,12 +163,12 @@ class StateNode {
 
   /** @internal */
   _initialize() {
-    this.after = dist_xstateActors.getDelayedTransitions(this);
+    this.after = createActor.getDelayedTransitions(this);
     this.transitions = formatTransitions(this);
     if (this.type === 'choice') {
       this.always = formatChoiceTransitions(this);
     } else if (this.config.always) {
-      this.always = mapTransitionConfigs(this.config.always, transition => dist_xstateActors.formatTransition(this, dist_xstateActors.NULL_EVENT, transition));
+      this.always = mapTransitionConfigs(this.config.always, transition => createActor.formatTransition(this, createActor.NULL_EVENT, transition));
     }
     for (const key of Object.keys(this.states)) {
       this.states[key]._initialize();
@@ -201,14 +202,14 @@ class StateNode {
 
   /** @internal */
   next(snapshot, event, actorScope, selectionResults) {
-    const descriptorKey = dist_xstateActors.getEventDescriptorKey(event);
+    const descriptorKey = createActor.getEventDescriptorKey(event);
     let candidates = this._candidateCache?.get(descriptorKey);
     if (!candidates) {
-      candidates = dist_xstateActors.getCandidates(this, event);
+      candidates = createActor.getCandidates(this, event);
       (this._candidateCache ??= new Map()).set(descriptorKey, candidates);
     }
     for (const candidate of candidates) {
-      const guardPassed = dist_xstateActors.evaluateCandidate(candidate, event, snapshot, this, actorScope, selectionResults);
+      const guardPassed = createActor.evaluateCandidate(candidate, event, snapshot, this, actorScope, selectionResults);
       if (guardPassed) {
         return [candidate];
       }
@@ -236,12 +237,12 @@ function formatChoiceTransitions(stateNode) {
     }
     return result;
   };
-  return [dist_xstateActors.formatTransition(stateNode, dist_xstateActors.NULL_EVENT, {
+  return [createActor.formatTransition(stateNode, createActor.NULL_EVENT, {
     to: args => validateChoiceResult(choice(args))
   })];
 }
 function mapTransitionConfigs(transitionsConfig, mapper) {
-  const transitionConfigs = dist_xstateActors.toTransitionConfigArray(transitionsConfig);
+  const transitionConfigs = createActor.toTransitionConfigArray(transitionsConfig);
   const transitions = new Array(transitionConfigs.length);
   for (let i = 0; i < transitionConfigs.length; i++) {
     transitions[i] = mapper(transitionConfigs[i]);
@@ -255,16 +256,16 @@ function formatTransitions(stateNode) {
   };
   if (stateNode.config.on) {
     for (const descriptor of Object.keys(stateNode.config.on)) {
-      if (descriptor === dist_xstateActors.NULL_EVENT) {
+      if (descriptor === createActor.NULL_EVENT) {
         throw new Error('Null event transition key');
       }
       const transitionsConfig = stateNode.config.on[descriptor];
-      transitions.set(descriptor, mapTransitionConfigs(transitionsConfig, transition => dist_xstateActors.formatTransition(stateNode, descriptor, transition)));
+      transitions.set(descriptor, mapTransitionConfigs(transitionsConfig, transition => createActor.formatTransition(stateNode, descriptor, transition)));
     }
   }
   if (stateNode.config.onDone) {
     const descriptor = 'xstate.done.state';
-    addTransitions(descriptor, mapTransitionConfigs(stateNode.config.onDone, transition => dist_xstateActors.formatTransition(stateNode, descriptor, {
+    addTransitions(descriptor, mapTransitionConfigs(stateNode.config.onDone, transition => createActor.formatTransition(stateNode, descriptor, {
       ...transition,
       matches: {
         ...transition.matches,
@@ -274,13 +275,13 @@ function formatTransitions(stateNode) {
   }
   if (stateNode.config.onError) {
     const descriptor = 'xstate.error.*';
-    transitions.set(descriptor, mapTransitionConfigs(stateNode.config.onError, transition => dist_xstateActors.formatTransition(stateNode, descriptor, transition)));
+    transitions.set(descriptor, mapTransitionConfigs(stateNode.config.onError, transition => createActor.formatTransition(stateNode, descriptor, transition)));
   }
-  const createCancelInvokeTimeoutTransition = (descriptor, timeoutEventId, actorId) => dist_xstateActors.formatTransition(stateNode, descriptor, {
+  const createCancelInvokeTimeoutTransition = (descriptor, timeoutEventId, actorId) => createActor.formatTransition(stateNode, descriptor, {
     matches: {
       actorId
     },
-    _eventMatcher: (event, snapshot) => dist_xstateActors.matchesActorSession(event, snapshot, actorId),
+    _eventMatcher: (event, snapshot) => createActor.matchesActorSession(event, snapshot, actorId),
     to: (_args, enq) => {
       enq.cancel(timeoutEventId);
       return {};
@@ -293,7 +294,7 @@ function formatTransitions(stateNode) {
       reenter,
       ...rest
     } = transitionConfig;
-    return dist_xstateActors.formatTransition(stateNode, descriptor, {
+    return createActor.formatTransition(stateNode, descriptor, {
       ...rest,
       reenter,
       to: (args, enq) => {
@@ -336,14 +337,14 @@ function formatTransitions(stateNode) {
         ...transition.matches,
         actorId: invokeDef.id
       },
-      _eventMatcher: (event, snapshot) => dist_xstateActors.matchesActorSession(event, snapshot, invokeDef.id)
+      _eventMatcher: (event, snapshot) => createActor.matchesActorSession(event, snapshot, invokeDef.id)
     });
-    const invokeTimeoutEventId = invokeDef.timeout !== undefined ? dist_xstateActors.createInvokeTimeoutEventId(invokeDef.id) : undefined;
+    const invokeTimeoutEventId = invokeDef.timeout !== undefined ? createActor.createInvokeTimeoutEventId(invokeDef.id) : undefined;
     if (invokeDef.onDone) {
       const descriptor = 'xstate.done.actor';
       const invokeDoneTransitions = mapTransitionConfigs(invokeDef.onDone, rawTransition => {
         const transition = withInvokeMatch(rawTransition);
-        return invokeTimeoutEventId ? formatInvokeCompletionTransition(descriptor, transition, invokeTimeoutEventId) : dist_xstateActors.formatTransition(stateNode, descriptor, transition);
+        return invokeTimeoutEventId ? formatInvokeCompletionTransition(descriptor, transition, invokeTimeoutEventId) : createActor.formatTransition(stateNode, descriptor, transition);
       });
       if (invokeTimeoutEventId) {
         invokeDoneTransitions.push(createCancelInvokeTimeoutTransition(descriptor, invokeTimeoutEventId, invokeDef.id));
@@ -357,12 +358,12 @@ function formatTransitions(stateNode) {
       const descriptor = 'xstate.error.actor';
       addTransitions(descriptor, mapTransitionConfigs(invokeDef.onError, rawTransition => {
         const transition = withInvokeMatch(rawTransition);
-        return invokeTimeoutEventId ? formatInvokeCompletionTransition(descriptor, transition, invokeTimeoutEventId) : dist_xstateActors.formatTransition(stateNode, descriptor, transition);
+        return invokeTimeoutEventId ? formatInvokeCompletionTransition(descriptor, transition, invokeTimeoutEventId) : createActor.formatTransition(stateNode, descriptor, transition);
       }));
     }
     if (invokeDef.onSnapshot) {
       const descriptor = 'xstate.snapshot.actor';
-      addTransitions(descriptor, mapTransitionConfigs(invokeDef.onSnapshot, transition => dist_xstateActors.formatTransition(stateNode, descriptor, withInvokeMatch(transition))));
+      addTransitions(descriptor, mapTransitionConfigs(invokeDef.onSnapshot, transition => createActor.formatTransition(stateNode, descriptor, withInvokeMatch(transition))));
     }
   }
   for (const delayedTransition of stateNode.after) {
@@ -397,7 +398,7 @@ function getEmptyCanActor() {
   // A minimal inert actor used purely as the `self`/`parent` argument when
   // dry-running transitions for `snapshot.can(...)`. Intentionally not built
   // on `createLogic` so `can()` does not pull that machinery into bundles.
-  return emptyCanActor ??= dist_xstateActors.createActor({
+  return emptyCanActor ??= createActor.createActor({
     transition: snapshot => [snapshot, []],
     initialTransition: () => [{
       status: 'active',
@@ -484,7 +485,7 @@ class StateMachine {
       _machine: this
     });
     this.root._initialize();
-    dist_xstateActors.formatRouteTransitions(this.root);
+    createActor.formatRouteTransitions(this.root);
     this.root._refreshEventMetadata();
     this._hasEventlessTransitions = Array.from(this.idMap.values()).some(stateNode => !!stateNode.always?.length);
     this.states = this.root.states; // TODO: remove!
@@ -528,15 +529,15 @@ class StateMachine {
     return provided;
   }
   resolveState(config) {
-    const resolvedStateValue = dist_xstateActors.resolveStateValue(this.root, config.value);
-    const nodeSet = dist_xstateActors.getAllStateNodes(dist_xstateActors.getStateNodes(this.root, resolvedStateValue));
+    const resolvedStateValue = createActor.resolveStateValue(this.root, config.value);
+    const nodeSet = createActor.getAllStateNodes(createActor.getStateNodes(this.root, resolvedStateValue));
     const nodes = [...nodeSet];
-    return dist_xstateActors.createMachineSnapshot({
+    return createActor.createMachineSnapshot({
       _nodes: nodes,
       value: resolvedStateValue,
       context: config.context || {},
       children: {},
-      status: dist_xstateActors.isInFinalState(nodeSet, this.root) ? 'done' : config.status || 'active',
+      status: createActor.isInFinalState(nodeSet, this.root) ? 'done' : config.status || 'active',
       output: config.output,
       error: config.error,
       historyValue: config.historyValue
@@ -552,7 +553,7 @@ class StateMachine {
    */
   transition(snapshot, event, actorScope) {
     const usesInertScope = !actorScope;
-    const resolvedActorScope = actorScope ?? dist_xstateActors.createInertActorScope(this, snapshot);
+    const resolvedActorScope = actorScope ?? createActor.createInertActorScope(this, snapshot);
     if (this.validator) {
       dist_xstateActors.assertValid(this.validator, {
         kind: 'event',
@@ -562,14 +563,14 @@ class StateMachine {
       });
     }
     if (usesInertScope) {
-      dist_xstateActors.setInertActorScopeSnapshot(resolvedActorScope, snapshot, false);
+      createActor.setInertActorScopeSnapshot(resolvedActorScope, snapshot, false);
     }
     const fastSnapshot = this._transitionFast(snapshot, event, resolvedActorScope);
     if (fastSnapshot) {
       if (usesInertScope) {
-        dist_xstateActors.setInertActorScopeSnapshot(resolvedActorScope, fastSnapshot, false);
+        createActor.setInertActorScopeSnapshot(resolvedActorScope, fastSnapshot, false);
       }
-      const returnedSnapshot = usesInertScope && fastSnapshot !== snapshot ? dist_xstateActors.attachSnapshotActorRef(resolvedActorScope, fastSnapshot) : this._attachPureActorRef(fastSnapshot, resolvedActorScope);
+      const returnedSnapshot = usesInertScope && fastSnapshot !== snapshot ? createActor.attachSnapshotActorRef(resolvedActorScope, fastSnapshot) : this._attachPureActorRef(fastSnapshot, resolvedActorScope);
       if (this.validator) {
         dist_xstateActors.assertValid(this.validator, {
           kind: 'result',
@@ -583,11 +584,11 @@ class StateMachine {
     const {
       snapshot: nextSnapshot,
       microsteps
-    } = dist_xstateActors.macrostep(snapshot, event, resolvedActorScope, []);
+    } = createActor.macrostep(snapshot, event, resolvedActorScope, []);
     if (usesInertScope) {
-      dist_xstateActors.setInertActorScopeSnapshot(resolvedActorScope, nextSnapshot, false);
+      createActor.setInertActorScopeSnapshot(resolvedActorScope, nextSnapshot, false);
     }
-    const returnedSnapshot = usesInertScope ? nextSnapshot === snapshot ? nextSnapshot : dist_xstateActors.attachSnapshotActorRef(resolvedActorScope, nextSnapshot) : this._attachPureActorRef(nextSnapshot, resolvedActorScope);
+    const returnedSnapshot = usesInertScope ? nextSnapshot === snapshot ? nextSnapshot : createActor.attachSnapshotActorRef(resolvedActorScope, nextSnapshot) : this._attachPureActorRef(nextSnapshot, resolvedActorScope);
     const effects = this._collectEffects(microsteps);
     if (this.validator) {
       dist_xstateActors.assertValid(this.validator, {
@@ -603,13 +604,13 @@ class StateMachine {
     return microsteps.flatMap(([, actions]) => actions);
   }
   _attachPureActorRef(snapshot, actorScope, skipInitializingActor = false) {
-    if (dist_xstateActors.isInertActorScope(actorScope)) {
+    if (createActor.isInertActorScope(actorScope)) {
       return snapshot;
     }
     if (skipInitializingActor && actorScope.self._actorScope === actorScope && actorScope.self._snapshot === undefined) {
       return snapshot;
     }
-    dist_xstateActors.setSnapshotActorRef(snapshot, actorScope.self, actorScope.system);
+    createActor.setSnapshotActorRef(snapshot, actorScope.self, actorScope.system);
     return snapshot;
   }
   _transitionFast(snapshot, event, actorScope) {
@@ -637,12 +638,12 @@ class StateMachine {
       ...snapshot.context,
       ...selected.context
     } : snapshot.context;
-    if (!dist_xstateActors.isInertActorScope(actorScope) && (actorScope.system._hasInspectionObservers?.() ?? true)) {
+    if (!createActor.isInertActorScope(actorScope) && (actorScope.system._hasInspectionObservers?.() ?? true)) {
       const collectedMicrosteps = actorScope.self._collectedMicrosteps || [];
       collectedMicrosteps.push(selected);
       actorScope.self._collectedMicrosteps = collectedMicrosteps;
     }
-    return dist_xstateActors.cloneMachineSnapshot(snapshot, {
+    return createActor.cloneMachineSnapshot(snapshot, {
       ...(context !== snapshot.context ? {
         context
       } : {}),
@@ -662,7 +663,7 @@ class StateMachine {
   microstep(snapshot, event, actorScope) {
     const {
       microsteps
-    } = dist_xstateActors.macrostep(snapshot, event, actorScope, []);
+    } = createActor.macrostep(snapshot, event, actorScope, []);
     const snapshots = new Array(microsteps.length);
     for (let i = 0; i < microsteps.length; i++) {
       snapshots[i] = microsteps[i][0];
@@ -670,14 +671,14 @@ class StateMachine {
     return snapshots;
   }
   getTransitionData(snapshot, event, actorScope, selectionResults) {
-    return dist_xstateActors.transitionNode(this.root, snapshot.value, snapshot, event, actorScope, selectionResults) || [];
+    return createActor.transitionNode(this.root, snapshot.value, snapshot, event, actorScope, selectionResults) || [];
   }
   isInternalEventType(eventType) {
-    if (eventType === dist_xstateActors.XSTATE_TIMER) {
+    if (eventType === createActor.XSTATE_TIMER) {
       return true;
     }
     for (const descriptor of this.internalEventDescriptors) {
-      if (dist_xstateActors.matchesEventDescriptor(eventType, descriptor)) {
+      if (createActor.matchesEventDescriptor(eventType, descriptor)) {
         return true;
       }
     }
@@ -703,10 +704,10 @@ class StateMachine {
       if (transition.target !== undefined) {
         return true;
       }
-      const res = dist_xstateActors.getTransitionResult(transition, snapshot, event, emptyActorScope, {
+      const res = createActor.getTransitionResult(transition, snapshot, event, emptyActorScope, {
         resolveActions: false
       });
-      if (res.targets?.length || res.context || dist_xstateActors.hasEffect(transition, snapshot.context, event, snapshot, emptyActorScope)) {
+      if (res.targets?.length || res.context || createActor.hasEffect(transition, snapshot.context, event, snapshot, emptyActorScope)) {
         return true;
       }
     }
@@ -720,10 +721,10 @@ class StateMachine {
    * @internal
    */
   getExecutionErrorEvent(snapshot, error) {
-    if (snapshot?.status !== 'active' || !snapshot._nodes?.some(stateNode => stateNode.config.onError)) {
+    if (snapshot?.status !== 'active' || !snapshot.nodes?.some(stateNode => stateNode.config.onError)) {
       return undefined;
     }
-    return dist_xstateActors.createErrorPlatformEvent('execution', error);
+    return createActor.createErrorPlatformEvent('execution', error);
   }
 
   /**
@@ -736,7 +737,7 @@ class StateMachine {
     const {
       context
     } = this.config;
-    const preInitial = dist_xstateActors.createMachineSnapshot({
+    const preInitial = createActor.createMachineSnapshot({
       context: typeof context !== 'function' && context ? context : {},
       _nodes: [this.root],
       children: {},
@@ -745,12 +746,12 @@ class StateMachine {
     if (typeof context === 'function') {
       const children = {};
       const spawn = createSpawner(actorScope, this.sources.actors, children);
-      const resolvedContext = context(dist_xstateActors.withActorSelf({
+      const resolvedContext = context(createActor.withActorSelf({
         spawn,
         input: initEvent.input,
         actors: this.sources.actors
       }, actorScope));
-      const [nextState] = dist_xstateActors.resolveActionsWithContext(preInitial, initEvent, actorScope, []);
+      const [nextState] = createActor.resolveActionsWithContext(preInitial, initEvent, actorScope, []);
       if (resolvedContext) {
         nextState.context = resolvedContext;
       }
@@ -781,16 +782,16 @@ class StateMachine {
       });
     }
     const usesInertScope = !actorScope;
-    const resolvedActorScope = actorScope ?? dist_xstateActors.createInertActorScope(this);
-    const initEvent = dist_xstateActors.createInitEvent(input); // TODO: fix;
+    const resolvedActorScope = actorScope ?? createActor.createInertActorScope(this);
+    const initEvent = createActor.createInitEvent(input); // TODO: fix;
     const internalQueue = [];
     const preInitialState = this._getPreInitialState(resolvedActorScope, initEvent);
-    const contextSpawnEffects = Object.values(preInitialState.children).filter(Boolean).map(actor => dist_xstateActors.createSpawnEffect(actor));
+    const contextSpawnEffects = Object.values(preInitialState.children).filter(Boolean).map(actor => createActor.createSpawnEffect(actor));
     const finalizeInitialResult = (macroState, microsteps) => {
       if (usesInertScope) {
-        dist_xstateActors.setInertActorScopeSnapshot(resolvedActorScope, macroState, false);
+        createActor.setInertActorScopeSnapshot(resolvedActorScope, macroState, false);
       }
-      const returnedSnapshot = usesInertScope ? dist_xstateActors.attachSnapshotActorRef(resolvedActorScope, macroState) : this._attachPureActorRef(macroState, resolvedActorScope, true);
+      const returnedSnapshot = usesInertScope ? createActor.attachSnapshotActorRef(resolvedActorScope, macroState) : this._attachPureActorRef(macroState, resolvedActorScope, true);
       const effects = this._collectEffects(microsteps);
       if (this.validator) {
         dist_xstateActors.assertValid(this.validator, {
@@ -803,18 +804,18 @@ class StateMachine {
       return [returnedSnapshot, effects];
     };
     try {
-      const [nextState, initialActions] = dist_xstateActors.initialMicrostep(this.root, preInitialState, resolvedActorScope, initEvent, internalQueue);
+      const [nextState, initialActions] = createActor.initialMicrostep(this.root, preInitialState, resolvedActorScope, initEvent, internalQueue);
       const {
         snapshot: macroState,
         microsteps
-      } = dist_xstateActors.macrostep(nextState, initEvent, resolvedActorScope, internalQueue, [[nextState, [...contextSpawnEffects, ...initialActions]]]);
+      } = createActor.macrostep(nextState, initEvent, resolvedActorScope, internalQueue, [[nextState, [...contextSpawnEffects, ...initialActions]]]);
       return finalizeInitialResult(macroState, microsteps);
     } catch (err) {
       if (!this.root.config.onError) {
         throw err;
       }
-      const errorEvent = dist_xstateActors.createErrorPlatformEvent('execution', err);
-      const errorMacrostep = dist_xstateActors.macrostep(preInitialState, errorEvent, resolvedActorScope, [], [[preInitialState, contextSpawnEffects]]);
+      const errorEvent = createActor.createErrorPlatformEvent('execution', err);
+      const errorMacrostep = createActor.macrostep(preInitialState, errorEvent, resolvedActorScope, [], [[preInitialState, contextSpawnEffects]]);
       return finalizeInitialResult(errorMacrostep.snapshot, errorMacrostep.microsteps);
     }
   }
@@ -837,21 +838,21 @@ class StateMachine {
     }
   }
   getStateNodeById(stateId) {
-    const fullPath = dist_xstateActors.toStatePath(stateId);
+    const fullPath = createActor.toStatePath(stateId);
     const relativePath = fullPath.slice(1);
-    const resolvedStateId = dist_xstateActors.isStateId(fullPath[0]) ? fullPath[0].slice(STATE_IDENTIFIER.length) : fullPath[0];
+    const resolvedStateId = createActor.isStateId(fullPath[0]) ? fullPath[0].slice(STATE_IDENTIFIER.length) : fullPath[0];
     const stateNode = this.idMap.get(resolvedStateId);
     if (!stateNode) {
       throw new Error(`Child state node '#${resolvedStateId}' does not exist on machine '${this.id}'`);
     }
-    return dist_xstateActors.getStateNodeByPath(stateNode, relativePath);
+    return createActor.getStateNodeByPath(stateNode, relativePath);
   }
   getPersistedSnapshot(snapshot, options) {
-    return dist_xstateActors.getPersistedSnapshot(snapshot, options);
+    return createActor.getPersistedSnapshot(snapshot, options);
   }
   restoreSnapshot(snapshot, actorScope) {
     const usesInertScope = !actorScope;
-    const resolvedActorScope = actorScope ?? dist_xstateActors.createInertActorScope(this);
+    const resolvedActorScope = actorScope ?? createActor.createInertActorScope(this);
     const persistedMachine = snapshot.machine;
     const legacyPersistedVersion = snapshot.version;
     const persistedVersion = typeof persistedMachine?.version === 'string' ? persistedMachine.version : legacyPersistedVersion;
@@ -875,7 +876,7 @@ class StateMachine {
       const actorData = snapshotChildren[actorId];
       const childState = actorData.snapshot;
       const src = actorData.src;
-      const logic = typeof src === 'string' ? dist_xstateActors.resolveReferencedActor(this, src) : src;
+      const logic = typeof src === 'string' ? createActor.resolveReferencedActor(this, src) : src;
       if (!logic) {
         const sourceId = typeof src === 'string' ? src : '<unknown>';
         throw new Error(`Unable to restore child actor '${actorId}': child source '${sourceId}' is not provided in machine '${this.id}'.`);
@@ -901,7 +902,7 @@ class StateMachine {
         const actorId = event.actorId;
         const child = children[actorId];
         if (child) {
-          event = dist_xstateActors.createInvokeTimeoutEvent(actorId, child.sessionId);
+          event = createActor.createInvokeTimeoutEvent(actorId, child.sessionId);
         }
       }
       const target = typeof timer.target === 'string' ? timer.target === 'self' ? 'self' : children[timer.target] : resolvedActorScope.self._parent;
@@ -942,12 +943,32 @@ class StateMachine {
       return revived;
     };
     const revivedHistoryValue = reviveHistoryValue(snapshotData.historyValue);
-    const nodes = Array.from(dist_xstateActors.getAllStateNodes(dist_xstateActors.getStateNodes(this.root, snapshotData.value)));
+    const validateStateValue = (stateValue, node, path) => {
+      const missingStateError = statePath => new Error(`Persisted snapshot references state '${statePath.join('.')}' which does not exist on machine '${this.id}'.`);
+      if (typeof stateValue === 'string') {
+        if (!node.states[stateValue]) {
+          throw missingStateError(path.concat(stateValue));
+        }
+        return;
+      }
+      if (!stateValue || typeof stateValue !== 'object') {
+        return;
+      }
+      for (const key of Object.keys(stateValue)) {
+        const childNode = node.states[key];
+        if (!childNode) {
+          throw missingStateError(path.concat(key));
+        }
+        validateStateValue(stateValue[key], childNode, path.concat(key));
+      }
+    };
+    validateStateValue(snapshotData.value, this.root, []);
+    const nodes = Array.from(createActor.getAllStateNodes(createActor.getStateNodes(this.root, snapshotData.value)));
     const {
       version: _persistedSnapshotVersion,
       ...persistedRest
     } = snapshot;
-    const restoredSnapshot = dist_xstateActors.createMachineSnapshot({
+    const restoredSnapshot = createActor.createMachineSnapshot({
       ...persistedRest,
       children,
       timers,
@@ -965,7 +986,7 @@ class StateMachine {
       for (const key of Object.keys(contextPart)) {
         const value = contextPart[key];
         if (value && typeof value === 'object') {
-          if ('xstate$$type' in value && value.xstate$$type === dist_xstateActors.$$ACTOR_TYPE) {
+          if ('xstate$$type' in value && value.xstate$$type === createActor.$$ACTOR_TYPE) {
             contextPart[key] = children[value.id];
             continue;
           }
@@ -975,8 +996,8 @@ class StateMachine {
     }
     reviveContext(restoredSnapshot.context);
     if (usesInertScope) {
-      dist_xstateActors.setInertActorScopeSnapshot(resolvedActorScope, restoredSnapshot, false);
-      return dist_xstateActors.attachSnapshotActorRef(resolvedActorScope, restoredSnapshot);
+      createActor.setInertActorScopeSnapshot(resolvedActorScope, restoredSnapshot, false);
+      return createActor.attachSnapshotActorRef(resolvedActorScope, restoredSnapshot);
     }
     return this._attachPureActorRef(restoredSnapshot, resolvedActorScope);
   }

package/dist/{StateMachine-9d68f525.esm.js → StateMachine-812087bb.esm.js}

@@ -1,4 +1,5 @@
-import { 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, B as getStateNodes, a8 as createMachineSnapshot, a9 as isInFinalState, k as createInertActorScope, aa as assertValid, s as setInertActorScopeSnapshot, l as attachSnapshotActorRef, n as macrostep, ab as isInertActorScope, ac as setSnapshotActorRef, ad as cloneMachineSnapshot, ae as transitionNode, e as XSTATE_TIMER, m as matchesEventDescriptor, af as getTransitionResult, ag as hasEffect, ah as createErrorPlatformEvent, ai as withActorSelf, r as resolveActionsWithContext, o as createInitEvent, q as createSpawnEffect, u as initialMicrostep, aj as toStatePath, ak as isStateId, al as getStateNodeByPath, am as getPersistedSnapshot, an as resolveReferencedActor, ao as createInvokeTimeoutEvent, ap as $$ACTOR_TYPE, j as createActor } from './index-9146dea1.esm.js';
+import { S as STATE_DELIMITER, I as mapValues, t as toArray, J as createInvokeId, K as getDelayedTransitions, L as getEventDescriptorKey, M as getCandidates, N as evaluateCandidate, O as formatTransition, P as NULL_EVENT, Q as toTransitionConfigArray, R as createInvokeTimeoutEventId, T as matchesActorSession, U as formatRouteTransitions, V as resolveStateValue, W as getAllStateNodes, o as getStateNodes, Y as createMachineSnapshot, Z as isInFinalState, _ as createInertActorScope, $ as setInertActorScopeSnapshot, a0 as attachSnapshotActorRef, a1 as macrostep, a2 as isInertActorScope, a3 as setSnapshotActorRef, a4 as cloneMachineSnapshot, a5 as transitionNode, e as XSTATE_TIMER, m as matchesEventDescriptor, a6 as getTransitionResult, a7 as hasEffect, a8 as createErrorPlatformEvent, a9 as withActorSelf, r as resolveActionsWithContext, F as createInitEvent, aa as createSpawnEffect, ab as initialMicrostep, ac as toStatePath, ad as isStateId, ae as getStateNodeByPath, af as getPersistedSnapshot, ag as resolveReferencedActor, ah as createInvokeTimeoutEvent, ai as $$ACTOR_TYPE, j as createActor } from './createActor-19e83fb9.esm.js';
+import { g as assertValid } from './index-abf9ab72.esm.js';
 
 function createSpawner(actorScope, actors, spawnedChildren) {
   return (src, options) => {
@@ -718,7 +719,7 @@ class StateMachine {
    * @internal
    */
   getExecutionErrorEvent(snapshot, error) {
-    if (snapshot?.status !== 'active' || !snapshot._nodes?.some(stateNode => stateNode.config.onError)) {
+    if (snapshot?.status !== 'active' || !snapshot.nodes?.some(stateNode => stateNode.config.onError)) {
       return undefined;
     }
     return createErrorPlatformEvent('execution', error);
@@ -940,6 +941,26 @@ class StateMachine {
       return revived;
     };
     const revivedHistoryValue = reviveHistoryValue(snapshotData.historyValue);
+    const validateStateValue = (stateValue, node, path) => {
+      const missingStateError = statePath => new Error(`Persisted snapshot references state '${statePath.join('.')}' which does not exist on machine '${this.id}'.`);
+      if (typeof stateValue === 'string') {
+        if (!node.states[stateValue]) {
+          throw missingStateError(path.concat(stateValue));
+        }
+        return;
+      }
+      if (!stateValue || typeof stateValue !== 'object') {
+        return;
+      }
+      for (const key of Object.keys(stateValue)) {
+        const childNode = node.states[key];
+        if (!childNode) {
+          throw missingStateError(path.concat(key));
+        }
+        validateStateValue(stateValue[key], childNode, path.concat(key));
+      }
+    };
+    validateStateValue(snapshotData.value, this.root, []);
     const nodes = Array.from(getAllStateNodes(getStateNodes(this.root, snapshotData.value)));
     const {
       version: _persistedSnapshotVersion,

package/dist/{StateMachine-8dd1e4a0.development.esm.js → StateMachine-d344b16c.development.esm.js}

@@ -1,4 +1,5 @@
-import { 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, B as getStateNodes, a8 as createMachineSnapshot, a9 as isInFinalState, k as createInertActorScope, aa as assertValid, s as setInertActorScopeSnapshot, l as attachSnapshotActorRef, n as macrostep, ab as isInertActorScope, ac as setSnapshotActorRef, ad as cloneMachineSnapshot, ae as transitionNode, e as XSTATE_TIMER, m as matchesEventDescriptor, af as getTransitionResult, ag as hasEffect, ah as createErrorPlatformEvent, ai as withActorSelf, r as resolveActionsWithContext, o as createInitEvent, q as createSpawnEffect, u as initialMicrostep, aj as toStatePath, ak as isStateId, al as getStateNodeByPath, am as getPersistedSnapshot, an as resolveReferencedActor, ao as createInvokeTimeoutEvent, ap as $$ACTOR_TYPE, j as createActor } from './index-9d364b4a.development.esm.js';
+import { S as STATE_DELIMITER, I as mapValues, t as toArray, J as createInvokeId, K as getDelayedTransitions, L as getEventDescriptorKey, M as getCandidates, N as evaluateCandidate, O as formatTransition, P as NULL_EVENT, Q as toTransitionConfigArray, R as createInvokeTimeoutEventId, T as matchesActorSession, U as formatRouteTransitions, V as resolveStateValue, W as getAllStateNodes, o as getStateNodes, Y as createMachineSnapshot, Z as isInFinalState, _ as createInertActorScope, $ as setInertActorScopeSnapshot, a0 as attachSnapshotActorRef, a1 as macrostep, a2 as isInertActorScope, a3 as setSnapshotActorRef, a4 as cloneMachineSnapshot, a5 as transitionNode, e as XSTATE_TIMER, m as matchesEventDescriptor, a6 as getTransitionResult, a7 as hasEffect, a8 as createErrorPlatformEvent, a9 as withActorSelf, r as resolveActionsWithContext, F as createInitEvent, aa as createSpawnEffect, ab as initialMicrostep, ac as toStatePath, ad as isStateId, ae as getStateNodeByPath, af as getPersistedSnapshot, ag as resolveReferencedActor, ah as createInvokeTimeoutEvent, ai as $$ACTOR_TYPE, j as createActor } from './createActor-164c86f5.development.esm.js';
+import { g as assertValid } from './index-acf2bd02.development.esm.js';
 
 function createSpawner(actorScope, actors, spawnedChildren) {
   return (src, options) => {
@@ -747,7 +748,7 @@ class StateMachine {
    * @internal
    */
   getExecutionErrorEvent(snapshot, error) {
-    if (snapshot?.status !== 'active' || !snapshot._nodes?.some(stateNode => stateNode.config.onError)) {
+    if (snapshot?.status !== 'active' || !snapshot.nodes?.some(stateNode => stateNode.config.onError)) {
       return undefined;
     }
     return createErrorPlatformEvent('execution', error);
@@ -972,6 +973,26 @@ class StateMachine {
       return revived;
     };
     const revivedHistoryValue = reviveHistoryValue(snapshotData.historyValue);
+    const validateStateValue = (stateValue, node, path) => {
+      const missingStateError = statePath => new Error(`Persisted snapshot references state '${statePath.join('.')}' which does not exist on machine '${this.id}'.`);
+      if (typeof stateValue === 'string') {
+        if (!node.states[stateValue]) {
+          throw missingStateError(path.concat(stateValue));
+        }
+        return;
+      }
+      if (!stateValue || typeof stateValue !== 'object') {
+        return;
+      }
+      for (const key of Object.keys(stateValue)) {
+        const childNode = node.states[key];
+        if (!childNode) {
+          throw missingStateError(path.concat(key));
+        }
+        validateStateValue(stateValue[key], childNode, path.concat(key));
+      }
+    };
+    validateStateValue(snapshotData.value, this.root, []);
     const nodes = Array.from(getAllStateNodes(getStateNodes(this.root, snapshotData.value)));
     const {
       version: _persistedSnapshotVersion,