xstate 6.0.0-alpha.21 → 6.0.0-alpha.23

package/dist/{index-ec7c7a2d.development.cjs.js → index-41c0375c.development.cjs.js}

@@ -56,6 +56,8 @@ const XSTATE_INIT = '@xstate.init';
 const XSTATE_START = '@xstate.start';
 const XSTATE_SPAWN = '@xstate.spawn';
 const XSTATE_STOP = '@xstate.stop';
+const XSTATE_TERMINATE = '@xstate.terminate';
+const XSTATE_TIMER = 'xstate.timer';
 
 /**
  * Returns an event that represents an implicit event that is sent after the
@@ -160,34 +162,40 @@ function reportUnhandledError(err) {
 
 const symbolObservable = (() => typeof Symbol === 'function' && Symbol.observable || '@@observable')();
 
+function assertSendToEvent(event) {
+  if (typeof event === 'string') {
+    throw new Error(// eslint-disable-next-line @typescript-eslint/restrict-template-expressions
+    `Only event objects may be used with sendTo; use sendTo({ type: "${event}" }) instead` );
+  }
+}
 const builtInActions = {
-  // No-op: creation/registration are eager and pure; the start is a separate
-  // deferred `@xstate.start` effect (see `deriveDeferredStarts`).
-  ['@xstate.spawn']: _actor => {},
+  // Actor refs are created while resolving the next snapshot. Starting is a
+  // separate deferred effect so the returned list remains execution-complete.
+  ['@xstate.spawn']: actor => {
+    return actor.system.spawnActor(actor._parent, actor);
+  },
   ['@xstate.start']: actor => {
-    actor.start();
+    return actor.system.startActor(actor);
   },
-  ['@xstate.raise']: (actorScope, event, options) => {
-    actorScope.system.scheduler.schedule(actorScope.self, actorScope.self, event, options?.delay ?? 0, options?.id);
+  ['@xstate.raise']: (actorScope, _event, options) => {
+    return actorScope.system.scheduleTimer(actorScope.self, options.id, options?.delay ?? 0);
   },
   ['@xstate.sendTo']: (actorScope, actor, event, options) => {
-    if (typeof event === 'string') {
-      throw new Error(// eslint-disable-next-line @typescript-eslint/restrict-template-expressions
-      `Only event objects may be used with sendTo; use sendTo({ type: "${event}" }) instead` );
-    }
+    assertSendToEvent(event);
     if (options?.delay !== undefined) {
-      actorScope.system.scheduler.schedule(actorScope.self, actor, event, options?.delay ?? 0, options?.id);
+      return actorScope.system.scheduleTimer(actorScope.self, options.id, options?.delay ?? 0);
     } else {
-      actorScope.defer(() => {
-        actorScope.system._relay(actorScope.self, actor, event);
-      });
+      return actorScope.system._relay(actorScope.self, actor, event);
     }
   },
   ['@xstate.cancel']: (actorScope, sendId) => {
-    actorScope.system.scheduler.cancel(actorScope.self, sendId);
+    return actorScope.system.cancelTimer(actorScope.self, sendId);
   },
   ['@xstate.stop']: (actorScope, actor) => {
-    actorScope.stopChild(actor);
+    return actorScope.system.stopActor(actor);
+  },
+  ['@xstate.terminate']: (actor, termination) => {
+    return actor.system.terminateActor(actor, termination);
   }
 };
 
@@ -351,12 +359,109 @@ function createSubscriptionLogic() {
 // Singleton logic instance
 const subscriptionLogic = /* #__PURE__ */createSubscriptionLogic();
 
