xstate 6.0.0-alpha.27 → 6.0.0-alpha.31

package/dist/{StateMachine-bcb27183.cjs.js → StateMachine-4e86e818.cjs.js}

@@ -1,6 +1,6 @@
 'use strict';
 
-var dist_xstateActors = require('./index-b228b8b6.cjs.js');
+var dist_xstateActors = require('./index-85c48a0a.cjs.js');
 
 function createSpawner(actorScope, actors, spawnedChildren) {
   return (src, options) => {
@@ -43,7 +43,7 @@ function createInertActorScope(actorLogic, snapshot, sourceSelf) {
   const snapshotRef = snapshot ? dist_xstateActors.getSnapshotActorRef(snapshot) : undefined;
   const previousSelf = sourceSelf ?? snapshotRef?.actor;
   const baseSystem = previousSelf?.system;
-  const system = previousSelf && baseSystem ? dist_xstateActors.createSnapshotSystem(baseSystem, previousSelf, dist_xstateActors.isMachineSnapshot(snapshot) ? snapshot.children : {}, sourceSelf ? undefined : snapshotRef?.systemState) : undefined;
+  const system = previousSelf && baseSystem ? dist_xstateActors.createSnapshotSystem(baseSystem, dist_xstateActors.isMachineSnapshot(snapshot) ? snapshot.children : {}, sourceSelf ? undefined : snapshotRef?.systemState) : undefined;
   const self = dist_xstateActors.createActor(actorLogic, {
     _inert: true,
     ...(previousSelf ? {
@@ -531,8 +531,9 @@ function getEmptyCanActorScope() {
 }
 class StateMachine {
   constructor(/** The raw config used to create the machine. */
-  config, sources) {
+  config, sources, validator) {
     this.config = config;
+    this.validator = validator;
     /** The machine's own version. */
     this.version = void 0;
     this.schemas = void 0;
@@ -617,7 +618,7 @@ class StateMachine {
         ...delays,
         ...sources.delays
       }
-    });
+    }, this.validator);
     // Providing sources does not change the serializable definition.
     provided._json = this._json;
     return provided;
@@ -648,6 +649,14 @@ class StateMachine {
   transition(snapshot, event, actorScope) {
     const usesInertScope = !actorScope;
     const resolvedActorScope = actorScope ?? createInertActorScope(this, snapshot);
+    if (this.validator) {
+      dist_xstateActors.assertValid(this.validator, {
+        kind: 'event',
+        logic: this,
+        event,
+        eventOrigin: actorScope && actorScope.self._lastSourceRef ? 'actor' : 'external'
+      });
+    }
     if (usesInertScope) {
       setInertActorScopeSnapshot(resolvedActorScope, snapshot, false);
     }
@@ -657,6 +666,14 @@ class StateMachine {
         setInertActorScopeSnapshot(resolvedActorScope, fastSnapshot, false);
       }
       const returnedSnapshot = usesInertScope && fastSnapshot !== snapshot ? attachSnapshotActorRef(this, resolvedActorScope, fastSnapshot) : this._attachPureActorRef(fastSnapshot, resolvedActorScope);
+      if (this.validator) {
+        dist_xstateActors.assertValid(this.validator, {
+          kind: 'result',
+          logic: this,
+          snapshot: returnedSnapshot,
+          effects: []
+        });
+      }
       return [returnedSnapshot, []];
     }
     const {
@@ -667,7 +684,16 @@ class StateMachine {
       setInertActorScopeSnapshot(resolvedActorScope, nextSnapshot, false);
     }
     const returnedSnapshot = usesInertScope ? nextSnapshot === snapshot ? nextSnapshot : attachSnapshotActorRef(this, resolvedActorScope, nextSnapshot) : this._attachPureActorRef(nextSnapshot, resolvedActorScope);
-    return [returnedSnapshot, this._collectEffects(microsteps)];
+    const effects = this._collectEffects(microsteps);
+    if (this.validator) {
+      dist_xstateActors.assertValid(this.validator, {
+        kind: 'result',
+        logic: this,
+        snapshot: returnedSnapshot,
+        effects
+      });
+    }
+    return [returnedSnapshot, effects];
   }
   _collectEffects(microsteps) {
     return microsteps.flatMap(([, actions]) => actions);
@@ -676,7 +702,8 @@ class StateMachine {
     if (isInertActorScope(actorScope)) {
       return snapshot;
     }
-    return attachSnapshotActorRef(this, actorScope, snapshot);
+    dist_xstateActors.setSnapshotActorRef(snapshot, actorScope.self, actorScope.system);
+    return snapshot;
   }
   _transitionFast(snapshot, event, actorScope) {
     if (snapshot.status !== 'active' || typeof snapshot.value !== 'string' || this.root.always?.length) {
@@ -839,37 +866,50 @@ class StateMachine {
     return this.initialTransition(input, actorScope)[0];
   }
   initialTransition(input, actorScope) {
+    if (this.validator) {
+      dist_xstateActors.assertValid(this.validator, {
+        kind: 'input',
+        logic: this,
+        input
+      });
+    }
     const usesInertScope = !actorScope;
     const resolvedActorScope = actorScope ?? createInertActorScope(this);
     const initEvent = dist_xstateActors.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));
-    let nextState;
-    let initialActions = [];
-    let microsteps = [];
-    let macroState;
+    const finalizeInitialResult = (macroState, microsteps) => {
+      if (usesInertScope) {
+        setInertActorScopeSnapshot(resolvedActorScope, macroState, false);
+      }
+      const returnedSnapshot = usesInertScope ? attachSnapshotActorRef(this, resolvedActorScope, macroState) : this._attachPureActorRef(macroState, resolvedActorScope);
+      const effects = this._collectEffects(microsteps);
+      if (this.validator) {
+        dist_xstateActors.assertValid(this.validator, {
+          kind: 'result',
+          logic: this,
+          snapshot: returnedSnapshot,
+          effects
+        });
+      }
+      return [returnedSnapshot, effects];
+    };
     try {
-      [nextState, initialActions] = dist_xstateActors.initialMicrostep(this.root, preInitialState, resolvedActorScope, initEvent, internalQueue);
-      ({
+      const [nextState, initialActions] = dist_xstateActors.initialMicrostep(this.root, preInitialState, resolvedActorScope, initEvent, internalQueue);
+      const {
         snapshot: macroState,
         microsteps
-      } = dist_xstateActors.macrostep(nextState, initEvent, resolvedActorScope, internalQueue, [[nextState, [...contextSpawnEffects, ...initialActions]]]));
+      } = dist_xstateActors.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]]);
-      macroState = errorMacrostep.snapshot;
-      microsteps = errorMacrostep.microsteps;
-      initialActions = [];
+      return finalizeInitialResult(errorMacrostep.snapshot, errorMacrostep.microsteps);
     }
-    if (usesInertScope) {
-      setInertActorScopeSnapshot(resolvedActorScope, macroState, false);
-    }
-    const returnedSnapshot = usesInertScope ? attachSnapshotActorRef(this, resolvedActorScope, macroState) : this._attachPureActorRef(macroState, resolvedActorScope);
-    return [returnedSnapshot, this._collectEffects(microsteps)];
   }
   start(snapshot) {
     // Start rehydrated children that were active when persisted. Freshly
@@ -900,7 +940,15 @@ class StateMachine {
   restoreSnapshot(snapshot, actorScope) {
     const usesInertScope = !actorScope;
     const resolvedActorScope = actorScope ?? createInertActorScope(this);
-    const persistedVersion = snapshot.version;
+    const persistedMachine = snapshot.machine;
+    const legacyPersistedVersion = snapshot.version;
+    const persistedVersion = typeof persistedMachine?.version === 'string' ? persistedMachine.version : legacyPersistedVersion;
+    if (legacyPersistedVersion !== undefined && persistedMachine?.version !== undefined && persistedMachine.version !== legacyPersistedVersion) {
+      throw new Error(`Persisted snapshot version '${legacyPersistedVersion}' conflicts with machine version '${persistedMachine.version}'.`);
+    }
+    if (persistedMachine && typeof persistedMachine.id === 'string' && persistedMachine.id !== this.id) {
+      throw new Error(`Machine ID mismatch: persisted snapshot machine '${persistedMachine.id}' does not match '${this.id}'.`);
+    }
     if (persistedVersion !== this.version) {
       const migrate = this.config.migrate;
       if (typeof migrate !== 'function') {

package/dist/{StateMachine-24c5e3f9.development.esm.js → StateMachine-54d3cf7a.development.esm.js}

@@ -1,4 +1,4 @@
-import { M as setSnapshotActorRef, N as getSnapshotActorRef, O as createSnapshotSystem, q as isMachineSnapshot, h as createActor, S as STATE_DELIMITER, P as mapValues, t as toArray, Q as createInvokeId, R as getDelayedTransitions, U as getEventDescriptorKey, V as evaluateCandidate, W as formatTransition, Y as NULL_EVENT, Z as toTransitionConfigArray, _ as createInvokeTimeoutEventId, $ as getCandidates, a0 as matchesActorSession, a1 as formatRouteTransitions, a2 as resolveStateValue, a3 as getAllStateNodes, s as getStateNodes, a4 as createMachineSnapshot, a5 as isInFinalState, j as macrostep, a6 as cloneMachineSnapshot, a7 as transitionNode, e as XSTATE_TIMER, m as matchesEventDescriptor, a8 as getTransitionResult, a9 as hasEffect, aa as createErrorPlatformEvent, r as resolveActionsWithContext, k as createInitEvent, l as createSpawnEffect, n as initialMicrostep, ab as toStatePath, ac as isStateId, ad as getStateNodeByPath, ae as getPersistedSnapshot, af as resolveReferencedActor, ag as createInvokeTimeoutEvent, ah as $$ACTOR_TYPE } from './index-41508d62.development.esm.js';
+import { M as setSnapshotActorRef, N as getSnapshotActorRef, O as createSnapshotSystem, q as isMachineSnapshot, h as createActor, S as STATE_DELIMITER, P as mapValues, t as toArray, Q as createInvokeId, R as getDelayedTransitions, U as getEventDescriptorKey, V as evaluateCandidate, W as formatTransition, Y as NULL_EVENT, Z as toTransitionConfigArray, _ as createInvokeTimeoutEventId, $ as getCandidates, a0 as matchesActorSession, a1 as formatRouteTransitions, a2 as resolveStateValue, a3 as getAllStateNodes, s as getStateNodes, a4 as createMachineSnapshot, a5 as isInFinalState, a6 as assertValid, j as macrostep, a7 as cloneMachineSnapshot, a8 as transitionNode, e as XSTATE_TIMER, m as matchesEventDescriptor, a9 as getTransitionResult, aa as hasEffect, ab as createErrorPlatformEvent, r as resolveActionsWithContext, k as createInitEvent, l as createSpawnEffect, n as initialMicrostep, ac as toStatePath, ad as isStateId, ae as getStateNodeByPath, af as getPersistedSnapshot, ag as resolveReferencedActor, ah as createInvokeTimeoutEvent, ai as $$ACTOR_TYPE } from './index-fbe9e986.development.esm.js';
 
 function createSpawner(actorScope, actors, spawnedChildren) {
   return (src, options) => {
@@ -41,7 +41,7 @@ function createInertActorScope(actorLogic, snapshot, sourceSelf) {
   const snapshotRef = snapshot ? getSnapshotActorRef(snapshot) : undefined;
   const previousSelf = sourceSelf ?? snapshotRef?.actor;
   const baseSystem = previousSelf?.system;
-  const system = previousSelf && baseSystem ? createSnapshotSystem(baseSystem, previousSelf, isMachineSnapshot(snapshot) ? snapshot.children : {}, sourceSelf ? undefined : snapshotRef?.systemState) : undefined;
+  const system = previousSelf && baseSystem ? createSnapshotSystem(baseSystem, isMachineSnapshot(snapshot) ? snapshot.children : {}, sourceSelf ? undefined : snapshotRef?.systemState) : undefined;
   const self = createActor(actorLogic, {
     _inert: true,
     ...(previousSelf ? {
@@ -547,8 +547,9 @@ function getEmptyCanActorScope() {
 }
 class StateMachine {
   constructor(/** The raw config used to create the machine. */
-  config, sources) {
+  config, sources, validator) {
     this.config = config;
+    this.validator = validator;
     /** The machine's own version. */
     this.version = void 0;
     this.schemas = void 0;
@@ -644,7 +645,7 @@ class StateMachine {
         ...delays,
         ...sources.delays
       }
-    });
+    }, this.validator);
     // Providing sources does not change the serializable definition.
     provided._json = this._json;
     return provided;
@@ -675,6 +676,14 @@ class StateMachine {
   transition(snapshot, event, actorScope) {
     const usesInertScope = !actorScope;
     const resolvedActorScope = actorScope ?? createInertActorScope(this, snapshot);
+    if (this.validator) {
+      assertValid(this.validator, {
+        kind: 'event',
+        logic: this,
+        event,
+        eventOrigin: actorScope && actorScope.self._lastSourceRef ? 'actor' : 'external'
+      });
+    }
     if (usesInertScope) {
       setInertActorScopeSnapshot(resolvedActorScope, snapshot, false);
     }
@@ -684,6 +693,14 @@ class StateMachine {
         setInertActorScopeSnapshot(resolvedActorScope, fastSnapshot, false);
       }
       const returnedSnapshot = usesInertScope && fastSnapshot !== snapshot ? attachSnapshotActorRef(this, resolvedActorScope, fastSnapshot) : this._attachPureActorRef(fastSnapshot, resolvedActorScope);
+      if (this.validator) {
+        assertValid(this.validator, {
+          kind: 'result',
+          logic: this,
+          snapshot: returnedSnapshot,
+          effects: []
+        });
+      }
       return [returnedSnapshot, []];
     }
     const {
@@ -694,7 +711,16 @@ class StateMachine {
       setInertActorScopeSnapshot(resolvedActorScope, nextSnapshot, false);
     }
     const returnedSnapshot = usesInertScope ? nextSnapshot === snapshot ? nextSnapshot : attachSnapshotActorRef(this, resolvedActorScope, nextSnapshot) : this._attachPureActorRef(nextSnapshot, resolvedActorScope);
-    return [returnedSnapshot, this._collectEffects(microsteps)];
+    const effects = this._collectEffects(microsteps);
+    if (this.validator) {
+      assertValid(this.validator, {
+        kind: 'result',
+        logic: this,
+        snapshot: returnedSnapshot,
+        effects
+      });
+    }
+    return [returnedSnapshot, effects];
   }
   _collectEffects(microsteps) {
     return microsteps.flatMap(([, actions]) => actions);
@@ -703,7 +729,8 @@ class StateMachine {
     if (isInertActorScope(actorScope)) {
       return snapshot;
     }
-    return attachSnapshotActorRef(this, actorScope, snapshot);
+    setSnapshotActorRef(snapshot, actorScope.self, actorScope.system);
+    return snapshot;
   }
   _transitionFast(snapshot, event, actorScope) {
     if (snapshot.status !== 'active' || typeof snapshot.value !== 'string' || this.root.always?.length) {
@@ -866,37 +893,50 @@ class StateMachine {
     return this.initialTransition(input, actorScope)[0];
   }
   initialTransition(input, actorScope) {
+    if (this.validator) {
+      assertValid(this.validator, {
+        kind: 'input',
+        logic: this,
+        input
+      });
+    }
     const usesInertScope = !actorScope;
     const resolvedActorScope = actorScope ?? createInertActorScope(this);
     const initEvent = createInitEvent(input); // TODO: fix;
     const internalQueue = [];
     const preInitialState = this._getPreInitialState(resolvedActorScope, initEvent);
     const contextSpawnEffects = Object.values(preInitialState.children).filter(Boolean).map(actor => createSpawnEffect(actor));
-    let nextState;
-    let initialActions = [];
-    let microsteps = [];
-    let macroState;
+    const finalizeInitialResult = (macroState, microsteps) => {
+      if (usesInertScope) {
+        setInertActorScopeSnapshot(resolvedActorScope, macroState, false);
+      }
+      const returnedSnapshot = usesInertScope ? attachSnapshotActorRef(this, resolvedActorScope, macroState) : this._attachPureActorRef(macroState, resolvedActorScope);
+      const effects = this._collectEffects(microsteps);
+      if (this.validator) {
+        assertValid(this.validator, {
+          kind: 'result',
+          logic: this,
+          snapshot: returnedSnapshot,
+          effects
+        });
+      }
+      return [returnedSnapshot, effects];
+    };
     try {
-      [nextState, initialActions] = initialMicrostep(this.root, preInitialState, resolvedActorScope, initEvent, internalQueue);
-      ({
+      const [nextState, initialActions] = initialMicrostep(this.root, preInitialState, resolvedActorScope, initEvent, internalQueue);
+      const {
         snapshot: macroState,
         microsteps
-      } = macrostep(nextState, initEvent, resolvedActorScope, internalQueue, [[nextState, [...contextSpawnEffects, ...initialActions]]]));
+      } = macrostep(nextState, initEvent, resolvedActorScope, internalQueue, [[nextState, [...contextSpawnEffects, ...initialActions]]]);
+      return finalizeInitialResult(macroState, microsteps);
     } catch (err) {
       if (!this.root.config.onError) {
         throw err;
       }
       const errorEvent = createErrorPlatformEvent('execution', err);
       const errorMacrostep = macrostep(preInitialState, errorEvent, resolvedActorScope, [], [[preInitialState, contextSpawnEffects]]);
-      macroState = errorMacrostep.snapshot;
-      microsteps = errorMacrostep.microsteps;
-      initialActions = [];
+      return finalizeInitialResult(errorMacrostep.snapshot, errorMacrostep.microsteps);
     }
-    if (usesInertScope) {
-      setInertActorScopeSnapshot(resolvedActorScope, macroState, false);
-    }
-    const returnedSnapshot = usesInertScope ? attachSnapshotActorRef(this, resolvedActorScope, macroState) : this._attachPureActorRef(macroState, resolvedActorScope);
-    return [returnedSnapshot, this._collectEffects(microsteps)];
   }
   start(snapshot) {
     // Start rehydrated children that were active when persisted. Freshly
@@ -927,7 +967,15 @@ class StateMachine {
   restoreSnapshot(snapshot, actorScope) {
     const usesInertScope = !actorScope;
     const resolvedActorScope = actorScope ?? createInertActorScope(this);
-    const persistedVersion = snapshot.version;
+    const persistedMachine = snapshot.machine;
+    const legacyPersistedVersion = snapshot.version;
+    const persistedVersion = typeof persistedMachine?.version === 'string' ? persistedMachine.version : legacyPersistedVersion;
+    if (legacyPersistedVersion !== undefined && persistedMachine?.version !== undefined && persistedMachine.version !== legacyPersistedVersion) {
+      throw new Error(`Persisted snapshot version '${legacyPersistedVersion}' conflicts with machine version '${persistedMachine.version}'.`);
+    }
+    if (persistedMachine && typeof persistedMachine.id === 'string' && persistedMachine.id !== this.id) {
+      throw new Error(`Machine ID mismatch: persisted snapshot was created by machine '${persistedMachine.id}', but machine '${this.id}' was provided.` );
+    }
     if (persistedVersion !== this.version) {
       const migrate = this.config.migrate;
       if (typeof migrate !== 'function') {

package/dist/{StateMachine-673e9a91.development.cjs.js → StateMachine-73b20de0.development.cjs.js}

@@ -1,6 +1,6 @@
 'use strict';
 
-var dist_xstateActors = require('./index-c55fff73.development.cjs.js');
+var dist_xstateActors = require('./index-0317dbd5.development.cjs.js');
 
 function createSpawner(actorScope, actors, spawnedChildren) {
   return (src, options) => {
@@ -43,7 +43,7 @@ function createInertActorScope(actorLogic, snapshot, sourceSelf) {
   const snapshotRef = snapshot ? dist_xstateActors.getSnapshotActorRef(snapshot) : undefined;
   const previousSelf = sourceSelf ?? snapshotRef?.actor;
   const baseSystem = previousSelf?.system;
-  const system = previousSelf && baseSystem ? dist_xstateActors.createSnapshotSystem(baseSystem, previousSelf, dist_xstateActors.isMachineSnapshot(snapshot) ? snapshot.children : {}, sourceSelf ? undefined : snapshotRef?.systemState) : undefined;
+  const system = previousSelf && baseSystem ? dist_xstateActors.createSnapshotSystem(baseSystem, dist_xstateActors.isMachineSnapshot(snapshot) ? snapshot.children : {}, sourceSelf ? undefined : snapshotRef?.systemState) : undefined;
   const self = dist_xstateActors.createActor(actorLogic, {
     _inert: true,
     ...(previousSelf ? {
@@ -549,8 +549,9 @@ function getEmptyCanActorScope() {
 }
 class StateMachine {
   constructor(/** The raw config used to create the machine. */
-  config, sources) {
+  config, sources, validator) {
     this.config = config;
+    this.validator = validator;
     /** The machine's own version. */
     this.version = void 0;
     this.schemas = void 0;
@@ -646,7 +647,7 @@ class StateMachine {
         ...delays,
         ...sources.delays
       }
-    });
+    }, this.validator);
     // Providing sources does not change the serializable definition.
     provided._json = this._json;
     return provided;
@@ -677,6 +678,14 @@ class StateMachine {
   transition(snapshot, event, actorScope) {
     const usesInertScope = !actorScope;
     const resolvedActorScope = actorScope ?? createInertActorScope(this, snapshot);
+    if (this.validator) {
+      dist_xstateActors.assertValid(this.validator, {
+        kind: 'event',
+        logic: this,
+        event,
+        eventOrigin: actorScope && actorScope.self._lastSourceRef ? 'actor' : 'external'
+      });
+    }
     if (usesInertScope) {
       setInertActorScopeSnapshot(resolvedActorScope, snapshot, false);
     }
@@ -686,6 +695,14 @@ class StateMachine {
         setInertActorScopeSnapshot(resolvedActorScope, fastSnapshot, false);
       }
       const returnedSnapshot = usesInertScope && fastSnapshot !== snapshot ? attachSnapshotActorRef(this, resolvedActorScope, fastSnapshot) : this._attachPureActorRef(fastSnapshot, resolvedActorScope);
+      if (this.validator) {
+        dist_xstateActors.assertValid(this.validator, {
+          kind: 'result',
+          logic: this,
+          snapshot: returnedSnapshot,
+          effects: []
+        });
+      }
       return [returnedSnapshot, []];
     }
     const {
@@ -696,7 +713,16 @@ class StateMachine {
       setInertActorScopeSnapshot(resolvedActorScope, nextSnapshot, false);
     }
     const returnedSnapshot = usesInertScope ? nextSnapshot === snapshot ? nextSnapshot : attachSnapshotActorRef(this, resolvedActorScope, nextSnapshot) : this._attachPureActorRef(nextSnapshot, resolvedActorScope);
-    return [returnedSnapshot, this._collectEffects(microsteps)];
+    const effects = this._collectEffects(microsteps);
+    if (this.validator) {
+      dist_xstateActors.assertValid(this.validator, {
+        kind: 'result',
+        logic: this,
+        snapshot: returnedSnapshot,
+        effects
+      });
+    }
+    return [returnedSnapshot, effects];
   }
   _collectEffects(microsteps) {
     return microsteps.flatMap(([, actions]) => actions);
@@ -705,7 +731,8 @@ class StateMachine {
     if (isInertActorScope(actorScope)) {
       return snapshot;
     }
-    return attachSnapshotActorRef(this, actorScope, snapshot);
+    dist_xstateActors.setSnapshotActorRef(snapshot, actorScope.self, actorScope.system);
+    return snapshot;
   }
   _transitionFast(snapshot, event, actorScope) {
     if (snapshot.status !== 'active' || typeof snapshot.value !== 'string' || this.root.always?.length) {
@@ -868,37 +895,50 @@ class StateMachine {
     return this.initialTransition(input, actorScope)[0];
   }
   initialTransition(input, actorScope) {
+    if (this.validator) {
+      dist_xstateActors.assertValid(this.validator, {
+        kind: 'input',
+        logic: this,
+        input
+      });
+    }
     const usesInertScope = !actorScope;
     const resolvedActorScope = actorScope ?? createInertActorScope(this);
     const initEvent = dist_xstateActors.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));
-    let nextState;
-    let initialActions = [];
-    let microsteps = [];
-    let macroState;
+    const finalizeInitialResult = (macroState, microsteps) => {
+      if (usesInertScope) {
+        setInertActorScopeSnapshot(resolvedActorScope, macroState, false);
+      }
+      const returnedSnapshot = usesInertScope ? attachSnapshotActorRef(this, resolvedActorScope, macroState) : this._attachPureActorRef(macroState, resolvedActorScope);
+      const effects = this._collectEffects(microsteps);
+      if (this.validator) {
+        dist_xstateActors.assertValid(this.validator, {
+          kind: 'result',
+          logic: this,
+          snapshot: returnedSnapshot,
+          effects
+        });
+      }
+      return [returnedSnapshot, effects];
+    };
     try {
-      [nextState, initialActions] = dist_xstateActors.initialMicrostep(this.root, preInitialState, resolvedActorScope, initEvent, internalQueue);
-      ({
+      const [nextState, initialActions] = dist_xstateActors.initialMicrostep(this.root, preInitialState, resolvedActorScope, initEvent, internalQueue);
+      const {
         snapshot: macroState,
         microsteps
-      } = dist_xstateActors.macrostep(nextState, initEvent, resolvedActorScope, internalQueue, [[nextState, [...contextSpawnEffects, ...initialActions]]]));
+      } = dist_xstateActors.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]]);
-      macroState = errorMacrostep.snapshot;
-      microsteps = errorMacrostep.microsteps;
-      initialActions = [];
+      return finalizeInitialResult(errorMacrostep.snapshot, errorMacrostep.microsteps);
     }
-    if (usesInertScope) {
-      setInertActorScopeSnapshot(resolvedActorScope, macroState, false);
-    }
-    const returnedSnapshot = usesInertScope ? attachSnapshotActorRef(this, resolvedActorScope, macroState) : this._attachPureActorRef(macroState, resolvedActorScope);
-    return [returnedSnapshot, this._collectEffects(microsteps)];
   }
   start(snapshot) {
     // Start rehydrated children that were active when persisted. Freshly
@@ -929,7 +969,15 @@ class StateMachine {
   restoreSnapshot(snapshot, actorScope) {
     const usesInertScope = !actorScope;
     const resolvedActorScope = actorScope ?? createInertActorScope(this);
-    const persistedVersion = snapshot.version;
+    const persistedMachine = snapshot.machine;
+    const legacyPersistedVersion = snapshot.version;
+    const persistedVersion = typeof persistedMachine?.version === 'string' ? persistedMachine.version : legacyPersistedVersion;
+    if (legacyPersistedVersion !== undefined && persistedMachine?.version !== undefined && persistedMachine.version !== legacyPersistedVersion) {
+      throw new Error(`Persisted snapshot version '${legacyPersistedVersion}' conflicts with machine version '${persistedMachine.version}'.`);
+    }
+    if (persistedMachine && typeof persistedMachine.id === 'string' && persistedMachine.id !== this.id) {
+      throw new Error(`Machine ID mismatch: persisted snapshot was created by machine '${persistedMachine.id}', but machine '${this.id}' was provided.` );
+    }
     if (persistedVersion !== this.version) {
       const migrate = this.config.migrate;
       if (typeof migrate !== 'function') {