xstate 6.0.0-alpha.20 → 6.0.0-alpha.22

package/dist/{StateMachine-6661eb0d.development.cjs.js → StateMachine-1888d034.development.cjs.js}

@@ -1,6 +1,6 @@
 'use strict';
 
-var dist_xstateActors = require('./index-49293864.development.cjs.js');
+var dist_xstateActors = require('./index-41c0375c.development.cjs.js');
 
 function createSpawner(actorScope, {
   machine,
@@ -12,7 +12,7 @@ function createSpawner(actorScope, {
       if (!logic) {
         throw new Error(`Actor logic '${src}' not implemented in machine '${machine.id}'`);
       }
-      const actor = dist_xstateActors.createActor(logic, {
+      const actor = actorScope.system.createActorRef(logic, {
         id: options?.id,
         parent: actorScope.self,
         syncSnapshot: options?.syncSnapshot,
@@ -27,7 +27,7 @@ function createSpawner(actorScope, {
       spawnedChildren[actor.id] = actor;
       return actor;
     } else {
-      const actor = dist_xstateActors.createActor(src, {
+      const actor = actorScope.system.createActorRef(src, {
         id: options?.id,
         parent: actorScope.self,
         syncSnapshot: options?.syncSnapshot,
@@ -41,16 +41,114 @@ function createSpawner(actorScope, {
   return (src, options) => {
     const actor = spawn(src, options); // TODO: fix types
     spawnedChildren[actor.id] = actor;
-    actorScope.defer(() => {
-      if (actor._processingStatus === dist_xstateActors.ProcessingStatus.Stopped) {
-        return;
-      }
-      actor.start();
-    });
     return actor;
   };
 }
 
+/** @internal */
+function setInertActorScopeSnapshot(actorScope, snapshot, attachActorRef = true) {
+  actorScope.self._snapshot = snapshot;
+  if (attachActorRef && snapshot && typeof snapshot === 'object') {
+    dist_xstateActors.setSnapshotActorRef(snapshot, actorScope.self);
+  }
+  return snapshot;
+}
+
+/** @internal */
+function isInertActorScope(actorScope) {
+  return !!actorScope.self.options?._inert;
+}
+
+/** @internal */
+function attachSnapshotActorRef(actorLogic, actorScope, snapshot) {
+  const snapshotScope = createInertActorScope(actorLogic, snapshot, actorScope.self);
+  return setInertActorScopeSnapshot(snapshotScope, snapshot);
+}
+
+/** @internal */
+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 self = dist_xstateActors.createActor(actorLogic, {
+    _inert: true,
+    ...(previousSelf ? {
+      id: previousSelf.id
+    } : {}),
+    ...(system ? {
+      _systemRef: {
+        current: system
+      }
+    } : {})
+  });
+  if (previousSelf?._parent) {
+    self._parent = previousSelf._parent;
+  }
+  if (snapshot) {
+    self._snapshot = snapshot;
+  }
+  const actorScope = {
+    self: self,
+    defer: () => {},
+    id: self.id,
+    logger: self.system._logger,
+    sessionId: self.sessionId,
+    stopChild: child => child._stop(),
+    system: self.system,
+    emit: event => self.system.emitEvent(self, event),
+    actionExecutor: () => {}
+  };
+  return actorScope;
+}
+
+/** @deprecated Use `initialTransition(…)` instead. */
+function getInitialSnapshot(actorLogic, ...[input]) {
+  const actorScope = createInertActorScope(actorLogic);
+  return actorLogic.initialTransition(input, actorScope)[0];
+}
+
+/**
+ * Determines the next snapshot for the given `actorLogic` based on the given
+ * `snapshot` and `event`.
+ *
+ * If the `snapshot` is `undefined`, the initial snapshot of the `actorLogic` is
+ * used.
+ *
+ * @deprecated Use `transition(…)` instead.
+ * @example
+ *
+ * ```ts
+ * import { getNextSnapshot } from 'xstate';
+ * import { trafficLightMachine } from './trafficLightMachine.ts';
+ *
+ * const nextSnapshot = getNextSnapshot(
+ *   trafficLightMachine, // actor logic
+ *   undefined, // snapshot (or initial state if undefined)
+ *   { type: 'TIMER' }
+ * ); // event object
+ *
+ * console.log(nextSnapshot.value);
+ * // => 'yellow'
+ *
+ * const nextSnapshot2 = getNextSnapshot(
+ *   trafficLightMachine, // actor logic
+ *   nextSnapshot, // snapshot
+ *   { type: 'TIMER' }
+ * ); // event object
+ *
+ * console.log(nextSnapshot2.value);
+ * // =>'red'
+ * ```
+ */
+function getNextSnapshot(actorLogic, snapshot, event) {
+  const actorScope = createInertActorScope(actorLogic, snapshot);
+  const transitionResult = actorLogic.transition(snapshot, event, actorScope);
+  const nextSnapshot = Array.isArray(transitionResult) ? transitionResult[0] : transitionResult;
+  setInertActorScopeSnapshot(actorScope, nextSnapshot, false);
+  return nextSnapshot === snapshot ? nextSnapshot : attachSnapshotActorRef(actorLogic, actorScope, nextSnapshot);
+}
+
 const cache = new WeakMap();
 function memo(object, key, fn) {
   let memoizedData = cache.get(object);
@@ -572,19 +670,37 @@ class StateMachine {
    * @param event The received event
    */
   transition(snapshot, event, actorScope) {
-    const fastSnapshot = this._transitionFast(snapshot, event, actorScope);
+    const usesInertScope = !actorScope;
+    const resolvedActorScope = actorScope ?? createInertActorScope(this, snapshot);
+    if (usesInertScope) {
+      setInertActorScopeSnapshot(resolvedActorScope, snapshot, false);
+    }
+    const fastSnapshot = this._transitionFast(snapshot, event, resolvedActorScope);
     if (fastSnapshot) {
-      return [fastSnapshot, []];
+      if (usesInertScope) {
+        setInertActorScopeSnapshot(resolvedActorScope, fastSnapshot, false);
+      }
+      const returnedSnapshot = usesInertScope && fastSnapshot !== snapshot ? attachSnapshotActorRef(this, resolvedActorScope, fastSnapshot) : this._attachPureActorRef(fastSnapshot, resolvedActorScope);
+      return [returnedSnapshot, []];
     }
     const {
       snapshot: nextSnapshot,
       microsteps
-    } = dist_xstateActors.macrostep(snapshot, event, actorScope, []);
-    return [nextSnapshot, this._collectEffects(microsteps)];
+    } = dist_xstateActors.macrostep(snapshot, event, resolvedActorScope, []);
+    if (usesInertScope) {
+      setInertActorScopeSnapshot(resolvedActorScope, nextSnapshot, false);
+    }
+    const returnedSnapshot = usesInertScope ? nextSnapshot === snapshot ? nextSnapshot : attachSnapshotActorRef(this, resolvedActorScope, nextSnapshot) : this._attachPureActorRef(nextSnapshot, resolvedActorScope);
+    return [returnedSnapshot, this._collectEffects(microsteps)];
+  }
+  _collectEffects(microsteps) {
+    return microsteps.flatMap(([, actions]) => actions);
   }
-  _collectEffects(microsteps, initialActions = []) {
-    const effects = [...initialActions, ...microsteps.flatMap(([, actions]) => actions)];
-    return [...effects, ...dist_xstateActors.deriveDeferredStarts(effects)];
+  _attachPureActorRef(snapshot, actorScope) {
+    if (isInertActorScope(actorScope)) {
+      return snapshot;
+    }
+    return attachSnapshotActorRef(this, actorScope, snapshot);
   }
   _transitionFast(snapshot, event, actorScope) {
     if (snapshot.status !== 'active' || typeof snapshot.value !== 'string' || this.root.always?.length) {
@@ -645,6 +761,9 @@ class StateMachine {
     return dist_xstateActors.transitionNode(this.root, snapshot.value, snapshot, event, self) || [];
   }
   isInternalEventType(eventType) {
+    if (eventType === dist_xstateActors.XSTATE_TIMER) {
+      return true;
+    }
     for (const descriptor of this.internalEventDescriptors) {
       if (dist_xstateActors.matchesEventDescriptor(eventType, descriptor)) {
         return true;
@@ -711,7 +830,7 @@ class StateMachine {
       _nodes: [this.root],
       children: {},
       status: 'active'
-    }, this);
+    }, this, actorScope.self);
     if (typeof context === 'function') {
       const children = {};
       const spawn = createSpawner(actorScope, preInitial, initEvent, children);
@@ -744,30 +863,37 @@ class StateMachine {
     return this.initialTransition(input, actorScope)[0];
   }
   initialTransition(input, actorScope) {
+    const usesInertScope = !actorScope;
+    const resolvedActorScope = actorScope ?? createInertActorScope(this);
     const initEvent = dist_xstateActors.createInitEvent(input); // TODO: fix;
     const internalQueue = [];
-    const preInitialState = this._getPreInitialState(actorScope, initEvent);
+    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;
     try {
-      [nextState, initialActions] = dist_xstateActors.initialMicrostep(this.root, preInitialState, actorScope, initEvent, internalQueue);
+      [nextState, initialActions] = dist_xstateActors.initialMicrostep(this.root, preInitialState, resolvedActorScope, initEvent, internalQueue);
       ({
         snapshot: macroState,
         microsteps
-      } = dist_xstateActors.macrostep(nextState, initEvent, actorScope, internalQueue));
+      } = dist_xstateActors.macrostep(nextState, initEvent, resolvedActorScope, internalQueue, [[nextState, [...contextSpawnEffects, ...initialActions]]]));
     } catch (err) {
       if (!this.root.config.onError) {
         throw err;
       }
       const errorEvent = dist_xstateActors.createErrorPlatformEvent('execution', err);
-      const errorMacrostep = dist_xstateActors.macrostep(preInitialState, errorEvent, actorScope, []);
+      const errorMacrostep = dist_xstateActors.macrostep(preInitialState, errorEvent, resolvedActorScope, [], [[preInitialState, contextSpawnEffects]]);
       macroState = errorMacrostep.snapshot;
       microsteps = errorMacrostep.microsteps;
       initialActions = [];
     }
-    return [macroState, this._collectEffects(microsteps, initialActions)];
+    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
@@ -795,7 +921,9 @@ class StateMachine {
   getPersistedSnapshot(snapshot, options) {
     return dist_xstateActors.getPersistedSnapshot(snapshot, options);
   }
-  restoreSnapshot(snapshot, _actorScope) {
+  restoreSnapshot(snapshot, actorScope) {
+    const usesInertScope = !actorScope;
+    const resolvedActorScope = actorScope ?? createInertActorScope(this);
     const persistedVersion = snapshot.version;
     if (persistedVersion !== this.version) {
       const migrate = this.config.migrate;
@@ -815,9 +943,9 @@ class StateMachine {
       if (!logic) {
         continue;
       }
-      const actor = dist_xstateActors.createActor(logic, {
+      const actor = resolvedActorScope.system.createActorRef(logic, {
         id: actorId,
-        parent: _actorScope.self,
+        parent: resolvedActorScope.self,
         syncSnapshot: actorData.syncSnapshot,
         snapshot: childState,
         src,
@@ -828,6 +956,19 @@ class StateMachine {
       actor._rehydrated = true;
       children[actorId] = actor;
     }
+    const timers = {};
+    const persistedTimers = snapshotData.timers ?? {};
+    for (const [id, timer] of Object.entries(persistedTimers)) {
+      const target = typeof timer.target === 'string' ? timer.target === 'self' ? 'self' : children[timer.target] : resolvedActorScope.self._parent;
+      if (!target) {
+        const targetDescription = typeof timer.target === 'string' ? timer.target : timer.target.type;
+        throw new Error(`Unable to restore timer '${id}': target actor '${targetDescription}' is unavailable.`);
+      }
+      timers[id] = {
+        ...timer,
+        target
+      };
+    }
     const reviveHistoryValue = historyValue => {
       if (!historyValue || typeof historyValue !== 'object') {
         return {};
@@ -866,11 +1007,12 @@ class StateMachine {
     const restoredSnapshot = dist_xstateActors.createMachineSnapshot({
       ...persistedRest,
       children,
+      timers,
       _nodes: nodes,
       value: snapshotData.value,
       historyValue: revivedHistoryValue,
       _stateInputs: snapshotData.stateInputs ?? {}
-    }, this);
+    }, this, resolvedActorScope.self);
     const seen = new WeakSet();
     function reviveContext(contextPart) {
       if (seen.has(contextPart)) {
@@ -889,9 +1031,18 @@ class StateMachine {
       }
     }
     reviveContext(restoredSnapshot.context);
-    return restoredSnapshot;
+    if (usesInertScope) {
+      setInertActorScopeSnapshot(resolvedActorScope, restoredSnapshot, false);
+      return attachSnapshotActorRef(this, resolvedActorScope, restoredSnapshot);
+    }
+    return this._attachPureActorRef(restoredSnapshot, resolvedActorScope);
   }
 }
 
 exports.StateMachine = StateMachine;
 exports.StateNode = StateNode;
+exports.attachSnapshotActorRef = attachSnapshotActorRef;
+exports.createInertActorScope = createInertActorScope;
+exports.getInitialSnapshot = getInitialSnapshot;
+exports.getNextSnapshot = getNextSnapshot;
+exports.setInertActorScopeSnapshot = setInertActorScopeSnapshot;

package/dist/{StateMachine-f2b70732.cjs.js → StateMachine-610fe929.cjs.js}

@@ -1,6 +1,6 @@
 'use strict';
 
-var dist_xstateActors = require('./index-42956779.cjs.js');
+var dist_xstateActors = require('./index-434fac23.cjs.js');
 
 function createSpawner(actorScope, {
   machine,
@@ -12,7 +12,7 @@ function createSpawner(actorScope, {
       if (!logic) {
         throw new Error(`Actor logic '${src}' not implemented in machine '${machine.id}'`);
       }
-      const actor = dist_xstateActors.createActor(logic, {
+      const actor = actorScope.system.createActorRef(logic, {
         id: options?.id,
         parent: actorScope.self,
         syncSnapshot: options?.syncSnapshot,
@@ -27,7 +27,7 @@ function createSpawner(actorScope, {
       spawnedChildren[actor.id] = actor;
       return actor;
     } else {
-      const actor = dist_xstateActors.createActor(src, {
+      const actor = actorScope.system.createActorRef(src, {
         id: options?.id,
         parent: actorScope.self,
         syncSnapshot: options?.syncSnapshot,
@@ -41,16 +41,114 @@ function createSpawner(actorScope, {
   return (src, options) => {
     const actor = spawn(src, options); // TODO: fix types
     spawnedChildren[actor.id] = actor;
-    actorScope.defer(() => {
-      if (actor._processingStatus === dist_xstateActors.ProcessingStatus.Stopped) {
-        return;
-      }
-      actor.start();
-    });
     return actor;
   };
 }
 
+/** @internal */
+function setInertActorScopeSnapshot(actorScope, snapshot, attachActorRef = true) {
+  actorScope.self._snapshot = snapshot;
+  if (attachActorRef && snapshot && typeof snapshot === 'object') {
+    dist_xstateActors.setSnapshotActorRef(snapshot, actorScope.self);
+  }
+  return snapshot;
+}
+
+/** @internal */
+function isInertActorScope(actorScope) {
+  return !!actorScope.self.options?._inert;
+}
+
+/** @internal */
+function attachSnapshotActorRef(actorLogic, actorScope, snapshot) {
+  const snapshotScope = createInertActorScope(actorLogic, snapshot, actorScope.self);
+  return setInertActorScopeSnapshot(snapshotScope, snapshot);
+}
+
+/** @internal */
+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 self = dist_xstateActors.createActor(actorLogic, {
+    _inert: true,
+    ...(previousSelf ? {
+      id: previousSelf.id
+    } : {}),
+    ...(system ? {
+      _systemRef: {
+        current: system
+      }
+    } : {})
+  });
+  if (previousSelf?._parent) {
+    self._parent = previousSelf._parent;
+  }
+  if (snapshot) {
+    self._snapshot = snapshot;
+  }
+  const actorScope = {
+    self: self,
+    defer: () => {},
+    id: self.id,
+    logger: self.system._logger,
+    sessionId: self.sessionId,
+    stopChild: child => child._stop(),
+    system: self.system,
+    emit: event => self.system.emitEvent(self, event),
+    actionExecutor: () => {}
+  };
+  return actorScope;
+}
+
+/** @deprecated Use `initialTransition(…)` instead. */
+function getInitialSnapshot(actorLogic, ...[input]) {
+  const actorScope = createInertActorScope(actorLogic);
+  return actorLogic.initialTransition(input, actorScope)[0];
+}
+
+/**
+ * Determines the next snapshot for the given `actorLogic` based on the given
+ * `snapshot` and `event`.
+ *
+ * If the `snapshot` is `undefined`, the initial snapshot of the `actorLogic` is
+ * used.
+ *
+ * @deprecated Use `transition(…)` instead.
+ * @example
+ *
+ * ```ts
+ * import { getNextSnapshot } from 'xstate';
+ * import { trafficLightMachine } from './trafficLightMachine.ts';
+ *
+ * const nextSnapshot = getNextSnapshot(
+ *   trafficLightMachine, // actor logic
+ *   undefined, // snapshot (or initial state if undefined)
+ *   { type: 'TIMER' }
+ * ); // event object
+ *
+ * console.log(nextSnapshot.value);
+ * // => 'yellow'
+ *
+ * const nextSnapshot2 = getNextSnapshot(
+ *   trafficLightMachine, // actor logic
+ *   nextSnapshot, // snapshot
+ *   { type: 'TIMER' }
+ * ); // event object
+ *
+ * console.log(nextSnapshot2.value);
+ * // =>'red'
+ * ```
+ */
+function getNextSnapshot(actorLogic, snapshot, event) {
+  const actorScope = createInertActorScope(actorLogic, snapshot);
+  const transitionResult = actorLogic.transition(snapshot, event, actorScope);
+  const nextSnapshot = Array.isArray(transitionResult) ? transitionResult[0] : transitionResult;
+  setInertActorScopeSnapshot(actorScope, nextSnapshot, false);
+  return nextSnapshot === snapshot ? nextSnapshot : attachSnapshotActorRef(actorLogic, actorScope, nextSnapshot);
+}
+
 const cache = new WeakMap();
 function memo(object, key, fn) {
   let memoizedData = cache.get(object);
@@ -543,19 +641,37 @@ class StateMachine {
    * @param event The received event
    */
   transition(snapshot, event, actorScope) {
-    const fastSnapshot = this._transitionFast(snapshot, event, actorScope);
+    const usesInertScope = !actorScope;
+    const resolvedActorScope = actorScope ?? createInertActorScope(this, snapshot);
+    if (usesInertScope) {
+      setInertActorScopeSnapshot(resolvedActorScope, snapshot, false);
+    }
+    const fastSnapshot = this._transitionFast(snapshot, event, resolvedActorScope);
     if (fastSnapshot) {
-      return [fastSnapshot, []];
+      if (usesInertScope) {
+        setInertActorScopeSnapshot(resolvedActorScope, fastSnapshot, false);
+      }
+      const returnedSnapshot = usesInertScope && fastSnapshot !== snapshot ? attachSnapshotActorRef(this, resolvedActorScope, fastSnapshot) : this._attachPureActorRef(fastSnapshot, resolvedActorScope);
+      return [returnedSnapshot, []];
     }
     const {
       snapshot: nextSnapshot,
       microsteps
-    } = dist_xstateActors.macrostep(snapshot, event, actorScope, []);
-    return [nextSnapshot, this._collectEffects(microsteps)];
+    } = dist_xstateActors.macrostep(snapshot, event, resolvedActorScope, []);
+    if (usesInertScope) {
+      setInertActorScopeSnapshot(resolvedActorScope, nextSnapshot, false);
+    }
+    const returnedSnapshot = usesInertScope ? nextSnapshot === snapshot ? nextSnapshot : attachSnapshotActorRef(this, resolvedActorScope, nextSnapshot) : this._attachPureActorRef(nextSnapshot, resolvedActorScope);
+    return [returnedSnapshot, this._collectEffects(microsteps)];
+  }
+  _collectEffects(microsteps) {
+    return microsteps.flatMap(([, actions]) => actions);
   }
-  _collectEffects(microsteps, initialActions = []) {
-    const effects = [...initialActions, ...microsteps.flatMap(([, actions]) => actions)];
-    return [...effects, ...dist_xstateActors.deriveDeferredStarts(effects)];
+  _attachPureActorRef(snapshot, actorScope) {
+    if (isInertActorScope(actorScope)) {
+      return snapshot;
+    }
+    return attachSnapshotActorRef(this, actorScope, snapshot);
   }
   _transitionFast(snapshot, event, actorScope) {
     if (snapshot.status !== 'active' || typeof snapshot.value !== 'string' || this.root.always?.length) {
@@ -616,6 +732,9 @@ class StateMachine {
     return dist_xstateActors.transitionNode(this.root, snapshot.value, snapshot, event, self) || [];
   }
   isInternalEventType(eventType) {
+    if (eventType === dist_xstateActors.XSTATE_TIMER) {
+      return true;
+    }
     for (const descriptor of this.internalEventDescriptors) {
       if (dist_xstateActors.matchesEventDescriptor(eventType, descriptor)) {
         return true;
@@ -682,7 +801,7 @@ class StateMachine {
       _nodes: [this.root],
       children: {},
       status: 'active'
-    }, this);
+    }, this, actorScope.self);
     if (typeof context === 'function') {
       const children = {};
       const spawn = createSpawner(actorScope, preInitial, initEvent, children);
@@ -715,30 +834,37 @@ class StateMachine {
     return this.initialTransition(input, actorScope)[0];
   }
   initialTransition(input, actorScope) {
+    const usesInertScope = !actorScope;
+    const resolvedActorScope = actorScope ?? createInertActorScope(this);
     const initEvent = dist_xstateActors.createInitEvent(input); // TODO: fix;
     const internalQueue = [];
-    const preInitialState = this._getPreInitialState(actorScope, initEvent);
+    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;
     try {
-      [nextState, initialActions] = dist_xstateActors.initialMicrostep(this.root, preInitialState, actorScope, initEvent, internalQueue);
+      [nextState, initialActions] = dist_xstateActors.initialMicrostep(this.root, preInitialState, resolvedActorScope, initEvent, internalQueue);
       ({
         snapshot: macroState,
         microsteps
-      } = dist_xstateActors.macrostep(nextState, initEvent, actorScope, internalQueue));
+      } = dist_xstateActors.macrostep(nextState, initEvent, resolvedActorScope, internalQueue, [[nextState, [...contextSpawnEffects, ...initialActions]]]));
     } catch (err) {
       if (!this.root.config.onError) {
         throw err;
       }
       const errorEvent = dist_xstateActors.createErrorPlatformEvent('execution', err);
-      const errorMacrostep = dist_xstateActors.macrostep(preInitialState, errorEvent, actorScope, []);
+      const errorMacrostep = dist_xstateActors.macrostep(preInitialState, errorEvent, resolvedActorScope, [], [[preInitialState, contextSpawnEffects]]);
       macroState = errorMacrostep.snapshot;
       microsteps = errorMacrostep.microsteps;
       initialActions = [];
     }
-    return [macroState, this._collectEffects(microsteps, initialActions)];
+    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
@@ -766,7 +892,9 @@ class StateMachine {
   getPersistedSnapshot(snapshot, options) {
     return dist_xstateActors.getPersistedSnapshot(snapshot, options);
   }
-  restoreSnapshot(snapshot, _actorScope) {
+  restoreSnapshot(snapshot, actorScope) {
+    const usesInertScope = !actorScope;
+    const resolvedActorScope = actorScope ?? createInertActorScope(this);
     const persistedVersion = snapshot.version;
     if (persistedVersion !== this.version) {
       const migrate = this.config.migrate;
@@ -786,9 +914,9 @@ class StateMachine {
       if (!logic) {
         continue;
       }
-      const actor = dist_xstateActors.createActor(logic, {
+      const actor = resolvedActorScope.system.createActorRef(logic, {
         id: actorId,
-        parent: _actorScope.self,
+        parent: resolvedActorScope.self,
         syncSnapshot: actorData.syncSnapshot,
         snapshot: childState,
         src,
@@ -799,6 +927,19 @@ class StateMachine {
       actor._rehydrated = true;
       children[actorId] = actor;
     }
+    const timers = {};
+    const persistedTimers = snapshotData.timers ?? {};
+    for (const [id, timer] of Object.entries(persistedTimers)) {
+      const target = typeof timer.target === 'string' ? timer.target === 'self' ? 'self' : children[timer.target] : resolvedActorScope.self._parent;
+      if (!target) {
+        const targetDescription = typeof timer.target === 'string' ? timer.target : timer.target.type;
+        throw new Error(`Unable to restore timer '${id}': target actor '${targetDescription}' is unavailable.`);
+      }
+      timers[id] = {
+        ...timer,
+        target
+      };
+    }
     const reviveHistoryValue = historyValue => {
       if (!historyValue || typeof historyValue !== 'object') {
         return {};
@@ -834,11 +975,12 @@ class StateMachine {
     const restoredSnapshot = dist_xstateActors.createMachineSnapshot({
       ...persistedRest,
       children,
+      timers,
       _nodes: nodes,
       value: snapshotData.value,
       historyValue: revivedHistoryValue,
       _stateInputs: snapshotData.stateInputs ?? {}
-    }, this);
+    }, this, resolvedActorScope.self);
     const seen = new WeakSet();
     function reviveContext(contextPart) {
       if (seen.has(contextPart)) {
@@ -857,9 +999,18 @@ class StateMachine {
       }
     }
     reviveContext(restoredSnapshot.context);
-    return restoredSnapshot;
+    if (usesInertScope) {
+      setInertActorScopeSnapshot(resolvedActorScope, restoredSnapshot, false);
+      return attachSnapshotActorRef(this, resolvedActorScope, restoredSnapshot);
+    }
+    return this._attachPureActorRef(restoredSnapshot, resolvedActorScope);
   }
 }
 
 exports.StateMachine = StateMachine;
 exports.StateNode = StateNode;
+exports.attachSnapshotActorRef = attachSnapshotActorRef;
+exports.createInertActorScope = createInertActorScope;
+exports.getInitialSnapshot = getInitialSnapshot;
+exports.getNextSnapshot = getNextSnapshot;
+exports.setInertActorScopeSnapshot = setInertActorScopeSnapshot;