-const builtInExecutableAction = Symbol('xstate.builtInExecutableAction');
-function brandBuiltInExecutableAction(action) {
-  Object.defineProperty(action, builtInExecutableAction, {
-    value: true
-  });
-  return action;
+function execCustomEffect() {
+  return this.action?.(...this.args);
+}
+function execEmitEffect(runtime = this.source.system) {
+  return runtime.emitEvent(this.source, this.event);
+}
+
+/** @internal Creates an emitted-event effect. */
+function createEmitEffect(actorScope, event) {
+  return {
+    kind: 'emit',
+    exec: execEmitEffect,
+    type: event.type,
+    source: actorScope.self,
+    event,
+    params: undefined,
+    args: []
+  };
+}
+
+/** @internal Creates a directly executable user effect. */
+function createCustomEffect(type, action, params) {
+  return {
+    kind: 'action',
+    exec: action,
+    type,
+    action: action,
+    params,
+    args: []
+  };
+}
+function execSpawnEffect(runtime = this.actor.system) {
+  return runtime.spawnActor(this.source, this.actor);
+}
+function execStartEffect(runtime = this.actor.system) {
+  return runtime.startActor(this.actor);
+}
+function execStopEffect(runtime = this.source.system) {
+  return runtime.stopActor(this.actor);
+}
+function execTerminateEffect(runtime = this.actor.system) {
+  const termination = this.status === 'done' ? {
+    status: 'done',
+    output: this.output,
+    error: undefined
+  } : {
+    status: 'error',
+    output: undefined,
+    error: this.error
+  };
+  return runtime.terminateActor(this.actor, termination);
+}
+function execRaiseEffect(runtime = this.source.system) {
+  return runtime.scheduleTimer(this.source, this.id, this.delay ?? 0);
+}
+function execSendToEffect(runtime = this.source.system) {
+  assertSendToEvent(this.event);
+  if (this.delay !== undefined) {
+    return runtime.scheduleTimer(this.source, this.id, this.delay);
+  }
+  return runtime.sendEvent(this.source, this.target, this.event);
+}
+function execCancelEffect(runtime = this.source.system) {
+  return runtime.cancelTimer(this.source, this.id);
+}
+function updateLogicalTimers(snapshot, effect, actorScope) {
+  if (!isBuiltInExecutableAction(effect)) {
+    return snapshot;
+  }
+  if (effect.type === '@xstate.cancel') {
+    if (!snapshot.timers?.[effect.id]) {
+      return snapshot;
+    }
+    const timers = {
+      ...snapshot.timers
+    };
+    delete timers[effect.id];
+    return {
+      ...snapshot,
+      timers
+    };
+  }
+  if (effect.type !== '@xstate.raise' && effect.type !== '@xstate.sendTo' || effect.delay === undefined) {
+    return snapshot;
+  }
+  let nextTimerId = snapshot._nextTimerId ?? 0;
+  const id = effect.id ?? `xstate.timer.auto.${nextTimerId++}`;
+  effect.id = id;
+  const target = effect.type === '@xstate.raise' || effect.target === actorScope.self ? 'self' : effect.target;
+  return {
+    ...snapshot,
+    timers: {
+      ...snapshot.timers,
+      [id]: {
+        id,
+        delay: effect.delay,
+        type: effect.type,
+        event: effect.event,
+        target
+      }
+    },
+    _nextTimerId: nextTimerId
+  };
 }
 function mergeContextPatch(context, patch) {
   return {
@@ -365,43 +470,55 @@ function mergeContextPatch(context, patch) {
   };
 }
 function pushBuiltInAction(actions, action, ...args) {
-  actions.push({
+  const actionRecord = {
     action,
     args
-  });
+  };
+  actions.push(actionRecord);
+  return actionRecord;
 }
-function registerSpawnedChild(actor, id) {
-  return Object.assign(function registerChild(args) {
+function applyChildUpdate(snapshot, update, actorScope) {
+  if (update.type === 'add') {
     return {
+      ...snapshot,
       children: {
-        ...args.children,
-        [id]: actor
+        ...snapshot.children,
+        [update.id]: update.actor
       }
     };
-  }, {
-    _special: true
-  });
-}
-function unregisterChild(actor) {
-  return Object.assign(function removeChild(args) {
-    const children = {
-      ...args.children
-    };
-    for (const key of Object.keys(children)) {
-      if (children[key] === actor) {
-        delete children[key];
-      }
+  }
+  const children = {
+    ...snapshot.children
+  };
+  let owned = update.actor._parent === actorScope.self;
+  for (const key of Object.keys(children)) {
+    if (children[key] === update.actor) {
+      owned = true;
+      delete children[key];
     }
-    return {
-      children
-    };
-  }, {
-    _special: true
-  });
+  }
+  if (!owned) {
+    throw new Error(`Cannot stop child actor ${update.actor.id} of ${actorScope.self.id} because it is not a child` );
+  }
+  actorScope.system._unregister(update.actor);
+  return {
+    ...snapshot,
+    children
+  };
+}
+function getTransitionActionRecord(action) {
+  if (typeof action === 'object' && action !== null && 'action' in action && typeof action.action === 'function') {
+    return action;
+  }
+  return undefined;
 }
 function pushSpawnedChild(actions, actor, id) {
-  pushBuiltInAction(actions, builtInActions['@xstate.spawn'], actor);
-  actions.push(registerSpawnedChild(actor, id ?? actor.id));
+  const action = pushBuiltInAction(actions, builtInActions['@xstate.spawn'], actor);
+  action.childUpdate = {
+    type: 'add',
+    actor,
+    id: id ?? actor.id
+  };
 }
 function createTransitionEnqueue(actorScope, actions, internalEvents, actorSubscriptions = false, createActors = true) {
   const props = {
@@ -431,7 +548,7 @@ function createTransitionEnqueue(actorScope, actions, internalEvents, actorSubsc
           id: options?.id ?? options?.registryKey ?? logic.id
         };
       }
-      const actor = createActor(logic, {
+      const actor = actorScope.system.createActorRef(logic, {
         ...options,
         parent: actorScope.self
       });
@@ -450,8 +567,11 @@ function createTransitionEnqueue(actorScope, actions, internalEvents, actorSubsc
     },
     stop: actor => {
       if (actor) {
-        pushBuiltInAction(actions, builtInActions['@xstate.stop'], actorScope, actor);
-        actions.push(unregisterChild(actor));
+        const action = pushBuiltInAction(actions, builtInActions['@xstate.stop'], actorScope, actor);
+        action.childUpdate = {
+          type: 'remove',
+          actor
+        };
       }
     }
   };
@@ -463,7 +583,7 @@ function createTransitionEnqueue(actorScope, actions, internalEvents, actorSubsc
           eventType,
           mapper
         };
-        const listenerActor = createActor(listenerLogic, {
+        const listenerActor = actorScope.system.createActorRef(listenerLogic, {
           input,
           parent: actorScope.self
         });
@@ -478,7 +598,7 @@ function createTransitionEnqueue(actorScope, actions, internalEvents, actorSubsc
           actor,
           mappers: normalizedMappers
         };
-        const subscriptionActor = createActor(subscriptionLogic, {
+        const subscriptionActor = actorScope.system.createActorRef(subscriptionLogic, {
           input,
           parent: actorScope.self
         });
@@ -497,6 +617,9 @@ function getBuiltInActionFields(action, args) {
       {
         const [actor] = args;
         return {
+          kind: 'builtin',
+          exec: execSpawnEffect,
+          source: actor._parent,
           actor,
           id: actor.id,
           logic: actor.logic,
@@ -508,6 +631,9 @@ function getBuiltInActionFields(action, args) {
       {
         const [, event, options] = args;
         return {
+          kind: 'builtin',
+          exec: execRaiseEffect,
+          source: args[0].self,
           event,
           id: options?.id,
           delay: options?.delay
@@ -517,6 +643,9 @@ function getBuiltInActionFields(action, args) {
       {
         const [, target, event, options] = args;
         return {
+          kind: 'builtin',
+          exec: execSendToEffect,
+          source: args[0].self,
           target,
           event,
           id: options?.id,
@@ -527,6 +656,9 @@ function getBuiltInActionFields(action, args) {
       {
         const [, id] = args;
         return {
+          kind: 'builtin',
+          exec: execCancelEffect,
+          source: args[0].self,
           id
         };
       }
@@ -534,7 +666,11 @@ function getBuiltInActionFields(action, args) {
       {
         const [, actor] = args;
         return {
-          actor
+          kind: 'builtin',
+          exec: execStopEffect,
+          source: args[0].self,
+          actor,
+          id: actor.id
         };
       }
     default:
@@ -542,19 +678,91 @@ function getBuiltInActionFields(action, args) {
   }
 }
 function createStartEffect(actor) {
-  const action = builtInActions['@xstate.start'];
   const args = [actor];
-  return brandBuiltInExecutableAction({
+  return {
+    kind: 'builtin',
+    exec: execStartEffect,
     type: XSTATE_START,
-    params: {
-      action,
-      args
-    },
+    source: actor._parent,
+    params: undefined,
     args,
-    exec: action.bind(null, actor),
     actor,
     id: actor.id
-  });
+  };
+}
+function createSpawnEffect(actor) {
+  const args = [actor];
+  return {
+    kind: 'builtin',
+    exec: execSpawnEffect,
+    type: XSTATE_SPAWN,
+    source: actor._parent,
+    params: undefined,
+    args,
+    actor,
+    id: actor.id,
+    logic: actor.logic,
+    src: actor.src,
+    input: actor.options?.input
+  };
+}
+
+/** @internal Creates an immediate actor-to-actor delivery effect. */
+function createSendToEffect(actorScope, target, event) {
+  const args = [actorScope, target, event, {}];
+  return {
+    kind: 'builtin',
+    exec: execSendToEffect,
+    type: '@xstate.sendTo',
+    source: actorScope.self,
+    target,
+    event,
+    id: undefined,
+    delay: undefined,
+    params: undefined,
+    args
+  };
+}
+
+/** @internal Creates the terminal lifecycle effect for an actor. */
+function createTerminationEffect(actorScope, snapshot) {
+  if (snapshot.status !== 'done' && snapshot.status !== 'error') {
+    throw new Error('Cannot terminate an active or stopped actor');
+  }
+  const termination = snapshot.status === 'done' ? {
+    status: 'done',
+    output: snapshot.output,
+    error: undefined
+  } : {
+    status: 'error',
+    output: undefined,
+    error: snapshot.error
+  };
+  const args = [actorScope.self, termination];
+  return {
+    kind: 'builtin',
+    exec: execTerminateEffect,
+    type: XSTATE_TERMINATE,
+    source: actorScope.self,
+    actor: actorScope.self,
+    id: actorScope.self.id,
+    ...termination,
+    params: undefined,
+    args
+  };
+}
+
+/**
+ * Ensures that a newly terminal snapshot has exactly one ordered actor
+ * termination effect.
+ *
+ * @internal
+ */
+function finalizeTransitionResult(actorScope, previousSnapshot, [nextSnapshot, effects]) {
+  const becameTerminal = nextSnapshot.status === 'done' || nextSnapshot.status === 'error';
+  const wasTerminal = previousSnapshot?.status === 'done' || previousSnapshot?.status === 'error';
+  const hasTerminationEffect = effects.some(effect => typeof effect === 'object' && effect !== null && 'type' in effect && effect.type === XSTATE_TERMINATE);
+  return becameTerminal && !wasTerminal && !hasTerminationEffect ? [nextSnapshot, [...effects, createTerminationEffect(actorScope, nextSnapshot)]] : [nextSnapshot, effects];
 }
 
 /**
@@ -583,14 +791,19 @@ function deriveDeferredStarts(effects) {
   return [...attachedStarts, ...childStarts];
 }
 function isBuiltInExecutableAction(action) {
-  return action[builtInExecutableAction] === true;
+  return action.kind === 'builtin';
+}
+
+/** Executes transition effects sequentially, awaiting each runtime operation. */
+async function executeEffects(effects, runtime) {
+  for (const effect of effects) {
+    await effect.exec(runtime);
+  }
 }
 function resolveActionsWithContext(currentSnapshot, event, actorScope, actions) {
   let intermediateSnapshot = currentSnapshot;
   const executableActions = [];
   for (const action of actions) {
-    const isInline = typeof action === 'function';
-    const resolvedAction = isInline ? action : typeof action === 'object' && 'action' in action && typeof action.action === 'function' ? action.action.bind(null, ...action.args) : false;
     const actionArgs = {
       context: intermediateSnapshot.context,
       event,
@@ -602,20 +815,29 @@ function resolveActionsWithContext(currentSnapshot, event, actorScope, actions)
       actions: currentSnapshot.machine.implementations.actions,
       actorSources: currentSnapshot.machine.implementations.actorSources
     };
+    const isInline = typeof action === 'function';
+    const actionRecord = getTransitionActionRecord(action);
+    const resolvedAction = isInline ? action : actionRecord ? actionRecord.action.bind(null, ...actionRecord.args) : false;
     let actionParams = undefined;
     if (typeof action === 'object' && action !== null) {
       const {
         type: _,
+        childUpdate: _childUpdate,
         ...emittedEventParams
       } = action;
       actionParams = emittedEventParams;
     }
+    if (actionRecord?.childUpdate) {
+      intermediateSnapshot = applyChildUpdate(intermediateSnapshot, actionRecord.childUpdate, actorScope);
+    }
     if (resolvedAction && '_special' in resolvedAction) {
       executableActions.push({
+        kind: 'action',
+        exec: execCustomEffect,
         type: typeof action === 'object' ? 'action' in action && typeof action.action === 'function' ? action.action.name ?? '(anonymous)' : action.type ?? '(anonymous)' : action.name || '(anonymous)',
         params: actionParams,
         args: [],
-        exec: undefined
+        action: undefined
       });
       const specialAction = resolvedAction;
       const res = specialAction(actionArgs, emptyEnqueueObject);
@@ -637,14 +859,26 @@ function resolveActionsWithContext(currentSnapshot, event, actorScope, actions)
     }
     if (!resolvedAction || !('resolve' in resolvedAction)) {
       const builtInFields = typeof action === 'object' && action !== null && 'action' in action && typeof action.action === 'function' ? getBuiltInActionFields(action.action, action.args) : undefined;
+      const isEmittedEvent = typeof action === 'object' && action !== null && !actionRecord;
       const executableAction = {
+        kind: builtInFields ? 'builtin' : isEmittedEvent ? 'emit' : 'action',
         type: typeof action === 'object' ? 'action' in action && typeof action.action === 'function' ? action.action.name ?? '(anonymous)' : action.type : action.name || '(anonymous)',
-        params: actionParams,
+        params: builtInFields ? undefined : actionParams,
         args: typeof action === 'object' && 'action' in action ? action.args : [],
-        exec: resolvedAction || (typeof action === 'object' && action !== null ? () => actorScope.defer(() => actorScope.emit(action)) : undefined),
+        ...(builtInFields ? {} : isEmittedEvent ? {
+          source: actorScope.self,
+          event: action
+        } : {
+          action: actionRecord?.action ?? (isInline ? action : undefined)
+        }),
+        ...(!builtInFields ? {
+          exec: isEmittedEvent ? execEmitEffect : execCustomEffect
+        } : {}),
         ...builtInFields
       };
-      executableActions.push(builtInFields ? brandBuiltInExecutableAction(executableAction) : executableAction);
+      const typedExecutableAction = executableAction;
+      intermediateSnapshot = updateLogicalTimers(intermediateSnapshot, typedExecutableAction, actorScope);
+      executableActions.push(typedExecutableAction);
       continue;
     }
   }
@@ -1434,6 +1668,17 @@ function microstep(transitions, currentSnapshot, actorScope, event, isInitial, i
       return [[wrappedAction], undefined, undefined];
     };
     let nextState = currentSnapshot;
+    const getInvokeStopActions = (stateNode, children) => {
+      const actions = [];
+      const enqueue = createTransitionEnqueue(actorScope, actions, []);
+      for (const invokeDef of stateNode.invoke) {
+        const child = children[invokeDef.id];
+        if (child) {
+          enqueue.stop(child);
+        }
+      }
+      return actions;
+    };
     const exitStates = () => {
       const statesToExit = computeExitSet(filteredTransitions, mutStateNodeSet, currentSnapshot, event, actorScope);
       statesToExit.sort((a, b) => b.order - a.order);
@@ -1455,7 +1700,7 @@ function microstep(transitions, currentSnapshot, actorScope, event, isInitial, i
       }
       for (const exitStateNode of statesToExit) {
         const stateInput = getStateInput(currentSnapshot, exitStateNode.id);
-        const [exitActions, nextContext, internalEvents] = exitStateNode.exit ? getStateActionsAndContext(exitStateNode.exit, nextState.context, currentSnapshot.children, stateInput) : [[]];
+        const [exitActions, nextContext, internalEvents] = exitStateNode.exit ? getStateActionsAndContext(exitStateNode.exit, nextState.context, currentSnapshot.children, stateInput) : [[], undefined, undefined];
         if (internalEvents?.length) {
           internalQueue.push(...internalEvents);
         }
@@ -1467,12 +1712,11 @@ function microstep(transitions, currentSnapshot, actorScope, event, isInitial, i
         const [resolvedState, resolvedActions] = resolveActionsWithContext(nextState, event, actorScope, exitActions);
         nextState = resolvedState;
         executableActions.push(...resolvedActions);
-        for (const def of exitStateNode.invoke) {
-          const childActor = nextState.children[def.id];
-          if (childActor && !childActor._isExternal) {
-            actorScope.stopChild(childActor);
-          }
-          delete nextState.children[def.id];
+        const invokeStopActions = getInvokeStopActions(exitStateNode, nextState.children);
+        if (invokeStopActions.length) {
+          const [stoppedState, stopEffects] = resolveActionsWithContext(nextState, event, actorScope, invokeStopActions);
+          nextState = stoppedState;
+          executableActions.push(...stopEffects);
         }
         mutStateNodeSet.delete(exitStateNode);
       }
@@ -1643,7 +1887,7 @@ function microstep(transitions, currentSnapshot, actorScope, event, isInitial, i
       }
       const completedNodes = new Set();
       const children = {
-        ...currentSnapshot.children
+        ...nextState.children
       };
       for (const stateNodeToEnter of [...statesToEnter].sort((a, b) => a.order - b.order)) {
         mutStateNodeSet.add(stateNodeToEnter);
@@ -1670,7 +1914,7 @@ function microstep(transitions, currentSnapshot, actorScope, event, isInitial, i
             event,
             output: getEventOutput(event)
           }) : invokeDef.input;
-          const actor = createActor(logic, {
+          const actor = actorScope.system.createActorRef(logic, {
             ...invokeDef,
             input,
             parent: actorScope.self,
@@ -1799,6 +2043,12 @@ function microstep(transitions, currentSnapshot, actorScope, event, isInitial, i
       const [resolvedState, resolvedActions] = resolveActionsWithContext(nextState, event, actorScope, allExitActions);
       nextState = resolvedState;
       executableActions.push(...resolvedActions);
+      const [stoppedState, stopEffects] = stopChildren(nextState, event, actorScope);
+      nextState = stoppedState;
+      executableActions.push(...stopEffects);
+      const [withoutTimers, cancelEffects] = cancelTimers(nextState, event, actorScope);
+      nextState = withoutTimers;
+      executableActions.push(...cancelEffects);
     }
     if (historyValue === currentSnapshot.historyValue && currentSnapshot._nodes.length === mutStateNodeSet.size && currentSnapshot._nodes.every(node => mutStateNodeSet.has(node))) {
       // If context was changed (e.g. by entry actions during self-transition),
@@ -1872,9 +2122,27 @@ function getTransitionResult(transition, snapshot, event, actorScope, options) {
     input: resolvedInput
   };
 }
-function macrostep(snapshot, event, actorScope, internalQueue) {
+function macrostep(snapshot, event, actorScope, internalQueue, initialMicrosteps = []) {
   let nextSnapshot = snapshot;
-  const microsteps = [];
+  const microsteps = initialMicrosteps.slice();
+  function completeMacrostep() {
+    const effects = microsteps.flatMap(([, actions]) => actions);
+    const starts = deriveDeferredStarts(effects);
+    const shouldTerminate = (snapshot.status === 'active' || initialMicrosteps.length > 0) && (nextSnapshot.status === 'done' || nextSnapshot.status === 'error');
+    if (starts.length || shouldTerminate) {
+      const terminalEffects = shouldTerminate ? [...starts, createTerminationEffect(actorScope, nextSnapshot)] : starts;
+      if (microsteps.length) {
+        const [lastSnapshot, lastEffects] = microsteps.at(-1);
+        microsteps[microsteps.length - 1] = [lastSnapshot, [...lastEffects, ...terminalEffects]];
+      } else {
+        microsteps.push([nextSnapshot, terminalEffects]);
+      }
+    }
+    return {
+      snapshot: nextSnapshot,
+      microsteps
+    };
+  }
   function addMicrostep(step, transitions) {
     // collect microsteps; surfaced on the enclosing '@xstate.transition' event
     // via its `microsteps[]` facet (there is no standalone microstep event)
@@ -1886,20 +2154,39 @@ function macrostep(snapshot, event, actorScope, internalQueue) {
 
   // Handle stop event
   if (event.type === XSTATE_STOP) {
-    nextSnapshot = cloneMachineSnapshot(stopChildren(nextSnapshot, actorScope), {
+    const [stoppedChildrenSnapshot, stopEffects] = stopChildren(nextSnapshot, event, actorScope);
+    const [withoutTimers, cancelEffects] = cancelTimers(stoppedChildrenSnapshot, event, actorScope);
+    nextSnapshot = cloneMachineSnapshot(withoutTimers, {
       status: 'stopped'
     });
-    addMicrostep([nextSnapshot, []], []);
-    return {
-      snapshot: nextSnapshot,
-      microsteps
-    };
+    addMicrostep([nextSnapshot, [...stopEffects, ...cancelEffects]], []);
+    return completeMacrostep();
   }
   let nextEvent = event;
+  if (event.type === XSTATE_TIMER) {
+    const timer = nextSnapshot.timers[event.id];
+    if (!timer) {
+      return completeMacrostep();
+    }
+    const timers = {
+      ...nextSnapshot.timers
+    };
+    delete timers[timer.id];
+    nextSnapshot = cloneMachineSnapshot(nextSnapshot, {
+      timers
+    });
+    if (timer.type === '@xstate.raise') {
+      internalQueue.push(timer.event);
+      addMicrostep([nextSnapshot, []], []);
+    } else {
+      const target = timer.target === 'self' ? actorScope.self : timer.target;
+      addMicrostep([nextSnapshot, [createSendToEffect(actorScope, target, timer.event)]], []);
+    }
+  }
 
   // Assume the state is at rest (no raised events)
   // Determine the next state based on the next microstep
-  if (nextEvent.type !== XSTATE_INIT) {
+  if (nextEvent.type !== XSTATE_INIT && nextEvent.type !== XSTATE_TIMER) {
     const currentEvent = nextEvent;
     const isErr = isErrorEvent(currentEvent);
     const transitions = nextSnapshot.machine.getTransitionData(nextSnapshot, currentEvent, actorScope.self);
@@ -1912,10 +2199,7 @@ function macrostep(snapshot, event, actorScope, internalQueue) {
         error: currentEvent.error
       });
       addMicrostep([nextSnapshot, []], []);
-      return {
-        snapshot: nextSnapshot,
-        microsteps
-      };
+      return completeMacrostep();
     }
     const step = microstep(transitions, snapshot, actorScope, nextEvent, false,
     // isInitial
@@ -1953,13 +2237,7 @@ function macrostep(snapshot, event, actorScope, internalQueue) {
     shouldSelectEventlessTransitions = nextSnapshot !== previousState;
     addMicrostep(step, enabledTransitions);
   }
-  if (nextSnapshot.status !== 'active' && nextSnapshot.children) {
-    stopChildren(nextSnapshot, actorScope);
-  }
-  return {
-    snapshot: nextSnapshot,
-    microsteps
-  };
+  return completeMacrostep();
 }
 
 /**
@@ -2019,17 +2297,29 @@ function transitionToHasEffect(transitionTo, context, event, snapshot, self, imp
   }
   return res !== undefined;
 }
-function stopChildren(snapshot, actorScope) {
+function stopChildren(snapshot, event, actorScope) {
   let children;
   if (!snapshot.children || (children = Object.values(snapshot.children).filter(Boolean)).length === 0) {
-    return snapshot;
+    return [snapshot, []];
   }
+  const actions = [];
+  const enqueue = createTransitionEnqueue(actorScope, actions, []);
   for (const child of children) {
-    actorScope.stopChild(child);
+    enqueue.stop(child);
   }
-  return cloneMachineSnapshot(snapshot, {
-    children: {}
-  });
+  return resolveActionsWithContext(snapshot, event, actorScope, actions);
+}
+function cancelTimers(snapshot, event, actorScope) {
+  const timerIds = Object.keys(snapshot.timers);
+  if (!timerIds.length) {
+    return [snapshot, []];
+  }
+  const actions = [];
+  const enqueue = createTransitionEnqueue(actorScope, actions, []);
+  for (const id of timerIds) {
+    enqueue.cancel(id);
+  }
+  return resolveActionsWithContext(snapshot, event, actorScope, actions);
 }
 function selectEventlessTransitions(snapshot, event, actorScope) {
   const enabledTransitionSet = new Set();
@@ -2074,6 +2364,129 @@ function evaluateCandidate(candidate, event, snapshot, stateNode, self) {
   return true;
 }
 
+/** @internal */
+const snapshotActorRef = Symbol('xstate.snapshotActorRef');
+
+/** Snapshot-scoped actor identity and system view. @internal */
+
+function getSnapshotChildren(snapshot) {
+  return 'children' in snapshot && snapshot.children ? snapshot.children : {};
+}
+
+/**
+ * Creates the isolated receptionist/id view used by a pure branch. Scheduling,
+ * relaying and clocks remain delegated to the snapshot's execution system.
+ *
+ * @internal
+ */
+function createSnapshotSystem(baseSystem, self, children, baseState) {
+  const registeredActors = new Map(baseState?.children ?? baseSystem.children);
+  const keyedActors = new Map(baseState?.keyedActors ?? Object.entries(baseSystem.getAll()).filter(entry => !!entry[1]));
+  const reverseKeyedActors = new WeakMap();
+  let booksSelf = true;
+  const system = {
+    ...baseSystem,
+    children: registeredActors,
+    keyedActors,
+    reverseKeyedActors,
+    _snapshot: {
+      ...(baseState?.snapshot ?? baseSystem._snapshot)
+    },
+    _bookId: () => {
+      if (booksSelf) {
+        booksSelf = false;
+        return self.sessionId ?? self.id;
+      }
+      return `x:${system._snapshot._nextActorId++}`;
+    },
+    _register: (sessionId, actor) => {
+      registeredActors.set(sessionId, actor);
+      return sessionId;
+    },
+    _unregister: actor => {
+      if (actor.sessionId) {
+        registeredActors.delete(actor.sessionId);
+      }
+      const registryKey = reverseKeyedActors.get(actor);
+      if (registryKey !== undefined && keyedActors.get(registryKey) === actor) {
+        keyedActors.delete(registryKey);
+      }
+      reverseKeyedActors.delete(actor);
+    },
+    _set: (registryKey, actor) => {
+      const existing = keyedActors.get(registryKey);
+      if (existing && existing !== actor) {
+        throw new Error(`Actor with registry key '${String(registryKey)}' already exists.`);
+      }
+      keyedActors.set(registryKey, actor);
+      reverseKeyedActors.set(actor, registryKey);
+    },
+    get: registryKey => keyedActors.get(registryKey),
+    getAll: () => Object.fromEntries(keyedActors),
+    // Pure transition resolution must not leak topology inspection events into
+    // a live runtime system.
+    _sendInspectionEvent: () => {}
+  };
+  for (const [registryKey, actor] of keyedActors) {
+    reverseKeyedActors.set(actor, registryKey);
+  }
+  for (const actor of Object.values(children)) {
+    if (!actor) {
+      continue;
+    }
+    if (actor.sessionId) {
+      registeredActors.set(actor.sessionId, actor);
+    }
+    const registryKey = actor.registryKey;
+    if (registryKey) {
+      keyedActors.set(registryKey, actor);
+      reverseKeyedActors.set(actor, registryKey);
+    }
+  }
+  return system;
+}
+
+/** Returns the actor identity associated with a transition snapshot. @internal */
+function getSnapshotActorRef(snapshot) {
+  return snapshot[snapshotActorRef];
+}
+
+/**
+ * Copies an internal actor association without rebuilding its system view.
+ *
+ * @internal
+ */
+function copySnapshotActorRef(source, target) {
+  const ref = getSnapshotActorRef(source);
+  if (ref) {
+    Object.defineProperty(target, snapshotActorRef, {
+      configurable: true,
+      value: ref
+    });
+  }
+}
+
+/**
+ * Associates a transition snapshot with an actor and an immutable system view.
+ * The internal association is excluded from enumeration and persistence.
+ *
+ * @internal
+ */
+function setSnapshotActorRef(snapshot, actor, baseSystem = actor.system) {
+  const system = createSnapshotSystem(baseSystem, actor, getSnapshotChildren(snapshot));
+  Object.defineProperty(snapshot, snapshotActorRef, {
+    configurable: true,
+    value: {
+      actor,
+      systemState: {
+        children: system.children,
+        keyedActors: system.keyedActors,
+        snapshot: system._snapshot
+      }
+    }
+  });
+}
+
 function isMachineSnapshot(value) {
   return !!value && typeof value === 'object' && 'machine' in value && 'value' in value;
 }
@@ -2096,6 +2509,7 @@ const machineSnapshotToJSON = function toJSON() {
   const {
     _nodes: nodes,
     _stateInputs,
+    [snapshotActorRef]: _actorRef,
     tags,
     machine,
     getMeta,
@@ -2132,8 +2546,8 @@ function collectTags(stateNodes) {
   }
   return tags;
 }
-function createMachineSnapshot(config, machine) {
-  return {
+function createMachineSnapshot(config, machine, actorRef) {
+  const snapshot = {
     status: config.status,
     output: config.output,
     error: config.error,
@@ -2143,8 +2557,10 @@ function createMachineSnapshot(config, machine) {
     value: config.value ?? getStateValue(machine.root, config._nodes),
     tags: collectTags(config._nodes),
     children: config.children,
+    timers: config.timers ?? {},
     historyValue: config.historyValue || {},
     _stateInputs: config._stateInputs || {},
+    _nextTimerId: config._nextTimerId ?? 0,
     matches: machineSnapshotMatches,
     hasTag: machineSnapshotHasTag,
     can: machineSnapshotCan,
@@ -2152,6 +2568,10 @@ function createMachineSnapshot(config, machine) {
     getInputs: machineSnapshotGetInputs,
     toJSON: machineSnapshotToJSON
   };
+  if (actorRef) {
+    setSnapshotActorRef(snapshot, actorRef);
+  }
+  return snapshot;
 }
 function cloneMachineSnapshot(snapshot, config = {}) {
   const configWithSnapshot = {
@@ -2159,7 +2579,7 @@ function cloneMachineSnapshot(snapshot, config = {}) {
     ...config
   };
   if ((config._nodes ?? snapshot._nodes) === snapshot._nodes) {
-    return {
+    const clonedSnapshot = {
       status: configWithSnapshot.status,
       output: configWithSnapshot.output,
       error: configWithSnapshot.error,
@@ -2169,8 +2589,10 @@ function cloneMachineSnapshot(snapshot, config = {}) {
       value: snapshot.value,
       tags: snapshot.tags,
       children: configWithSnapshot.children,
+      timers: configWithSnapshot.timers ?? {},
       historyValue: configWithSnapshot.historyValue || {},
       _stateInputs: configWithSnapshot._stateInputs || {},
+      _nextTimerId: configWithSnapshot._nextTimerId ?? 0,
       matches: machineSnapshotMatches,
       hasTag: machineSnapshotHasTag,
       can: machineSnapshotCan,
@@ -2178,11 +2600,15 @@ function cloneMachineSnapshot(snapshot, config = {}) {
       getInputs: machineSnapshotGetInputs,
       toJSON: machineSnapshotToJSON
     };
+    copySnapshotActorRef(snapshot, clonedSnapshot);
+    return clonedSnapshot;
   }
-  return createMachineSnapshot({
+  const clonedSnapshot = createMachineSnapshot({
     ...configWithSnapshot,
     value: undefined
   }, snapshot.machine);
+  copySnapshotActorRef(snapshot, clonedSnapshot);
+  return clonedSnapshot;
 }
 function serializeHistoryValue(historyValue) {
   const result = {};
@@ -2203,6 +2629,7 @@ function getPersistedSnapshot(snapshot, options) {
     tags,
     machine,
     children,
+    timers,
     context,
     can,
     hasTag,
@@ -2213,6 +2640,7 @@ function getPersistedSnapshot(snapshot, options) {
     ...jsonValues
   } = snapshot;
   const childrenJson = {};
+  const timersJson = {};
   for (const id in children) {
     const child = children[id];
     if (typeof child.src !== 'string' && (!options || !('__unsafeAllowInlineActors' in options))) {
@@ -2225,10 +2653,36 @@ function getPersistedSnapshot(snapshot, options) {
       syncSnapshot: child._syncSnapshot
     };
   }
+  for (const id in timers) {
+    const timer = timers[id];
+    let target;
+    if (timer.target === 'self') {
+      target = 'self';
+    } else {
+      const childId = Object.entries(children).find(([, child]) => child === timer.target)?.[0];
+      if (childId) {
+        target = childId;
+      } else if (timer.target === getSnapshotActorRef(snapshot)?.actor._parent) {
+        target = {
+          type: 'parent'
+        };
+      } else {
+        throw new Error(`Unable to persist timer '${id}': target actor '${timer.target.id}' is no longer addressable from this snapshot.`);
+      }
+    }
+    timersJson[id] = {
+      id: timer.id,
+      delay: timer.delay,
+      type: timer.type,
+      event: timer.event,
+      target
+    };
+  }
   const persisted = {
     ...jsonValues,
     context: persistContext(context),
     children: childrenJson,
+    timers: timersJson,
     historyValue: serializeHistoryValue(jsonValues.historyValue)
   };
   if (_stateInputs && Object.keys(_stateInputs).length > 0) {
@@ -2495,11 +2949,17 @@ function matchesEventDescriptor(eventType, descriptor) {
   return true;
 }
 
-function createScheduledEventId(actor, id) {
+/**
+ * Runtime operations used to execute effects.
+ *
+ * An external interpreter can override these operations while the default actor
+ * system provides the local in-memory implementation.
+ */
+
+function createScheduledTimerId(actor, id) {
   return `${actor.sessionId}.${id}`;
 }
 function createRuntimeSystem(rootActor, options) {
-  let idCounter = 0;
   const children = new Map();
   const keyedActors = new Map();
   const reverseKeyedActors = new WeakMap();
@@ -2527,42 +2987,50 @@ function createRuntimeSystem(rootActor, options) {
     });
   };
   const scheduler = {
-    schedule: (source, target, event, delay, id = Math.random().toString(36).slice(2)) => {
-      recordSent(source, target, event, delay, id);
-      const scheduledEvent = {
+    schedule: (source, id, delay) => {
+      const existingId = createScheduledTimerId(source, id);
+      if (timerMap[existingId] !== undefined) {
+        scheduler.cancel(source, id);
+      }
+      const timer = source.getSnapshot()?.timers?.[id];
+      if (timer) {
+        const target = timer.target === 'self' ? source : timer.target;
+        recordSent(source, target, timer.event, delay, id);
+      }
+      const scheduledAt = Date.now();
+      const scheduledTimer = {
         source,
-        target,
-        event,
         delay,
         id,
-        startedAt: Date.now()
+        scheduledAt,
+        dueAt: scheduledAt + delay
       };
-      const scheduledEventId = createScheduledEventId(source, id);
-      system._snapshot._scheduledEvents[scheduledEventId] = scheduledEvent;
+      const scheduledTimerId = createScheduledTimerId(source, id);
+      system._snapshot._scheduledTimers[scheduledTimerId] = scheduledTimer;
       const timeout = clock.setTimeout(() => {
-        delete timerMap[scheduledEventId];
-        delete system._snapshot._scheduledEvents[scheduledEventId];
-
-        // The send was already recorded at schedule time on the sender's
-        // transition, so deliver without re-recording.
-        deliver(source, target, event);
+        delete timerMap[scheduledTimerId];
+        delete system._snapshot._scheduledTimers[scheduledTimerId];
+        deliver(source, source, {
+          type: XSTATE_TIMER,
+          id
+        });
       }, delay);
-      timerMap[scheduledEventId] = timeout;
+      timerMap[scheduledTimerId] = timeout;
     },
     cancel: (source, id) => {
-      const scheduledEventId = createScheduledEventId(source, id);
-      const timeout = timerMap[scheduledEventId];
-      delete timerMap[scheduledEventId];
-      delete system._snapshot._scheduledEvents[scheduledEventId];
+      const scheduledTimerId = createScheduledTimerId(source, id);
+      const timeout = timerMap[scheduledTimerId];
+      delete timerMap[scheduledTimerId];
+      delete system._snapshot._scheduledTimers[scheduledTimerId];
       if (timeout !== undefined) {
         clock.clearTimeout(timeout);
       }
     },
     cancelAll: actor => {
-      for (const scheduledEventId in system._snapshot._scheduledEvents) {
-        const scheduledEvent = system._snapshot._scheduledEvents[scheduledEventId];
-        if (scheduledEvent.source === actor) {
-          scheduler.cancel(actor, scheduledEvent.id);
+      for (const scheduledTimerId in system._snapshot._scheduledTimers) {
+        const scheduledTimer = system._snapshot._scheduledTimers[scheduledTimerId];
+        if (scheduledTimer.source === actor) {
+          scheduler.cancel(actor, scheduledTimer.id);
         }
       }
     }
@@ -2595,9 +3063,10 @@ function createRuntimeSystem(rootActor, options) {
     reverseKeyedActors,
     keyedActors,
     _snapshot: {
-      _scheduledEvents: (options?.snapshot && options.snapshot.scheduler) ?? {}
+      _scheduledTimers: (options?.snapshot && options.snapshot.scheduler) ?? {},
+      _nextActorId: 0
     },
-    _bookId: () => `x:${idCounter++}`,
+    _bookId: () => `x:${system._snapshot._nextActorId++}`,
     _register: (sessionId, actor) => {
       children.set(sessionId, actor);
       return sessionId;
@@ -2606,7 +3075,9 @@ function createRuntimeSystem(rootActor, options) {
       children.delete(actor.sessionId);
       const registryKey = reverseKeyedActors.get(actor);
       if (registryKey !== undefined) {
-        keyedActors.delete(registryKey);
+        if (keyedActors.get(registryKey) === actor) {
+          keyedActors.delete(registryKey);
+        }
         reverseKeyedActors.delete(actor);
       }
     },
@@ -2634,35 +3105,48 @@ function createRuntimeSystem(rootActor, options) {
       };
     },
     _sendInspectionEvent: sendInspectionEvent,
-    _relay: (source, target, event) => {
+    createActorRef: options.createActorRef,
+    spawnActor: () => {},
+    startActor: actor => {
+      actor.start();
+    },
+    stopActor: actor => {
+      actor._stop();
+    },
+    terminateActor: (actor, termination) => {
+      actor._terminate(termination);
+    },
+    sendEvent: (source, target, event) => {
       recordSent(source, target, event);
       deliver(source, target, event);
     },
+    emitEvent: (source, event) => source._emit(event),
+    scheduleTimer: (source, id, delay) => scheduler.schedule(source, id, delay),
+    cancelTimer: (source, id) => scheduler.cancel(source, id),
+    cancelAllTimers: source => scheduler.cancelAll(source),
+    _relay: (source, target, event) => system.sendEvent(source, target, event),
     scheduler,
     getSnapshot: () => {
       return {
-        _scheduledEvents: {
-          ...system._snapshot._scheduledEvents
+        _scheduledTimers: {
+          ...system._snapshot._scheduledTimers
         }
       };
     },
     start: () => {
-      const scheduledEvents = system._snapshot._scheduledEvents;
-      system._snapshot._scheduledEvents = {};
-      for (const scheduledId in scheduledEvents) {
+      const scheduledTimers = system._snapshot._scheduledTimers;
+      system._snapshot._scheduledTimers = {};
+      for (const scheduledId in scheduledTimers) {
         const {
           source,
-          target,
-          event,
-          delay,
+          dueAt,
           id
-        } = scheduledEvents[scheduledId];
-        scheduler.schedule(source, target, event, delay, id);
+        } = scheduledTimers[scheduledId];
+        system.scheduleTimer(source, id, Math.max(0, dueAt - Date.now()));
       }
     },
     _clock: clock,
-    _logger: logger,
-    _timerStrategy: options.timers
+    _logger: logger
   };
   return system;
 }
@@ -2697,22 +3181,13 @@ function safeCall(fn, arg) {
     reportUnhandledError(err);
   }
 }
-function isExecutableActionObject(effect) {
-  return typeof effect === 'object' && effect !== null && 'args' in effect && 'exec' in effect;
-}
 function executeExecutableEffects(effects, actorScope) {
   if (!effects?.length) {
-    return [];
+    return;
   }
-  const logicEffects = [];
   for (const effect of effects) {
-    if (isExecutableActionObject(effect)) {
-      actorScope.actionExecutor(effect);
-    } else {
-      logicEffects.push(effect);
-    }
+    actorScope.actionExecutor(effect);
   }
-  return logicEffects;
 }
 
 /**
@@ -2778,8 +3253,7 @@ class Actor {
     this.src = void 0;
     // array of functions to defer
     this._deferred = [];
-    // pending effects (timers) from a persisted snapshot, rescheduled on `start()`
-    this._pendingEffects = void 0;
+    this._restored = false;
     const resolvedOptions = {
       ...defaultOptions,
       ...options
@@ -2796,7 +3270,7 @@ class Actor {
     this.system = parent ? parent.system : resolvedOptions._systemRef?.current ?? createRuntimeSystem(this, {
       clock,
       logger,
-      timers: resolvedOptions.timers
+      createActorRef: (childLogic, childOptions) => createActor(childLogic, childOptions)
     });
     if (!parent && resolvedOptions._systemRef && !resolvedOptions._systemRef.current) {
       resolvedOptions._systemRef.current = this.system;
@@ -2829,15 +3303,7 @@ class Actor {
         }
         child._stop();
       },
-      emit: emittedEvent => {
-        for (const listeners of [this.eventListeners.get(emittedEvent.type), this.eventListeners.get('*')]) {
-          if (listeners) {
-            for (const handler of listeners) {
-              safeCall(handler, emittedEvent);
-            }
-          }
-        }
-      },
+      emit: emittedEvent => this.system.emitEvent(this, emittedEvent),
       actionExecutor: action => {
         const exec = () => {
           // Record every executed action for the '@xstate.transition' inspection
@@ -2846,13 +3312,10 @@ class Actor {
             type: action.type,
             params: action.params
           });
-          if (!action.exec) {
-            return;
-          }
           const saveExecutingCustomAction = executingCustomAction;
           try {
             executingCustomAction = true;
-            action.exec();
+            void action.exec();
           } finally {
             executingCustomAction = saveExecutingCustomAction;
           }
@@ -2885,38 +3348,29 @@ class Actor {
 
     // prepare to collect initial microsteps during initialTransition
     this._collectedMicrosteps = [];
-    let persistedState = options?.snapshot ?? options?.state;
-    if (persistedState && typeof persistedState === 'object' && '_pendingEffects' in persistedState) {
-      // Pending effects are restored by this actor on `start()`; the logic
-      // only sees the rest of the persisted snapshot.
-      const {
-        _pendingEffects,
-        ...rest
-      } = persistedState;
-      this._pendingEffects = _pendingEffects;
-      persistedState = rest;
-    }
+    const persistedState = options?.snapshot ?? options?.state;
+    this._restored = persistedState !== undefined;
     try {
       if (persistedState) {
-        this._snapshot = this.logic.restoreSnapshot ? this.logic.restoreSnapshot(persistedState, this._actorScope) : persistedState;
+        this._setSnapshot(this.logic.restoreSnapshot ? this.logic.restoreSnapshot(persistedState, this._actorScope) : persistedState);
       } else if (options?._inert) {
         // Inert actors (createInertActorScope) only anchor a scope for pure
         // transition functions; computing an initial snapshot here would run
         // init-time side effects (context factories, entry) a second time.
       } else {
-        const [snapshot, effects] = this.logic.initialTransition(this.options?.input, this._actorScope);
-        this._snapshot = snapshot;
+        const [snapshot, effects] = finalizeTransitionResult(this._actorScope, undefined, this.logic.initialTransition(this.options?.input, this._actorScope));
+        this._setSnapshot(snapshot);
         this._initialEffects = effects;
       }
     } catch (err) {
       // if we get here then it means that we assign a value to this._snapshot that is not of the correct type
       // we can't get the true `TSnapshot & { status: 'error'; }`, it's impossible
       // so right now this is a lie of sorts
-      this._snapshot = {
+      this._setSnapshot({
         status: 'error',
         output: undefined,
         error: err
-      };
+      });
       // discard any functions deferred during the failed initial snapshot
       // computation so they can't run against an inconsistent actor
       this._deferred.length = 0;
@@ -2937,12 +3391,17 @@ class Actor {
       snapshot: this._snapshot
     });
   }
+  /** Associates each live snapshot with this actor for later pure transitions. */
+  _setSnapshot(snapshot) {
+    this._snapshot = snapshot;
+    setSnapshotActorRef(snapshot, this);
+  }
   _setErrorSnapshot(err, snapshot = this._snapshot) {
-    this._snapshot = {
+    this._setSnapshot({
       ...snapshot,
       status: 'error',
       error: err
-    };
+    });
   }
 
   /** Recover via the logic's error event if possible; otherwise error out. */
@@ -2960,11 +3419,10 @@ class Actor {
       return false;
     }
     try {
-      const [nextSnapshot, effects] = this.logic.transition(snapshot, errorEvent, this._actorScope);
-      this._snapshot = nextSnapshot;
-      const logicEffects = executeExecutableEffects(effects, this._actorScope);
+      const [nextSnapshot, effects] = finalizeTransitionResult(this._actorScope, snapshot, this.logic.transition(snapshot, errorEvent, this._actorScope));
+      this._setSnapshot(nextSnapshot);
+      executeExecutableEffects(effects, this._actorScope);
       this.update(nextSnapshot, errorEvent);
-      this.logic.executeEffects?.(logicEffects, this._actorScope);
       return true;
     } catch {
       return false;
@@ -2977,7 +3435,7 @@ class Actor {
   }
   update(snapshot, event) {
     // Update state
-    this._snapshot = snapshot;
+    this._setSnapshot(snapshot);
 
     // Execute deferred effects
     for (let i = 0; i < this._deferred.length; i++) {
@@ -2995,6 +3453,7 @@ class Actor {
           return;
         }
         this._setErrorSnapshot(err, snapshot);
+        this._error(err);
         break;
       }
     }
@@ -3003,26 +3462,6 @@ class Actor {
       case 'active':
         this._next(snapshot);
         break;
-      case 'done':
-        {
-          // next observers are meant to be notified about done snapshots
-          // this can be seen as something that is different from how observable work
-          // but with observables `complete` callback is called without any arguments
-          // it's more ergonomic for XState to treat a done snapshot as a "next" value
-          // and the completion event as something that is separate,
-          // something that merely follows emitting that done snapshot
-          this._next(snapshot);
-          this._stopProcedure();
-          this._complete();
-          const doneEvent = createDoneActorEvent(this.id, this._snapshot.output);
-          if (this._parent) {
-            this.system._relay(this, this._parent, doneEvent);
-          }
-          break;
-        }
-      case 'error':
-        this._error(this._snapshot.error);
-        break;
     }
     this.system._sendInspectionEvent({
       type: '@xstate.transition',
@@ -3047,8 +3486,7 @@ class Actor {
     }
     this._forceDeferredActions = true;
     try {
-      const logicEffects = executeExecutableEffects(this._initialEffects, this._actorScope);
-      this.logic.executeEffects?.(logicEffects, this._actorScope);
+      executeExecutableEffects(this._initialEffects, this._actorScope);
       this._initialEffects = undefined;
       return true;
     } catch (err) {
@@ -3219,6 +3657,14 @@ class Actor {
       case 'done':
         // a state machine can be "done" upon initialization (it could reach a final state using initial microsteps)
         // we still need to complete observers, flush deferreds etc
+        if (this._restored) {
+          // Restoration does not replay the transition that originally
+          // terminated the actor, and must not notify the parent again.
+          this._next(this._snapshot);
+          this._stopProcedure();
+          this._complete();
+          return this;
+        }
         if (!this._flushInitialEffects()) {
           return this;
         }
@@ -3232,33 +3678,31 @@ class Actor {
     if (!this._parent) {
       this.system.start();
     }
+    if (!this._flushInitialEffects()) {
+      return this;
+    }
     if (this.logic.start) {
       try {
-        this.logic.start(this._snapshot, this._actorScope);
+        this.logic.start(this._snapshot, this._actorScope, {
+          restored: this._restored
+        });
       } catch (err) {
         this._setErrorSnapshot(err);
         this._error(err);
         return this;
       }
     }
-    if (!this._flushInitialEffects()) {
-      return this;
-    }
 
     // TODO: this notifies all subscribers but usually this is redundant
     // there is no real change happening here
     // we need to rethink if this needs to be refactored
     this.update(this._snapshot, initEvent);
-    if (this._pendingEffects) {
-      const strategy = this.options.timers ?? this.system._timerStrategy ?? 'resume';
-      for (const effect of this._pendingEffects) {
-        // Re-execute the pending effect with its remaining delay. Only
-        // self-targeted raises exist today; other effect types are ignored.
-        if (effect.type === '@xstate.raise') {
-          this.system.scheduler.schedule(this, this, effect.event, resolveRestoredTimerDelay(strategy, effect), effect.id);
-        }
+    if (this._restored) {
+      const timers = this._snapshot.timers ?? {};
+      for (const timer of Object.values(timers)) {
+        this.system.scheduleTimer(this, timer.id, timer.delay);
       }
-      this._pendingEffects = undefined;
+      this._restored = false;
     }
     this.mailbox.start();
     return this;
@@ -3267,7 +3711,7 @@ class Actor {
     let nextState;
     let caughtError;
     try {
-      nextState = this.logic.transition(this._snapshot, event, this._actorScope);
+      nextState = finalizeTransitionResult(this._actorScope, this._snapshot, this.logic.transition(this._snapshot, event, this._actorScope));
     } catch (err) {
       // we wrap it in a box so we can rethrow it later even if falsy value gets caught here
       caughtError = {
@@ -3282,10 +3726,9 @@ class Actor {
     try {
       const [nextSnapshot, effects] = nextState;
       snapshot = nextSnapshot;
-      this._snapshot = snapshot;
-      const logicEffects = executeExecutableEffects(effects, this._actorScope);
+      this._setSnapshot(snapshot);
+      executeExecutableEffects(effects, this._actorScope);
       this.update(snapshot, event);
-      this.logic.executeEffects?.(logicEffects, this._actorScope);
     } catch (err) {
       this._recoverOrError(err, snapshot);
       return;
@@ -3296,6 +3739,35 @@ class Actor {
     }
   }
 
+  /** @internal */
+  _emit(event) {
+    for (const listeners of [this.eventListeners.get(event.type), this.eventListeners.get('*')]) {
+      if (listeners) {
+        for (const handler of listeners) {
+          safeCall(handler, event);
+        }
+      }
+    }
+  }
+
+  /** @internal */
+  _terminate(termination) {
+    if (termination.status === 'done') {
+      // The terminal snapshot is published before observer completion and the
+      // parent notification, matching actor lifecycle order.
+      this._next(this._snapshot);
+      this._stopProcedure();
+      this._complete();
+      if (this._parent) {
+        this.system._relay(this, this._parent, createDoneActorEvent(this.id, termination.output));
+      }
+      return;
+    }
+    if (termination.status === 'error') {
+      this._error(termination.error);
+    }
+  }
+
   /** @internal */
   _stop() {
     if (this._processingStatus === ProcessingStatus.Stopped) {
@@ -3304,6 +3776,7 @@ class Actor {
     this.mailbox.clear();
     if (this._processingStatus === ProcessingStatus.NotStarted) {
       this._processingStatus = ProcessingStatus.Stopped;
+      this.system._unregister(this);
       return this;
     }
     this.mailbox.enqueue({
@@ -3362,7 +3835,7 @@ class Actor {
     }
 
     // Cancel all delayed events
-    this.system.scheduler.cancelAll(this);
+    this.system.cancelAllTimers(this);
 
     // TODO: mailbox.reset
     this.mailbox.clear();
@@ -3423,35 +3896,7 @@ class Actor {
    */
 
   getPersistedSnapshot(options) {
-    const persisted = this.logic.getPersistedSnapshot(this._snapshot, options);
-
-    // Capture this actor's pending self-targeted effects (delayed
-    // events/transitions) as serialized action descriptors plus their
-    // runtime progress, so they can be restored on `start()`.
-    const scheduledEvents = this.system._snapshot._scheduledEvents;
-    let pendingEffects;
-    const now = Date.now();
-    for (const key in scheduledEvents) {
-      const scheduled = scheduledEvents[key];
-      if (scheduled.source === this && scheduled.target === this) {
-        (pendingEffects ??= []).push({
-          type: '@xstate.raise',
-          event: scheduled.event,
-          id: scheduled.id,
-          delay: scheduled.delay,
-          startedAt: scheduled.startedAt,
-          elapsed: Math.max(0, now - scheduled.startedAt)
-        });
-      }
-    }
-
-    // If this actor was restored but not yet started, its pending effects
-    // are not in the scheduler yet — carry them through as-is.
-    pendingEffects ??= this._pendingEffects;
-    return pendingEffects ? {
-      ...persisted,
-      _pendingEffects: pendingEffects
-    } : persisted;
+    return this.logic.getPersistedSnapshot(this._snapshot, options);
   }
   [symbolObservable]() {
     return this;
@@ -3478,20 +3923,6 @@ class Actor {
     return this._snapshot;
   }
 }
-function resolveRestoredTimerDelay(strategy, effect) {
-  if (typeof strategy === 'function') {
-    return strategy(effect);
-  }
-  switch (strategy) {
-    case 'restart':
-      return effect.delay;
-    case 'absolute':
-      return Math.max(0, effect.startedAt + effect.delay - Date.now());
-    case 'resume':
-    default:
-      return Math.max(0, effect.delay - effect.elapsed);
-  }
-}
 /**
  * Creates a new actor instance for the given actor logic with the provided
  * options, if any.
@@ -3547,63 +3978,27 @@ function getEffectState(self) {
   }
   return state;
 }
-function executeLogicEffects(effects, actorScope) {
-  if (!effects?.length) {
+function executeLogicEffect(self, key, effect) {
+  const state = getEffectState(self);
+  if (key !== undefined && state.has(key)) {
     return;
   }
-  for (const effect of effects) {
-    switch (effect.type) {
-      case 'emit':
-        actorScope.emit(effect.event);
-        break;
-      case 'sendBack':
-        {
-          const parent = actorScope.self._parent;
-          if (parent) {
-            actorScope.system._relay(actorScope.self, parent, effect.event);
-          }
-          break;
-        }
-      case 'raise':
-        actorScope.system._relay(actorScope.self, actorScope.self, effect.event);
-        break;
-      case 'effect':
-        {
-          if (!effect.key) {
-            const cleanup = effect.exec();
-            if (typeof cleanup === 'function') {
-              getEffectState(actorScope.self).set(Symbol(), {
-                cleanup
-              });
-            }
-            break;
-          }
-          const state = getEffectState(actorScope.self);
-          if (state.has(effect.key)) {
-            break;
-          }
-          const cleanup = effect.exec();
-          state.set(effect.key, {
-            cleanup: typeof cleanup === 'function' ? cleanup : undefined
-          });
-          break;
-        }
-      case 'cleanupEffects':
-        {
-          const state = effectStates.get(actorScope.self);
-          if (!state) {
-            break;
-          }
-          for (const {
-            cleanup
-          } of state.values()) {
-            cleanup?.();
-          }
-          effectStates.delete(actorScope.self);
-          break;
-        }
-    }
+  const cleanup = effect();
+  state.set(key ?? Symbol(), {
+    cleanup: typeof cleanup === 'function' ? cleanup : undefined
+  });
+}
+function cleanupLogicEffects(self) {
+  const state = effectStates.get(self);
+  if (!state) {
+    return;
+  }
+  for (const {
+    cleanup
+  } of state.values()) {
+    cleanup?.();
   }
+  effectStates.delete(self);
 }
 function resolveContext(context, input) {
   return typeof context === 'function' ? context({
@@ -3620,9 +4015,7 @@ function createLogic(config) {
         ...snapshot,
         status: 'stopped',
         input: undefined
-      }, [{
-        type: 'cleanupEffects'
-      }]];
+      }, [createCustomEffect('xstate.logic.cleanup', () => cleanupLogicEffects(actorScope.self))]];
     }
     if (event.type === XSTATE_LOGIC_EFFECT_START) {
       return [{
@@ -3665,43 +4058,33 @@ function createLogic(config) {
       if (snapshot.effects?.[key]) {
         return;
       }
-      effects.push({
-        type: 'effect',
-        key,
-        exec
-      });
+      effects.push(createCustomEffect('xstate.logic.effect', (runtime = actorScope.self.system) => executeLogicEffect(actorScope.self, key, () => exec(runtime)), {
+        key
+      }));
       trackedEffects[key] = {
         status: 'active'
       };
     };
     const enq = {
       emit: emitted => {
-        effects.push({
-          type: 'emit',
-          event: emitted
-        });
+        effects.push(createEmitEffect(actorScope, emitted));
       },
       sendBack: sentEvent => {
-        effects.push({
-          type: 'sendBack',
-          event: sentEvent
-        });
+        const parent = actorScope.self._parent;
+        if (parent) {
+          effects.push(createSendToEffect(actorScope, parent, sentEvent));
+        }
       },
       raise: raisedEvent => {
-        effects.push({
-          type: 'raise',
-          event: raisedEvent
-        });
+        effects.push(createSendToEffect(actorScope, actorScope.self, raisedEvent));
       },
       effect: (keyOrExec, maybeExec) => {
         if (typeof keyOrExec === 'string') {
           enqueueEffect(keyOrExec, maybeExec);
           return;
         }
-        effects.push({
-          type: 'effect',
-          exec: keyOrExec
-        });
+        const exec = keyOrExec;
+        effects.push(createCustomEffect('xstate.logic.effect', (runtime = actorScope.self.system) => executeLogicEffect(actorScope.self, undefined, () => exec(runtime))));
       }
     };
     const patch = config.run({
@@ -3726,18 +4109,23 @@ function createLogic(config) {
         ...trackedEffects
       };
     }
-    return [nextSnapshot, effects];
+    return finalizeTransitionResult(actorScope, snapshot, [nextSnapshot, effects]);
   };
   const logic = {
     id: config.id,
     config,
     transition,
-    start: (snapshot, actorScope) => {
+    start: (snapshot, actorScope, options) => {
+      if (!options?.restored) {
+        return;
+      }
       const [nextSnapshot, effects] = transition(snapshot, createInitEvent(snapshot.input), actorScope);
       Object.assign(snapshot, nextSnapshot);
-      executeLogicEffects(effects, actorScope);
+      for (const effect of effects) {
+        actorScope.actionExecutor(effect);
+      }
     },
-    initialTransition: (input, _) => {
+    initialTransition: (input, actorScope) => {
       const context = resolveContext(config.context, input);
       const snapshot = {
         status: 'active',
@@ -3748,14 +4136,13 @@ function createLogic(config) {
       if (context !== undefined) {
         snapshot.context = context;
       }
-      return [{
+      return transition({
         ...snapshot
-      }, []];
+      }, createInitEvent(input), actorScope);
     },
     getInitialSnapshot: (actorScope, input) => logic.initialTransition(input, actorScope)[0],
     getPersistedSnapshot: snapshot => snapshot,
-    restoreSnapshot: snapshot => snapshot,
-    executeEffects: executeLogicEffects
+    restoreSnapshot: snapshot => snapshot
   };
   return logic;
 }
@@ -4015,7 +4402,6 @@ function createObservableLogic(observableCreatorOrConfig) {
         self,
         system
       } = args;
-      const emit = args.emit;
       switch (event.type) {
         case XSTATE_OBSERVABLE_NEXT:
           {
@@ -4046,28 +4432,32 @@ function createObservableLogic(observableCreatorOrConfig) {
             }
           };
       }
-      enq.effect('observable', () => {
+      if (event.type !== XSTATE_INIT) {
+        return;
+      }
+      enq.effect((runtime = system) => {
         const actorSelf = self;
+        const sendSelf = event => void runtime.sendEvent(actorSelf, actorSelf, event);
         const subscription = observableCreator({
           input,
           system,
           self: self,
-          emit: emit
+          emit: event => void runtime.emitEvent(actorSelf, event)
         }).subscribe({
           next: value => {
-            system._relay(actorSelf, actorSelf, {
+            sendSelf({
               type: XSTATE_OBSERVABLE_NEXT,
               data: value
             });
           },
           error: err => {
-            system._relay(actorSelf, actorSelf, {
+            sendSelf({
               type: XSTATE_OBSERVABLE_ERROR,
               data: err
             });
           },
           complete: () => {
-            system._relay(actorSelf, actorSelf, {
+            sendSelf({
               type: XSTATE_OBSERVABLE_COMPLETE
             });
           }
@@ -4136,26 +4526,26 @@ function createEventObservableLogic(lazyObservableOrConfig) {
   // TODO: event types
   const logic = {
     config: lazyObservable,
-    transition: (state, event) => {
+    transition: (state, event, actorScope) => {
       if (state.status !== 'active') {
         return [state, []];
       }
       switch (event.type) {
         case XSTATE_OBSERVABLE_ERROR:
-          return [{
+          return finalizeTransitionResult(actorScope, state, [{
             ...state,
             status: 'error',
             error: event.data,
             input: undefined,
             _subscription: undefined
-          }, []];
+          }, []]);
         case XSTATE_OBSERVABLE_COMPLETE:
-          return [{
+          return finalizeTransitionResult(actorScope, state, [{
             ...state,
             status: 'done',
             input: undefined,
             _subscription: undefined
-          }, []];
+          }, []]);
         case XSTATE_STOP:
           state._subscription.unsubscribe();
           return [{
@@ -4190,7 +4580,9 @@ function createEventObservableLogic(lazyObservableOrConfig) {
         input: state.input,
         system,
         self,
-        emit
+        emit: event => {
+          void emit(event);
+        }
       }).subscribe({
         next: value => {
           if (self._parent) {
@@ -4391,8 +4783,9 @@ function createAsyncLogic(asyncLogic) {
       if (event.type !== XSTATE_INIT) {
         return;
       }
-      enq.effect(() => {
+      enq.effect((runtime = system) => {
         const actorSelf = self;
+        const sendSelf = event => void runtime.sendEvent(actorSelf, actorSelf, event);
         const controller = new AbortController();
         const timeout = config.timeout;
         const timeoutMs = parseDelayToMilliseconds(timeout);
@@ -4401,7 +4794,7 @@ function createAsyncLogic(asyncLogic) {
             return;
           }
           controller.abort();
-          system._relay(actorSelf, actorSelf, {
+          sendSelf({
             type: XSTATE_ASYNC_REJECT,
             data: new TimeoutError(timeout)
           });
@@ -4417,7 +4810,7 @@ function createAsyncLogic(asyncLogic) {
           self: self,
           signal: controller.signal
         }, {
-          emit: enq.emit,
+          emit: event => void runtime.emitEvent(actorSelf, event),
           step: async (key, exec) => {
             const effect = self.getSnapshot().effects?.[key];
             if (effect?.status === 'done') {
@@ -4429,20 +4822,20 @@ function createAsyncLogic(asyncLogic) {
             if (effect?.status === 'active') {
               return waitForEffect(self, key);
             }
-            system._relay(actorSelf, actorSelf, {
+            sendSelf({
               type: XSTATE_LOGIC_EFFECT_START,
               key
             });
             try {
               const output = await exec();
-              system._relay(actorSelf, actorSelf, {
+              sendSelf({
                 type: XSTATE_LOGIC_EFFECT_RESOLVE,
                 key,
                 output
               });
               return output;
             } catch (error) {
-              system._relay(actorSelf, actorSelf, {
+              sendSelf({
                 type: XSTATE_LOGIC_EFFECT_REJECT,
                 key,
                 error
@@ -4456,7 +4849,7 @@ function createAsyncLogic(asyncLogic) {
           if (self.getSnapshot().status !== 'active') {
             return;
           }
-          system._relay(actorSelf, actorSelf, {
+          sendSelf({
             type: XSTATE_ASYNC_RESOLVE,
             data: response
           });
@@ -4465,7 +4858,7 @@ function createAsyncLogic(asyncLogic) {
           if (self.getSnapshot().status !== 'active') {
             return;
           }
-          system._relay(actorSelf, actorSelf, {
+          sendSelf({
             type: XSTATE_ASYNC_REJECT,
             data: errorData
           });
@@ -4497,11 +4890,11 @@ function createEmptyActor() {
 exports.$$ACTOR_TYPE = $$ACTOR_TYPE;
 exports.Actor = Actor;
 exports.NULL_EVENT = NULL_EVENT;
-exports.ProcessingStatus = ProcessingStatus;
 exports.STATE_DELIMITER = STATE_DELIMITER;
 exports.TimeoutError = TimeoutError;
 exports.XSTATE_INIT = XSTATE_INIT;
 exports.XSTATE_STOP = XSTATE_STOP;
+exports.XSTATE_TIMER = XSTATE_TIMER;
 exports.builtInActions = builtInActions;
 exports.checkStateIn = checkStateIn;
 exports.cloneMachineSnapshot = cloneMachineSnapshot;
@@ -4518,10 +4911,15 @@ exports.createListenerLogic = createListenerLogic;
 exports.createLogic = createLogic;
 exports.createMachineSnapshot = createMachineSnapshot;
 exports.createObservableLogic = createObservableLogic;
+exports.createSendToEffect = createSendToEffect;
+exports.createSnapshotSystem = createSnapshotSystem;
+exports.createSpawnEffect = createSpawnEffect;
 exports.createSubscriptionLogic = createSubscriptionLogic;
 exports.createTransitionEnqueue = createTransitionEnqueue;
 exports.deriveDeferredStarts = deriveDeferredStarts;
 exports.evaluateCandidate = evaluateCandidate;
+exports.executeEffects = executeEffects;
+exports.finalizeTransitionResult = finalizeTransitionResult;
 exports.formatRouteTransitions = formatRouteTransitions;
 exports.formatTransition = formatTransition;
 exports.getAllOwnEventDescriptors = getAllOwnEventDescriptors;
@@ -4530,6 +4928,7 @@ exports.getCandidates = getCandidates;
 exports.getDelayedTransitions = getDelayedTransitions;
 exports.getPersistedSnapshot = getPersistedSnapshot;
 exports.getProperAncestors = getProperAncestors;
+exports.getSnapshotActorRef = getSnapshotActorRef;
 exports.getStateNodeByPath = getStateNodeByPath;
 exports.getStateNodes = getStateNodes;
 exports.getTransitionResult = getTransitionResult;
@@ -4550,6 +4949,7 @@ exports.pathToStateValue = pathToStateValue;
 exports.resolveActionsWithContext = resolveActionsWithContext;
 exports.resolveReferencedActor = resolveReferencedActor;
 exports.resolveStateValue = resolveStateValue;
+exports.setSnapshotActorRef = setSnapshotActorRef;
 exports.subscriptionLogic = subscriptionLogic;
 exports.toArray = toArray;
 exports.toObserver = toObserver;