xstate 6.0.0-alpha.2 → 6.0.0-alpha.21

package/dist/{index-e61170ba.development.esm.js → index-d39fb138.development.esm.js}

@@ -1,16 +1,3 @@
-/**
- * Reactivity interop between actors and atoms.
- *
- * `Actor#get()` calls this hook (when installed) so that computed atoms can
- * track actor reads as dependencies. The hook is installed by `atom.ts` on
- * module evaluation, which only happens when atoms are actually used — apps
- * that never import atoms don't bundle the reactive system.
- */
-let onActorRead;
-function installActorReadHook(hook) {
-  onActorRead = hook;
-}
-
 class Mailbox {
   constructor(_process) {
     this._process = _process;
@@ -64,6 +51,8 @@ const NULL_EVENT = '';
 const STATE_IDENTIFIER = '#';
 const WILDCARD = '*';
 const XSTATE_INIT = '@xstate.init';
+const XSTATE_START = '@xstate.start';
+const XSTATE_SPAWN = '@xstate.spawn';
 const XSTATE_STOP = '@xstate.stop';
 
 /**
@@ -140,6 +129,12 @@ function createErrorActorEvent(id, error) {
     actorId: id
   };
 }
+function createErrorPlatformEvent(kind, error) {
+  return {
+    type: `xstate.error.${kind}`,
+    error
+  };
+}
 function createInitEvent(input) {
   return {
     type: XSTATE_INIT,
@@ -164,6 +159,9 @@ function reportUnhandledError(err) {
 const symbolObservable = (() => typeof Symbol === 'function' && Symbol.observable || '@@observable')();
 
 const builtInActions = {
+  // No-op: creation/registration are eager and pure; the start is a separate
+  // deferred `@xstate.start` effect (see `deriveDeferredStarts`).
+  ['@xstate.spawn']: _actor => {},
   ['@xstate.start']: actor => {
     actor.start();
   },
@@ -186,7 +184,7 @@ const builtInActions = {
   ['@xstate.cancel']: (actorScope, sendId) => {
     actorScope.system.scheduler.cancel(actorScope.self, sendId);
   },
-  ['@xstate.stopChild']: (actorScope, actor) => {
+  ['@xstate.stop']: (actorScope, actor) => {
     actorScope.stopChild(actor);
   }
 };
@@ -198,15 +196,20 @@ const subscriptions = /* #__PURE__ */new WeakMap();
  * (`enq.listen()` / `enq.subscribeTo()`) and detaches when stopped.
  */
 function createAttachedLogic(attach) {
+  const initialTransition = (input, _) => [{
+    status: 'active',
+    output: undefined,
+    error: undefined,
+    input
+  }, []];
   return {
     start: (state, {
       self,
       system
     }) => {
-      // Don't attach if the target doesn't exist, or (for actors) is stopped.
-      // Atoms have no `getSnapshot` / lifecycle, so they always attach.
+      // Don't attach if the target doesn't exist or is stopped.
       const target = state.input.actor;
-      if (!target || typeof target.getSnapshot === 'function' && target.getSnapshot().status === 'stopped') {
+      if (!target || target.getSnapshot().status === 'stopped') {
         return;
       }
       const subscription = attach(state.input, {
@@ -249,20 +252,16 @@ function createAttachedLogic(attach) {
       if (event.type === XSTATE_STOP) {
         subscriptions.get(self)?.unsubscribe();
         subscriptions.delete(self);
-        return {
+        return [{
           ...state,
           status: 'stopped',
           error: undefined
-        };
+        }, []];
       }
-      return state;
+      return [state, []];
     },
-    getInitialSnapshot: (_, input) => ({
-      status: 'active',
-      output: undefined,
-      error: undefined,
-      input
-    }),
+    initialTransition,
+    getInitialSnapshot: (actorScope, input) => initialTransition(input)[0],
     getPersistedSnapshot: snapshot => snapshot,
     restoreSnapshot: snapshot => snapshot
   };
@@ -308,620 +307,6 @@ function createListenerLogic() {
 // Singleton logic instance
 const listenerLogic = /* #__PURE__ */createListenerLogic();
 
-/* eslint-disable */
-// Adapted from Alien Signals
-// https://github.com/stackblitz/alien-signals/
-
-let ReactiveFlags = /*#__PURE__*/function (ReactiveFlags) {
-  ReactiveFlags[ReactiveFlags["None"] = 0] = "None";
-  ReactiveFlags[ReactiveFlags["Mutable"] = 1] = "Mutable";
-  ReactiveFlags[ReactiveFlags["Watching"] = 2] = "Watching";
-  ReactiveFlags[ReactiveFlags["RecursedCheck"] = 4] = "RecursedCheck";
-  ReactiveFlags[ReactiveFlags["Recursed"] = 8] = "Recursed";
-  ReactiveFlags[ReactiveFlags["Dirty"] = 16] = "Dirty";
-  ReactiveFlags[ReactiveFlags["Pending"] = 32] = "Pending";
-  return ReactiveFlags;
-}({});
-function createReactiveSystem({
-  update,
-  notify,
-  unwatched
-}) {
-  return {
-    link,
-    unlink,
-    propagate,
-    checkDirty,
-    shallowPropagate
-  };
-  function link(dep, sub, version) {
-    const prevDep = sub.depsTail;
-    if (prevDep !== undefined && prevDep.dep === dep) {
-      return;
-    }
-    const nextDep = prevDep !== undefined ? prevDep.nextDep : sub.deps;
-    if (nextDep !== undefined && nextDep.dep === dep) {
-      nextDep.version = version;
-      sub.depsTail = nextDep;
-      return;
-    }
-    const prevSub = dep.subsTail;
-    if (prevSub !== undefined && prevSub.version === version && prevSub.sub === sub) {
-      return;
-    }
-    const newLink = sub.depsTail = dep.subsTail = {
-      version,
-      dep,
-      sub,
-      prevDep,
-      nextDep,
-      prevSub,
-      nextSub: undefined
-    };
-    if (nextDep !== undefined) {
-      nextDep.prevDep = newLink;
-    }
-    if (prevDep !== undefined) {
-      prevDep.nextDep = newLink;
-    } else {
-      sub.deps = newLink;
-    }
-    if (prevSub !== undefined) {
-      prevSub.nextSub = newLink;
-    } else {
-      dep.subs = newLink;
-    }
-  }
-  function unlink(link, sub = link.sub) {
-    const dep = link.dep;
-    const prevDep = link.prevDep;
-    const nextDep = link.nextDep;
-    const nextSub = link.nextSub;
-    const prevSub = link.prevSub;
-    if (nextDep !== undefined) {
-      nextDep.prevDep = prevDep;
-    } else {
-      sub.depsTail = prevDep;
-    }
-    if (prevDep !== undefined) {
-      prevDep.nextDep = nextDep;
-    } else {
-      sub.deps = nextDep;
-    }
-    if (nextSub !== undefined) {
-      nextSub.prevSub = prevSub;
-    } else {
-      dep.subsTail = prevSub;
-    }
-    if (prevSub !== undefined) {
-      prevSub.nextSub = nextSub;
-    } else if ((dep.subs = nextSub) === undefined) {
-      unwatched(dep);
-    }
-    return nextDep;
-  }
-  function propagate(link) {
-    let next = link.nextSub;
-    let stack;
-    top: do {
-      const sub = link.sub;
-      let flags = sub.flags;
-      if (!(flags & (ReactiveFlags.RecursedCheck | ReactiveFlags.Recursed | ReactiveFlags.Dirty | ReactiveFlags.Pending))) {
-        sub.flags = flags | ReactiveFlags.Pending;
-      } else if (!(flags & (ReactiveFlags.RecursedCheck | ReactiveFlags.Recursed))) {
-        flags = ReactiveFlags.None;
-      } else if (!(flags & ReactiveFlags.RecursedCheck)) {
-        sub.flags = flags & ~ReactiveFlags.Recursed | ReactiveFlags.Pending;
-      } else if (!(flags & (ReactiveFlags.Dirty | ReactiveFlags.Pending)) && isValidLink(link, sub)) {
-        sub.flags = flags | (ReactiveFlags.Recursed | ReactiveFlags.Pending);
-        flags &= ReactiveFlags.Mutable;
-      } else {
-        flags = ReactiveFlags.None;
-      }
-      if (flags & ReactiveFlags.Watching) {
-        notify(sub);
-      }
-      if (flags & ReactiveFlags.Mutable) {
-        const subSubs = sub.subs;
-        if (subSubs !== undefined) {
-          const nextSub = (link = subSubs).nextSub;
-          if (nextSub !== undefined) {
-            stack = {
-              value: next,
-              prev: stack
-            };
-            next = nextSub;
-          }
-          continue;
-        }
-      }
-      if ((link = next) !== undefined) {
-        next = link.nextSub;
-        continue;
-      }
-      while (stack !== undefined) {
-        link = stack.value;
-        stack = stack.prev;
-        if (link !== undefined) {
-          next = link.nextSub;
-          continue top;
-        }
-      }
-      break;
-    } while (true);
-  }
-  function checkDirty(link, sub) {
-    let stack;
-    let checkDepth = 0;
-    let dirty = false;
-    top: do {
-      const dep = link.dep;
-      const flags = dep.flags;
-      if (sub.flags & ReactiveFlags.Dirty) {
-        dirty = true;
-      } else if ((flags & (ReactiveFlags.Mutable | ReactiveFlags.Dirty)) === (ReactiveFlags.Mutable | ReactiveFlags.Dirty)) {
-        if (update(dep)) {
-          const subs = dep.subs;
-          if (subs.nextSub !== undefined) {
-            shallowPropagate(subs);
-          }
-          dirty = true;
-        }
-      } else if ((flags & (ReactiveFlags.Mutable | ReactiveFlags.Pending)) === (ReactiveFlags.Mutable | ReactiveFlags.Pending)) {
-        if (link.nextSub !== undefined || link.prevSub !== undefined) {
-          stack = {
-            value: link,
-            prev: stack
-          };
-        }
-        link = dep.deps;
-        sub = dep;
-        ++checkDepth;
-        continue;
-      }
-      if (!dirty) {
-        const nextDep = link.nextDep;
-        if (nextDep !== undefined) {
-          link = nextDep;
-          continue;
-        }
-      }
-      while (checkDepth--) {
-        const firstSub = sub.subs;
-        const hasMultipleSubs = firstSub.nextSub !== undefined;
-        if (hasMultipleSubs) {
-          link = stack.value;
-          stack = stack.prev;
-        } else {
-          link = firstSub;
-        }
-        if (dirty) {
-          if (update(sub)) {
-            if (hasMultipleSubs) {
-              shallowPropagate(firstSub);
-            }
-            sub = link.sub;
-            continue;
-          }
-          dirty = false;
-        } else {
-          sub.flags &= ~ReactiveFlags.Pending;
-        }
-        sub = link.sub;
-        const nextDep = link.nextDep;
-        if (nextDep !== undefined) {
-          link = nextDep;
-          continue top;
-        }
-      }
-      return dirty;
-    } while (true);
-  }
-  function shallowPropagate(link) {
-    do {
-      const sub = link.sub;
-      const flags = sub.flags;
-      if ((flags & (ReactiveFlags.Pending | ReactiveFlags.Dirty)) === ReactiveFlags.Pending) {
-        sub.flags = flags | ReactiveFlags.Dirty;
-        if ((flags & (ReactiveFlags.Watching | ReactiveFlags.RecursedCheck)) === ReactiveFlags.Watching) {
-          notify(sub);
-        }
-      }
-    } while ((link = link.nextSub) !== undefined);
-  }
-  function isValidLink(checkLink, sub) {
-    let link = sub.depsTail;
-    while (link !== undefined) {
-      if (link === checkLink) {
-        return true;
-      }
-      link = link.prevDep;
-    }
-    return false;
-  }
-}
-
-/**
- * Nominal brand (phantom, compile-time only) marking a value as an XState atom.
- * Real atoms get the runtime brand ({@link $$atom}) in `createAtom`; this type
- * brand keeps atom-only APIs (e.g. `enq.subscribeTo`) from structurally
- * accepting plain readables like `actor.select(...)` that would be dispatched
- * down the non-atom path at runtime.
- */
-
-/** Brand marking an object as an atom, so it can be detected structurally. */
-const $$atom = /* #__PURE__ */Symbol.for('xstate.atom');
-
-/**
- * Returns `true` if the value is an atom (writable, computed, async, or
- * reducer). Lets actor-consuming APIs (e.g. `enq.subscribeTo`) accept atoms
- * directly.
- */
-function isAtom(value) {
-  return !!value && typeof value === 'object' && $$atom in value;
-}
-const queuedEffects = [];
-let cycle = 0;
-// Initialized lazily on first atom creation (instead of at module evaluation)
-// so the reactive system stays tree-shakeable for apps that never use atoms —
-
-// would be retained by consumer bundlers even when atoms are unused.
-let link;
-let unlink;
-let propagate;
-let checkDirty;
-let shallowPropagate;
-let reactiveSystemInstalled = false;
-function ensureReactiveSystem() {
-  if (reactiveSystemInstalled) {
-    return;
-  }
-  reactiveSystemInstalled = true;
-  ({
-    link,
-    unlink,
-    propagate,
-    checkDirty,
-    shallowPropagate
-  } = createReactiveSystem({
-    update(atom) {
-      return atom._update();
-    },
-    notify(effect) {
-      queuedEffects[queuedEffectsLength++] = effect;
-      effect.flags &= ~ReactiveFlags.Watching;
-    },
-    unwatched(atom) {
-      if (atom.depsTail !== undefined) {
-        atom.depsTail = undefined;
-        atom.flags = ReactiveFlags.Mutable | ReactiveFlags.Dirty;
-        purgeDeps(atom);
-      }
-    }
-  }));
-}
-let notifyIndex = 0;
-let queuedEffectsLength = 0;
-let activeSub;
-function purgeDeps(sub) {
-  const depsTail = sub.depsTail;
-  let dep = depsTail !== undefined ? depsTail.nextDep : sub.deps;
-  while (dep !== undefined) {
-    dep = unlink(dep, sub);
-  }
-}
-function flush() {
-  while (notifyIndex < queuedEffectsLength) {
-    const effect = queuedEffects[notifyIndex];
-    queuedEffects[notifyIndex++] = undefined;
-    effect.notify();
-  }
-  notifyIndex = 0;
-  queuedEffectsLength = 0;
-}
-
-/** The current state of an async atom. */
-
-/** Options passed to an async atom getter. */
-
-function compareAsyncAtomState(a, b) {
-  if (a.status !== b.status) {
-    return false;
-  }
-  if (a.status === 'done' && b.status === 'done') {
-    return Object.is(a.data, b.data);
-  }
-  if (a.status === 'error' && b.status === 'error') {
-    return Object.is(a.error, b.error);
-  }
-  // both 'pending'
-  return true;
-}
-function updateAsyncAtom(atom, nextValue) {
-  if (atom._update(nextValue)) {
-    const subs = atom.subs;
-    if (subs !== undefined) {
-      propagate(subs);
-      shallowPropagate(subs);
-      flush();
-    }
-  }
-}
-
-/**
- * Creates a read-only atom whose value is loaded from an async getter.
- *
- * The getter receives an `AbortSignal`; when the async atom recomputes, the
- * previous signal is aborted and stale resolutions are ignored.
- */
-function createAsyncAtom(getValue, options) {
-  const ref = {};
-  let currentController;
-  let currentRunId = 0;
-  const atom = createAtom(() => {
-    currentController?.abort();
-    const controller = new AbortController();
-    const runId = ++currentRunId;
-    currentController = controller;
-    getValue({
-      signal: controller.signal
-    }).then(data => {
-      if (runId !== currentRunId || controller.signal.aborted) {
-        return;
-      }
-      updateAsyncAtom(ref.current, {
-        status: 'done',
-        data
-      });
-    }, error => {
-      if (runId !== currentRunId || controller.signal.aborted) {
-        return;
-      }
-      updateAsyncAtom(ref.current, {
-        status: 'error',
-        error
-      });
-    });
-    return {
-      status: 'pending'
-    };
-  }, {
-    compare: compareAsyncAtomState,
-    ...options
-  });
-  ref.current = atom;
-  return atom;
-}
-
-/**
- * Mirror atoms that bump a version whenever a tracked actor emits a snapshot,
- * letting computed atoms depend on `actor.get()` reads.
- *
- * The hook is installed lazily on first atom creation (not at module
- * evaluation) so that it remains tree-shakeable for apps that never use atoms —
- * any tracked read necessarily happens inside an atom computation, so first-use
- * installation is always early enough.
- */
-let actorInteropInstalled = false;
-function ensureActorInterop() {
-  if (actorInteropInstalled) {
-    return;
-  }
-  actorInteropInstalled = true;
-  const actorVersions = new WeakMap();
-  installActorReadHook(actorRef => {
-    if (activeSub === undefined) {
-      return;
-    }
-    let version = actorVersions.get(actorRef);
-    if (version === undefined) {
-      version = createAtom(0);
-      actorVersions.set(actorRef, version);
-      actorRef.subscribe({
-        next: () => version.set(v => v + 1),
-        error: () => {}
-      });
-    }
-    version.get();
-  });
-}
-
-/**
- * Creates an atom.
- *
- * Pass a value for a writable atom or a getter for a computed read-only atom.
- */
-
-function createAtom(valueOrFn, optionsOrInput) {
-  ensureReactiveSystem();
-  ensureActorInterop();
-  const isComputed = typeof valueOrFn === 'function';
-  const getter = valueOrFn;
-
-  // Create plain object atom
-  const atom = {
-    _snapshot: isComputed ? undefined : valueOrFn,
-    subs: undefined,
-    subsTail: undefined,
-    deps: undefined,
-    depsTail: undefined,
-    flags: isComputed ? ReactiveFlags.None : ReactiveFlags.Mutable,
-    get() {
-      if (activeSub !== undefined) {
-        link(atom, activeSub, cycle);
-      }
-      return atom._snapshot;
-    },
-    subscribe(observerOrFn) {
-      const observer = typeof observerOrFn === 'function' ? {
-        next: observerOrFn
-      } : observerOrFn;
-      const observed = {
-        current: false
-      };
-      const e = effect(() => {
-        atom.get();
-        if (!observed.current) {
-          observed.current = true;
-        } else {
-          const prevSub = activeSub;
-          activeSub = undefined;
-          try {
-            observer.next?.(atom._snapshot);
-          } catch (err) {
-            reportUnhandledError(err);
-          } finally {
-            activeSub = prevSub;
-          }
-
-          // If the observer synchronously updates any of our deps we'll be
-          // marked as dirty preventing this effect from re-running. Request
-          // the value again to reconcile any dirty deps.
-          atom.get();
-        }
-      });
-      return {
-        unsubscribe: () => {
-          e.stop();
-        }
-      };
-    },
-    _update(getValue) {
-      const prevSub = activeSub;
-      const compare = optionsOrInput?.compare ?? Object.is;
-      activeSub = atom;
-      ++cycle;
-      atom.depsTail = undefined;
-      if (isComputed) {
-        atom.flags = ReactiveFlags.Mutable | ReactiveFlags.RecursedCheck;
-      }
-      try {
-        const oldValue = atom._snapshot;
-        const newValue = typeof getValue === 'function' ? getValue(oldValue) : getValue === undefined && isComputed ? getter(oldValue) : getValue;
-        if (oldValue === undefined || !compare(oldValue, newValue)) {
-          atom._snapshot = newValue;
-          return true;
-        }
-        return false;
-      } finally {
-        activeSub = prevSub;
-        if (isComputed) {
-          atom.flags &= ~ReactiveFlags.RecursedCheck;
-        }
-        purgeDeps(atom);
-      }
-    }
-  };
-  if (isComputed) {
-    atom.flags = ReactiveFlags.Mutable | ReactiveFlags.Dirty;
-    atom.get = function () {
-      const flags = atom.flags;
-      if (flags & ReactiveFlags.Dirty || flags & ReactiveFlags.Pending && checkDirty(atom.deps, atom)) {
-        if (atom._update()) {
-          const subs = atom.subs;
-          if (subs !== undefined) {
-            shallowPropagate(subs);
-          }
-        }
-      } else if (flags & ReactiveFlags.Pending) {
-        atom.flags = flags & ~ReactiveFlags.Pending;
-      }
-      if (activeSub !== undefined) {
-        link(atom, activeSub, cycle);
-      }
-      return atom._snapshot;
-    };
-  } else {
-    atom.set = function (valueOrFn) {
-      if (atom._update(valueOrFn)) {
-        const subs = atom.subs;
-        if (subs !== undefined) {
-          propagate(subs);
-          shallowPropagate(subs);
-          flush();
-        }
-      }
-    };
-  }
-  atom[$$atom] = true;
-  return atom;
-}
-
-/**
- * Creates an inert atom config that can be instantiated later.
- *
- * Useful for framework hooks that need to create a stable local atom from
- * component input.
- */
-
-function createAtomConfig(initialValueOrFn, options) {
-  return {
-    createAtom(input) {
-      const initialValue = typeof initialValueOrFn === 'function' ? initialValueOrFn(input) : initialValueOrFn;
-      return createAtom(initialValue, options);
-    }
-  };
-}
-
-/** Creates an atom whose updates are handled by a reducer function. */
-function createReducerAtom(initialValue, reducer, options) {
-  const atom = createAtom(initialValue, options);
-  return {
-    [$$atom]: true,
-    get: atom.get.bind(atom),
-    subscribe: atom.subscribe.bind(atom),
-    send(event) {
-      const prevSub = activeSub;
-      activeSub = undefined;
-      let nextState;
-      try {
-        nextState = reducer(atom.get(), event);
-      } finally {
-        activeSub = prevSub;
-      }
-      atom.set(nextState);
-    }
-  };
-}
-function effect(fn) {
-  const run = () => {
-    const prevSub = activeSub;
-    activeSub = effectObj;
-    ++cycle;
-    effectObj.depsTail = undefined;
-    effectObj.flags = ReactiveFlags.Watching | ReactiveFlags.RecursedCheck;
-    try {
-      return fn();
-    } finally {
-      activeSub = prevSub;
-      effectObj.flags &= ~ReactiveFlags.RecursedCheck;
-      purgeDeps(effectObj);
-    }
-  };
-  const effectObj = {
-    deps: undefined,
-    depsTail: undefined,
-    subs: undefined,
-    subsTail: undefined,
-    flags: ReactiveFlags.Watching | ReactiveFlags.RecursedCheck,
-    notify() {
-      const flags = this.flags;
-      if (flags & ReactiveFlags.Dirty || flags & ReactiveFlags.Pending && checkDirty(this.deps, this)) {
-        run();
-      } else {
-        this.flags = ReactiveFlags.Watching;
-      }
-    },
-    stop() {
-      this.flags = ReactiveFlags.None;
-      this.depsTail = undefined;
-      purgeDeps(this);
-    }
-  };
-  run();
-  return effectObj;
-}
-
 /**
  * Creates actor logic for subscribing to lifecycle events (done/error/snapshot)
  * from another actor. Used internally by `enq.subscribeTo()`.
@@ -939,15 +324,6 @@ function createSubscriptionLogic() {
       error,
       snapshot: onSnapshot
     } = mappers;
-
-    // Atoms emit a raw value (no `status`) and have no done/error lifecycle —
-    // pass the value straight to the `snapshot` mapper.
-    if (isAtom(actor)) {
-      if (!onSnapshot) {
-        return;
-      }
-      return actor.subscribe(value => relayMappedToParent(self, system, () => onSnapshot(value)));
-    }
     return actor.subscribe({
       next: snapshot => {
         if (snapshot.status === 'done' && done) {
@@ -973,6 +349,19 @@ 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 mergeContextPatch(context, patch) {
+  return {
+    ...context,
+    ...patch
+  };
+}
 function pushBuiltInAction(actions, action, ...args) {
   actions.push({
     action,
@@ -1008,11 +397,11 @@ function unregisterChild(actor) {
     _special: true
   });
 }
-function pushStartedChild(actions, actor, id) {
-  pushBuiltInAction(actions, builtInActions['@xstate.start'], actor);
+function pushSpawnedChild(actions, actor, id) {
+  pushBuiltInAction(actions, builtInActions['@xstate.spawn'], actor);
   actions.push(registerSpawnedChild(actor, id ?? actor.id));
 }
-function createTransitionEnqueue(actorScope, actions, internalEvents, actorSubscriptions = false) {
+function createTransitionEnqueue(actorScope, actions, internalEvents, actorSubscriptions = false, createActors = true) {
   const props = {
     cancel: id => {
       pushBuiltInAction(actions, builtInActions['@xstate.cancel'], actorScope, id);
@@ -1034,21 +423,32 @@ function createTransitionEnqueue(actorScope, actions, internalEvents, actorSubsc
       }
     },
     spawn: (logic, options) => {
+      if (!createActors) {
+        // TODO: replace this speculative placeholder with a typed inert actor ref.
+        return {
+          id: options?.id ?? options?.registryKey ?? logic.id
+        };
+      }
       const actor = createActor(logic, {
         ...options,
         parent: actorScope.self
       });
-      pushStartedChild(actions, actor, options?.id);
+      pushSpawnedChild(actions, actor, options?.id);
       return actor;
     },
     sendTo: (actor, event, options) => {
-      if (actor) {
-        pushBuiltInAction(actions, builtInActions['@xstate.sendTo'], actorScope, actor, event, options);
+      if (!actor) {
+        internalEvents.push(createErrorPlatformEvent('communication', {
+          message: 'Unable to send event to an undefined actor',
+          event
+        }));
+        return;
       }
+      pushBuiltInAction(actions, builtInActions['@xstate.sendTo'], actorScope, actor, event, options);
     },
     stop: actor => {
       if (actor) {
-        pushBuiltInAction(actions, builtInActions['@xstate.stopChild'], actorScope, actor);
+        pushBuiltInAction(actions, builtInActions['@xstate.stop'], actorScope, actor);
         actions.push(unregisterChild(actor));
       }
     }
@@ -1065,7 +465,7 @@ function createTransitionEnqueue(actorScope, actions, internalEvents, actorSubsc
           input,
           parent: actorScope.self
         });
-        pushBuiltInAction(actions, builtInActions['@xstate.start'], listenerActor);
+        pushBuiltInAction(actions, builtInActions['@xstate.spawn'], listenerActor);
         return listenerActor;
       },
       subscribeTo: (actor, mappers) => {
@@ -1080,77 +480,175 @@ function createTransitionEnqueue(actorScope, actions, internalEvents, actorSubsc
           input,
           parent: actorScope.self
         });
-        pushBuiltInAction(actions, builtInActions['@xstate.start'], subscriptionActor);
+        pushBuiltInAction(actions, builtInActions['@xstate.spawn'], subscriptionActor);
         return subscriptionActor;
       }
     });
   }
-  return createEnqueueObject$1(props, (action, ...args) => {
+  return createEnqueueObject(props, (action, ...args) => {
     pushBuiltInAction(actions, action, ...args);
   });
 }
-function resolveAndExecuteActionsWithContext(currentSnapshot, event, actorScope, actions) {
-  let intermediateSnapshot = currentSnapshot;
-  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;
-    if (!resolvedAction && typeof action === 'object' && action !== null) {
-      actorScope.defer(() => {
-        actorScope.emit(action);
-      });
-    }
-    const actionArgs = {
-      context: intermediateSnapshot.context,
-      event,
-      self: actorScope.self,
-      system: actorScope.system,
-      children: intermediateSnapshot.children,
-      parent: actorScope.self._parent,
-      actions: currentSnapshot.machine.implementations.actions,
-      actors: currentSnapshot.machine.implementations.actors
-    };
-    let actionParams = undefined;
-    if (typeof action === 'object' && action !== null) {
-      const {
-        type: _,
-        ...emittedEventParams
-      } = action;
-      actionParams = emittedEventParams;
-    }
-    if (resolvedAction && '_special' in resolvedAction) {
-      actorScope.actionExecutor({
-        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
-      });
-      const specialAction = resolvedAction;
-      const res = specialAction(actionArgs, emptyEnqueueObject);
-      if (res && ('context' in res || 'children' in res)) {
-        intermediateSnapshot = cloneMachineSnapshot(intermediateSnapshot, {
-          ...('context' in res ? {
-            context: res.context
-          } : {}),
-          ...('children' in res ? {
-            children: res.children
-          } : {})
-        });
+function getBuiltInActionFields(action, args) {
+  switch (action) {
+    case builtInActions['@xstate.spawn']:
+      {
+        const [actor] = args;
+        return {
+          actor,
+          id: actor.id,
+          logic: actor.logic,
+          src: actor.src,
+          input: actor.options?.input
+        };
+      }
+    case builtInActions['@xstate.raise']:
+      {
+        const [, event, options] = args;
+        return {
+          event,
+          id: options?.id,
+          delay: options?.delay
+        };
+      }
+    case builtInActions['@xstate.sendTo']:
+      {
+        const [, target, event, options] = args;
+        return {
+          target,
+          event,
+          id: options?.id,
+          delay: options?.delay
+        };
+      }
+    case builtInActions['@xstate.cancel']:
+      {
+        const [, id] = args;
+        return {
+          id
+        };
+      }
+    case builtInActions['@xstate.stop']:
+      {
+        const [, actor] = args;
+        return {
+          actor
+        };
+      }
+    default:
+      return undefined;
+  }
+}
+function createStartEffect(actor) {
+  const action = builtInActions['@xstate.start'];
+  const args = [actor];
+  return brandBuiltInExecutableAction({
+    type: XSTATE_START,
+    params: {
+      action,
+      args
+    },
+    args,
+    exec: action.bind(null, actor),
+    actor,
+    id: actor.id
+  });
+}
+
+/**
+ * Attached (listener/subscription) starts are ordered before child starts so
+ * that a listener/subscription captures events emitted synchronously as its
+ * target actor starts.
+ */
+function deriveDeferredStarts(effects) {
+  const attachedStarts = [];
+  const childStarts = [];
+  for (const effect of effects) {
+    if (!isBuiltInExecutableAction(effect) || effect.type !== XSTATE_SPAWN) {
+      continue;
+    }
+    const {
+      actor,
+      logic
+    } = effect;
+    const start = createStartEffect(actor);
+    if (logic === listenerLogic || logic === subscriptionLogic) {
+      attachedStarts.push(start);
+    } else {
+      childStarts.push(start);
+    }
+  }
+  return [...attachedStarts, ...childStarts];
+}
+function isBuiltInExecutableAction(action) {
+  return action[builtInExecutableAction] === true;
+}
+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,
+      output: getEventOutput(event),
+      self: actorScope.self,
+      system: actorScope.system,
+      children: intermediateSnapshot.children,
+      parent: actorScope.self._parent,
+      actions: currentSnapshot.machine.implementations.actions,
+      actorSources: currentSnapshot.machine.implementations.actorSources
+    };
+    let actionParams = undefined;
+    if (typeof action === 'object' && action !== null) {
+      const {
+        type: _,
+        ...emittedEventParams
+      } = action;
+      actionParams = emittedEventParams;
+    }
+    if (resolvedAction && '_special' in resolvedAction) {
+      executableActions.push({
+        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
+      });
+      const specialAction = resolvedAction;
+      const res = specialAction(actionArgs, emptyEnqueueObject);
+      if (res && ('context' in res || 'children' in res)) {
+        // Special-action patches never change `_nodes`, so a shallow clone is
+        // equivalent to `cloneMachineSnapshot` — and keeps this module (and
+        // non-machine logic like `createFSM`) independent of State.ts.
+        intermediateSnapshot = {
+          ...intermediateSnapshot,
+          ...(res.context !== undefined ? {
+            context: mergeContextPatch(intermediateSnapshot.context, res.context)
+          } : {}),
+          ...('children' in res ? {
+            children: res.children
+          } : {})
+        };
       }
       continue;
     }
     if (!resolvedAction || !('resolve' in resolvedAction)) {
-      actorScope.actionExecutor({
+      const builtInFields = typeof action === 'object' && action !== null && 'action' in action && typeof action.action === 'function' ? getBuiltInActionFields(action.action, action.args) : undefined;
+      const executableAction = {
         type: typeof action === 'object' ? 'action' in action && typeof action.action === 'function' ? action.action.name ?? '(anonymous)' : action.type : action.name || '(anonymous)',
         params: actionParams,
         args: typeof action === 'object' && 'action' in action ? action.args : [],
-        exec: resolvedAction
-      });
+        exec: resolvedAction || (typeof action === 'object' && action !== null ? () => actorScope.defer(() => actorScope.emit(action)) : undefined),
+        ...builtInFields
+      };
+      executableActions.push(builtInFields ? brandBuiltInExecutableAction(executableAction) : executableAction);
       continue;
     }
   }
-  return intermediateSnapshot;
+  return [intermediateSnapshot, executableActions];
 }
-function createEnqueueObject$1(props, action) {
+function createEnqueueObject(props, action) {
   const enqueueFn = (fn, ...args) => {
     action(fn, ...args);
   };
@@ -1168,7 +666,7 @@ function createEnqueueObject$1(props, action) {
   });
   return enqueueFn;
 }
-const emptyEnqueueObject = createEnqueueObject$1({}, () => {});
+const emptyEnqueueObject = createEnqueueObject({}, () => {});
 
 function parseDurationToMilliseconds(duration) {
   const normalizedDuration = duration.trim();
@@ -1230,6 +728,9 @@ function resolveDelay(delay, delaySource, args) {
   }
   return configuredDelay;
 }
+function getStateInput(snapshot, stateNodeId) {
+  return snapshot._stateInputs?.[stateNodeId];
+}
 function isAtomicStateNode(stateNode) {
   return stateNode.type === 'atomic' || stateNode.type === 'final' || stateNode.type === 'choice';
 }
@@ -1342,22 +843,9 @@ function isInFinalState(stateNodeSet, stateNode) {
 }
 const isStateId = str => str[0] === STATE_IDENTIFIER;
 function getCandidates(stateNode, receivedEventType) {
-  const candidates = stateNode.transitions.get(receivedEventType);
-  if (candidates) {
-    return candidates;
-  }
-  const matchingDescriptors = [];
-  for (const eventDescriptor of stateNode.transitions.keys()) {
-    if (matchesEventDescriptor(receivedEventType, eventDescriptor)) {
-      matchingDescriptors.push(eventDescriptor);
-    }
-  }
-  matchingDescriptors.sort((a, b) => b.length - a.length);
-  const wildcardCandidates = [];
-  for (const descriptor of matchingDescriptors) {
-    wildcardCandidates.push(...stateNode.transitions.get(descriptor));
-  }
-  return wildcardCandidates;
+  const exactMatch = stateNode.transitions.get(receivedEventType);
+  const wildcardCandidates = [...stateNode.transitions.keys()].filter(eventDescriptor => eventDescriptor !== receivedEventType && matchesEventDescriptor(receivedEventType, eventDescriptor)).sort((a, b) => b.length - a.length).flatMap(key => stateNode.transitions.get(key));
+  return exactMatch ? [...exactMatch, ...wildcardCandidates] : wildcardCandidates;
 }
 function scheduleDelayedEvent(stateNode, event, resolveScheduledDelay) {
   const eventType = event.type;
@@ -1396,61 +884,69 @@ function getDelayedTransitions(stateNode) {
       }
     }
   }
-  const mutateEntryExitWithDelay = delay => {
-    const afterEvent = createAfterEvent(delay, stateNode.id);
-    return scheduleDelayedEvent(stateNode, afterEvent, x => resolveDelay(delay, x.delays, {
-      context: x.context,
-      event: x.event,
-      stateNode
-    }));
-  };
-  const delayedTransitions = [];
-  const addDelayedTransitions = (transitionsConfig, event, delay) => {
-    for (const transition of toTransitionConfigArray(transitionsConfig)) {
-      delayedTransitions.push({
-        ...transition,
-        event,
-        delay
-      });
-    }
-  };
+
+  // Every delayed transition — `after`, state-level `timeout`/`onTimeout`, and
+  // invoke-level `timeout`/`onTimeout` — has the same shape: an event raised on
+  // entry (and cancelled on exit) plus a transition that catches it. They
+  // differ only in the event raised, the transition(s) caught, and whether the
+  // delay resolves against the machine's `delays` map (invoke timeouts do not).
+  //
+  // `xstate.timeout.<id>` is a dedicated event so a state-level `timeout` cannot
+  // collide with an explicit `after` entry on the same state. Invoke timeouts
+  // are scheduled on the enclosing state; completion transitions cancel the
+  // timer separately, so it clears even when the parent state stays active.
+  const sources = [];
   if (afterConfig) {
-    for (const delay of Object.keys(afterConfig)) {
-      const configTransition = afterConfig[delay];
-      const parsedDelay = Number.isNaN(+delay) ? delay : +delay;
-      const eventType = mutateEntryExitWithDelay(parsedDelay);
-      const resolvedDelay = getConfiguredDelayValue(parsedDelay, stateNode.machine.implementations.delays);
-      addDelayedTransitions(configTransition, eventType, resolvedDelay);
+    for (const key of Object.keys(afterConfig)) {
+      const delay = Number.isNaN(+key) ? key : +key;
+      sources.push({
+        event: createAfterEvent(delay, stateNode.id),
+        delay,
+        transitions: afterConfig[key],
+        fromDelaysMap: true
+      });
     }
   }
-
-  // Desugar state-level `timeout` + `onTimeout` into a delayed transition.
-  // Uses a dedicated `xstate.timeout.<id>` event so it cannot collide with
-  // explicit `after` entries on the same state.
   if (timeoutConfig !== undefined && onTimeoutConfig) {
-    const timeoutEvent = createTimeoutEvent(stateNode.id);
-    const timeoutEventType = scheduleDelayedEvent(stateNode, timeoutEvent, x => resolveDelay(timeoutConfig, x.delays, {
-      context: x.context,
-      event: x.event,
-      stateNode
-    }));
-    const resolvedDelay = typeof timeoutConfig === 'function' ? timeoutConfig : getConfiguredDelayValue(timeoutConfig, stateNode.machine.implementations.delays);
-    addDelayedTransitions(onTimeoutConfig, timeoutEventType, resolvedDelay);
+    sources.push({
+      event: createTimeoutEvent(stateNode.id),
+      delay: timeoutConfig,
+      transitions: onTimeoutConfig,
+      fromDelaysMap: true
+    });
   }
-
-  // Desugar invoke-level `timeout` + `onTimeout` into a delayed transition on
-  // the enclosing state. Completion transitions cancel this timer separately,
-  // so the timeout is cleared even when the parent state stays active.
   for (const invokeDef of invokeDefs) {
-    const invokeTimeoutEvent = createInvokeTimeoutEvent(invokeDef.id);
-    const invokeTimeout = invokeDef.timeout;
-    const invokeTimeoutEventType = scheduleDelayedEvent(stateNode, invokeTimeoutEvent, x => resolveDelay(invokeTimeout, {}, {
+    sources.push({
+      event: createInvokeTimeoutEvent(invokeDef.id),
+      delay: invokeDef.timeout,
+      transitions: invokeDef.onTimeout,
+      fromDelaysMap: false
+    });
+  }
+
+  // `delay` here is the raw config value, retained only as metadata on the
+  // transition definition — the live delay is resolved at runtime in the
+  // scheduled entry action, so no eager resolution is needed.
+  const delayedTransitions = [];
+  for (const {
+    event,
+    delay,
+    transitions,
+    fromDelaysMap
+  } of sources) {
+    const eventType = scheduleDelayedEvent(stateNode, event, x => resolveDelay(delay, fromDelaysMap ? x.delays : {}, {
       context: x.context,
       event: x.event,
-      stateNode
+      stateNode,
+      input: x.input
     }));
-    const invokeOnTimeout = invokeDef.onTimeout;
-    addDelayedTransitions(invokeOnTimeout, invokeTimeoutEventType, invokeTimeout);
+    for (const transition of toTransitionConfigArray(transitions)) {
+      delayedTransitions.push({
+        ...transition,
+        event: eventType,
+        delay
+      });
+    }
   }
   return delayedTransitions.map(delayedTransition => ({
     ...formatTransition(stateNode, delayedTransition.event, delayedTransition),
@@ -1512,30 +1008,13 @@ function formatRouteTransitions(rootStateNode) {
           }
           return;
         }
-        if ('$unserializable' in routeConfig) {
-          throw new Error(`State "${sn.id}" has a route that is not serializable. Re-provide the route function when reviving this machine.`);
-        }
-
-        // Object-form route. A `guard` (string or function) on the object is
-        // only produced by the JSON layer (createMachineFromConfig) —
-        // authoring uses the function form above.
-        const userGuard = routeConfig.guard;
+        const {
+          guard: _guard,
+          ...routeOptions
+        } = routeConfig;
         const transition = {
-          ...routeConfig,
-          guard: userGuard ? args => {
-            if (!routeMatches(args)) return false;
-            if (typeof userGuard === 'function') return userGuard(args);
-            if (typeof userGuard === 'string') {
-              const guardImpl = args.guards?.[userGuard];
-              if (!guardImpl) {
-                // A typo'd guard name must fail loudly — silently passing
-                // would allow the route and corrupt machine behavior.
-                throw new Error(`Guard '${userGuard}' is not implemented in machine '${rootStateNode.machine.id}'. Available guards: ${Object.keys(args.guards ?? {}).map(key => `'${key}'`).join(', ') || '(none)'}.` );
-              }
-              return guardImpl(args);
-            }
-            return true;
-          } : routeMatches,
+          ...routeOptions,
+          guard: routeMatches,
           target: `#${routeId}`
         };
         routeTransitions.push(formatTransition(rootStateNode, 'xstate.route', transition));
@@ -1574,7 +1053,7 @@ function resolveTarget(stateNode, targets) {
         const targetStateNode = getStateNodeByPath(stateNode.parent, resolvedTarget);
         return targetStateNode;
       } catch (err) {
-        throw new Error(`Invalid transition definition for state node '${stateNode.id}':\n${err.message}`);
+        throw new Error(`Invalid transition definition for state node '${stateNode.id}':\n${err.message}` );
       }
     } else {
       throw new Error(`Invalid target: "${target}" is not a valid target from the root node. Did you mean ".${target}"?` );
@@ -1584,6 +1063,14 @@ function resolveTarget(stateNode, targets) {
 function resolveHistoryDefaultTransition(stateNode) {
   const normalizedTarget = normalizeTarget(stateNode.config.target);
   if (!normalizedTarget) {
+    if (stateNode.parent.type === 'parallel') {
+      return {
+        target: [stateNode.parent],
+        source: stateNode,
+        reenter: false,
+        eventType: ''
+      };
+    }
     return stateNode.parent.initial;
   }
   return {
@@ -1625,12 +1112,9 @@ function getStateNode(stateNode, stateKey) {
   if (isStateId(stateKey)) {
     return stateNode.machine.getStateNodeById(stateKey);
   }
-  if (!stateNode.states) {
-    throw new Error(`Unable to retrieve child state '${stateKey}' from '${stateNode.id}'; no child states exist.`);
-  }
-  const result = stateNode.states[stateKey];
+  const result = stateNode.states?.[stateKey];
   if (!result) {
-    throw new Error(`Child state '${stateKey}' does not exist on '${stateNode.id}'`);
+    throw new Error(!stateNode.states ? `Unable to retrieve child state '${stateKey}' from '${stateNode.id}'; no child states exist.` : `Child state '${stateKey}' does not exist on '${stateNode.id}'`);
   }
   return result;
 }
@@ -1771,6 +1255,11 @@ function removeConflictingTransitions(enabledTransitions, stateNodeSet, snapshot
       if (hasIntersection(getExitSet(t1), getExitSet(t2))) {
         if (isDescendant(t1.source, t2.source)) {
           transitionsToRemove.add(t2);
+        } else if (t2.source.type === 'final' && t1.source.type !== 'final') {
+          // A transition sourced in a final state yields to a conflicting
+          // transition from a live state, so a done region doesn't keep
+          // consuming events its siblings can still handle.
+          transitionsToRemove.add(t2);
         } else {
           t1Preempted = true;
           break;
@@ -1790,7 +1279,9 @@ function getEffectiveTargetStates(transition, snapshot, event, actorScope) {
   const historyValue = snapshot.historyValue;
   const {
     targets
-  } = getTransitionResult(transition, snapshot, event, actorScope);
+  } = getTransitionResult(transition, snapshot, event, actorScope, {
+    resolveActions: false
+  });
   if (!targets) {
     return [];
   }
@@ -1812,19 +1303,44 @@ function getEffectiveTargetStates(transition, snapshot, event, actorScope) {
   }
   return [...targetSet];
 }
+
+/**
+ * Narrows a parallel domain to the single child region that contains every
+ * effective target, so that a transition confined to one region does not exit
+ * (and reset) its sibling regions.
+ */
+function narrowParallelDomain(domain, targetStates) {
+  let narrowed = domain;
+  while (narrowed.type === 'parallel') {
+    const region = getChildren(narrowed).find(child => targetStates.every(target => target === child || isDescendant(target, child)));
+    if (!region) {
+      break;
+    }
+    narrowed = region;
+  }
+  return narrowed;
+}
 function getTransitionDomain(transition, snapshot, event, actorScope) {
   const targetStates = getEffectiveTargetStates(transition, snapshot, event, actorScope);
   const {
     reenter
-  } = getTransitionResult(transition, snapshot, event, actorScope);
-  if (!reenter && targetStates.every(target => target === transition.source || isDescendant(target, transition.source))) {
-    return transition.source;
+  } = getTransitionResult(transition, snapshot, event, actorScope, {
+    resolveActions: false
+  });
+  if (targetStates.every(target => target === transition.source || isDescendant(target, transition.source))) {
+    // Targets are contained within the source. A reentering transition
+    // exits and reenters the source itself; otherwise the domain narrows
+    // past parallel nodes so sibling regions are left untouched.
+    return reenter ? transition.source : narrowParallelDomain(transition.source, targetStates);
   }
   const [head, ...tail] = targetStates.concat(transition.source);
   // Find the least common ancestor (LCA) of the source and effective targets.
   for (const ancestor of getProperAncestors(head, undefined)) {
     if (tail.every(sn => isDescendant(sn, ancestor))) {
-      return ancestor;
+      // A cross-region transition (source in one parallel region, targets in
+      // another) only exits the region containing its targets; the source
+      // region and other sibling regions stay put unless it reenters.
+      return reenter ? ancestor : narrowParallelDomain(ancestor, targetStates);
     }
   }
 
@@ -1832,17 +1348,20 @@ function getTransitionDomain(transition, snapshot, event, actorScope) {
   if (reenter) {
     return;
   }
-  return transition.source.machine.root;
+  return narrowParallelDomain(transition.source.machine.root, targetStates);
 }
 function computeExitSet(transitions, stateNodeSet, snapshot, event, actorScope) {
   const statesToExit = new Set();
   for (const transition of transitions) {
     const {
-      targets
-    } = getTransitionResult(transition, snapshot, event, actorScope);
+      targets,
+      reenter
+    } = getTransitionResult(transition, snapshot, event, actorScope, {
+      resolveActions: false
+    });
     if (targets?.length) {
       const domain = getTransitionDomain(transition, snapshot, event, actorScope);
-      if (transition.reenter && transition.source === domain) {
+      if (reenter && transition.source === domain) {
         statesToExit.add(domain);
       }
       for (const stateNode of stateNodeSet) {
@@ -1866,16 +1385,11 @@ function initialMicrostep(root, preInitialState, actorScope, initEvent, internal
 
 /** https://www.w3.org/TR/scxml/#microstepProcedure */
 function microstep(transitions, currentSnapshot, actorScope, event, isInitial, internalQueue) {
-  const actions = [];
+  const executableActions = [];
   if (!transitions.length) {
-    return [currentSnapshot, actions];
+    return [currentSnapshot, executableActions];
   }
-  const originalExecutor = actorScope.actionExecutor;
-  actorScope.actionExecutor = action => {
-    actions.push(action);
-    originalExecutor(action);
-  };
-  try {
+  {
     const mutStateNodeSet = new Set(currentSnapshot._nodes);
     let historyValue = currentSnapshot.historyValue;
     const originalContext = currentSnapshot.context;
@@ -1896,13 +1410,13 @@ function microstep(transitions, currentSnapshot, actorScope, event, isInitial, i
           children,
           system: actorScope.system,
           actions: currentSnapshot.machine.implementations.actions,
-          actors: currentSnapshot.machine.implementations.actors,
+          actorSources: currentSnapshot.machine.implementations.actorSources,
           guards: currentSnapshot.machine.implementations.guards,
           delays: currentSnapshot.machine.implementations.delays,
           input
         }, enqueue);
-        if (res?.context) {
-          updatedContext = res.context;
+        if (res?.context !== undefined) {
+          updatedContext = mergeContextPatch(context, res.context);
         }
         return [actions, updatedContext, internalEvents];
       }
@@ -1938,7 +1452,7 @@ function microstep(transitions, currentSnapshot, actorScope, event, isInitial, i
         }
       }
       for (const exitStateNode of statesToExit) {
-        const stateInput = currentSnapshot._stateInputs?.[exitStateNode.id];
+        const stateInput = getStateInput(currentSnapshot, exitStateNode.id);
         const [exitActions, nextContext, internalEvents] = exitStateNode.exit ? getStateActionsAndContext(exitStateNode.exit, nextState.context, currentSnapshot.children, stateInput) : [[]];
         if (internalEvents?.length) {
           internalQueue.push(...internalEvents);
@@ -1948,7 +1462,9 @@ function microstep(transitions, currentSnapshot, actorScope, event, isInitial, i
             context: nextContext
           });
         }
-        nextState = resolveAndExecuteActionsWithContext(nextState, event, actorScope, exitActions);
+        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) {
@@ -1973,8 +1489,8 @@ function microstep(transitions, currentSnapshot, actorScope, event, isInitial, i
         transitionActions.push(...toArray(t.actions));
       }
       const res = getCurrentTransitionResult(t);
-      if (res.context) {
-        context = res.context;
+      if (res.context !== undefined) {
+        context = mergeContextPatch(context, res.context);
       }
       if (res.actions) {
         transitionActions.push(...res.actions);
@@ -1989,17 +1505,18 @@ function microstep(transitions, currentSnapshot, actorScope, event, isInitial, i
     const enterStates = () => {
       const getMachineOutput = rootCompletionNode => {
         const rootNode = nextState.machine.root;
-        if (rootNode.output === undefined) {
-          return;
-        }
         let completionOutput;
         if (rootCompletionNode.output !== undefined && rootCompletionNode.parent) {
-          completionOutput = resolveOutput(rootCompletionNode.output, nextState.context, event, actorScope.self);
+          const rootDoneEvent = internalQueue.find(e => e.type === `xstate.done.state.${rootNode.id}`);
+          completionOutput = rootDoneEvent && rootCompletionNode.parent === rootNode ? rootDoneEvent.output : resolveOutput(rootCompletionNode.output, nextState.context, event, actorScope.self, stateInputMap[rootCompletionNode.id]);
         } else if (rootCompletionNode.type === 'parallel') {
           const parallelDoneType = `xstate.done.state.${rootCompletionNode.id}`;
           const parallelDoneEvent = internalQueue.find(e => e.type === parallelDoneType);
           completionOutput = parallelDoneEvent?.output;
         }
+        if (rootNode.output === undefined) {
+          return rootCompletionNode.parent === rootNode ? completionOutput : undefined;
+        }
         return resolveOutput(rootNode.output, nextState.context, createDoneStateEvent(rootCompletionNode.id, completionOutput), actorScope.self);
       };
       const statesToEnter = new Set();
@@ -2076,7 +1593,9 @@ function microstep(transitions, currentSnapshot, actorScope, event, isInitial, i
         const {
           targets,
           reenter
-        } = getCurrentTransitionResult(transition);
+        } = getTransitionResult(transition, currentSnapshot, event, actorScope, {
+          resolveActions: false
+        });
         for (const targetNode of targets ?? []) {
           if (!isHistoryNode(targetNode) && (transition.source !== targetNode || transition.source !== domain || reenter)) {
             statesToEnter.add(targetNode);
@@ -2092,6 +1611,12 @@ function microstep(transitions, currentSnapshot, actorScope, event, isInitial, i
           }
           addAncestorStatesToEnter(ancestors, !transition.source.parent && reenter ? undefined : domain);
         }
+        if (reenter && domain === transition.source) {
+          // A reentering transition whose domain is its own source exits and
+          // reenters the source, so the source must be entered explicitly —
+          // it has no ancestor inside the domain to add it.
+          statesToEnter.add(transition.source);
+        }
       }
       if (isInitial) {
         statesForDefaultEntry.add(currentSnapshot.machine.root);
@@ -2099,14 +1624,18 @@ function microstep(transitions, currentSnapshot, actorScope, event, isInitial, i
       const stateInputMap = {
         ...currentSnapshot._stateInputs
       };
+      let stateInputsChanged = false;
       for (const transition of filteredTransitions) {
         const {
           targets,
           input
-        } = getCurrentTransitionResult(transition);
+        } = getTransitionResult(transition, currentSnapshot, event, actorScope, {
+          resolveActions: false
+        });
         if (input && targets) {
           for (const targetNode of targets) {
             stateInputMap[targetNode.id] = input;
+            stateInputsChanged = true;
           }
         }
       }
@@ -2123,7 +1652,7 @@ function microstep(transitions, currentSnapshot, actorScope, event, isInitial, i
           let src = invokeDef.logic;
           if (typeof src === 'function') {
             src = src({
-              actors: currentSnapshot.machine.implementations.actors,
+              actorSources: currentSnapshot.machine.implementations.actorSources,
               context: nextState.context,
               event,
               self: actorScope.self
@@ -2131,12 +1660,13 @@ function microstep(transitions, currentSnapshot, actorScope, event, isInitial, i
           }
           const logic = typeof src === 'string' ? resolveReferencedActor(currentSnapshot.machine, src) : src;
           if (!logic) {
-            throw new Error(`Actor logic '${typeof src === 'string' ? src : 'inline'}' not implemented in machine '${currentSnapshot.machine.id}'`);
+            throw new Error(`Actor logic '${typeof src === 'string' ? src : 'inline'}' not implemented in machine '${currentSnapshot.machine.id}'` );
           }
           const input = typeof invokeDef.input === 'function' ? invokeDef.input({
             self: actorScope.self,
             context: nextState.context,
-            event
+            event,
+            output: getEventOutput(event)
           }) : invokeDef.input;
           const actor = createActor(logic, {
             ...invokeDef,
@@ -2145,7 +1675,7 @@ function microstep(transitions, currentSnapshot, actorScope, event, isInitial, i
             syncSnapshot: !!invokeDef.onSnapshot
           });
           actions.push({
-            action: builtInActions['@xstate.start'],
+            action: builtInActions['@xstate.spawn'],
             args: [actor]
           });
           if (invokeDef.id) {
@@ -2157,18 +1687,23 @@ function microstep(transitions, currentSnapshot, actorScope, event, isInitial, i
             children
           });
         }
-        let context;
+        let context = nextState.context;
+        let contextChangedByEntry = false;
         const stateInput = stateInputMap[stateNodeToEnter.id];
         if (stateNodeToEnter.entry) {
-          const [resultActions, nextContext, nextInternalEvents] = getStateActionsAndContext(stateNodeToEnter.entry, nextState.context, children, stateInput);
+          const [resultActions, nextContext, nextInternalEvents] = getStateActionsAndContext(stateNodeToEnter.entry, context, children, stateInput);
           actions.push(...resultActions);
           if (nextInternalEvents?.length) {
             internalQueue.push(...nextInternalEvents);
           }
           if (nextContext) {
             context = nextContext;
+            contextChangedByEntry = true;
           }
         }
+        if (contextChangedByEntry) {
+          nextState.context = context;
+        }
         if (statesForDefaultEntry.has(stateNodeToEnter)) {
           const {
             actions: initialActions,
@@ -2180,13 +1715,14 @@ function microstep(transitions, currentSnapshot, actorScope, event, isInitial, i
           if (initialInput && stateNodeToEnter.initial?.target) {
             for (const targetNode of stateNodeToEnter.initial.target) {
               stateInputMap[targetNode.id] = initialInput;
+              stateInputsChanged = true;
             }
           }
         }
-        nextState = resolveAndExecuteActionsWithContext(nextState, event, actorScope, actions);
-        if (context) {
-          nextState.context = context;
-        }
+        const [resolvedState, resolvedActions] = resolveActionsWithContext(nextState, event, actorScope, actions);
+        nextState = resolvedState;
+        actions.length = 0;
+        executableActions.push(...resolvedActions);
         if (stateNodeToEnter.type !== 'final') {
           continue;
         }
@@ -2194,14 +1730,14 @@ function microstep(transitions, currentSnapshot, actorScope, event, isInitial, i
         let ancestorMarker = parent?.type === 'parallel' ? parent : parent?.parent;
         let rootCompletionNode = ancestorMarker || stateNodeToEnter;
         if (parent?.type === 'compound') {
-          internalQueue.push(createDoneStateEvent(parent.id, stateNodeToEnter.output !== undefined ? resolveOutput(stateNodeToEnter.output, nextState.context, event, actorScope.self) : undefined));
+          internalQueue.push(createDoneStateEvent(parent.id, stateNodeToEnter.output !== undefined ? resolveOutput(stateNodeToEnter.output, nextState.context, event, actorScope.self, stateInput) : undefined));
         }
         while (ancestorMarker?.type === 'parallel' && !completedNodes.has(ancestorMarker) && isInFinalState(mutStateNodeSet, ancestorMarker)) {
           completedNodes.add(ancestorMarker);
           const regionOutput = {};
           for (const region of getChildren(ancestorMarker)) {
             if (region.type === 'final') {
-              regionOutput[region.key] = region.output !== undefined ? resolveOutput(region.output, nextState.context, event, actorScope.self) : undefined;
+              regionOutput[region.key] = region.output !== undefined ? resolveOutput(region.output, nextState.context, event, actorScope.self, stateInputMap[region.id]) : undefined;
               continue;
             }
             if (region.type === 'parallel') {
@@ -2211,7 +1747,7 @@ function microstep(transitions, currentSnapshot, actorScope, event, isInitial, i
               continue;
             }
             const finalChild = getChildren(region).find(s => s.type === 'final' && mutStateNodeSet.has(s));
-            regionOutput[region.key] = finalChild?.output !== undefined ? resolveOutput(finalChild.output, nextState.context, event, actorScope.self) : undefined;
+            regionOutput[region.key] = finalChild?.output !== undefined ? resolveOutput(finalChild.output, nextState.context, event, actorScope.self, stateInputMap[finalChild.id]) : undefined;
           }
           internalQueue.push(createDoneStateEvent(ancestorMarker.id, regionOutput));
           rootCompletionNode = ancestorMarker;
@@ -2225,8 +1761,7 @@ function microstep(transitions, currentSnapshot, actorScope, event, isInitial, i
           output: getMachineOutput(rootCompletionNode)
         });
       }
-      const inputChanged = JSON.stringify(stateInputMap) !== JSON.stringify(currentSnapshot._stateInputs || {});
-      if (inputChanged) {
+      if (stateInputsChanged) {
         nextState = cloneMachineSnapshot(nextState, {
           _stateInputs: stateInputMap
         });
@@ -2234,7 +1769,9 @@ function microstep(transitions, currentSnapshot, actorScope, event, isInitial, i
     };
 
     // Execute transition content
-    nextState = resolveAndExecuteActionsWithContext(nextState, event, actorScope, transitionActions);
+    const [resolvedTransitionState, transitionExecutableActions] = resolveActionsWithContext(nextState, event, actorScope, transitionActions);
+    nextState = resolvedTransitionState;
+    executableActions.push(...transitionExecutableActions);
     if (context && context !== currentSnapshot.context) {
       nextState = cloneMachineSnapshot(nextState, {
         context
@@ -2249,7 +1786,7 @@ function microstep(transitions, currentSnapshot, actorScope, event, isInitial, i
       const nextStateNodesToExit = nextStateNodes.sort((a, b) => b.order - a.order);
       nextStateNodesToExit.forEach(stateNode => {
         if (stateNode.exit) {
-          const stateInput = nextState._stateInputs?.[stateNode.id];
+          const stateInput = getStateInput(nextState, stateNode.id);
           const [exitActions,, nextInternalEvents] = getStateActionsAndContext(stateNode.exit, nextState.context, nextState.children, stateInput);
           allExitActions.push(...exitActions);
           if (nextInternalEvents?.length) {
@@ -2257,22 +1794,22 @@ function microstep(transitions, currentSnapshot, actorScope, event, isInitial, i
           }
         }
       });
-      nextState = resolveAndExecuteActionsWithContext(nextState, event, actorScope, allExitActions);
+      const [resolvedState, resolvedActions] = resolveActionsWithContext(nextState, event, actorScope, allExitActions);
+      nextState = resolvedState;
+      executableActions.push(...resolvedActions);
     }
     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),
       // clone to ensure reference inequality for eventless transition re-evaluation
       if (nextState.context !== originalContext) {
-        return [cloneMachineSnapshot(nextState), actions];
+        return [cloneMachineSnapshot(nextState), executableActions];
       }
-      return [nextState, actions];
+      return [nextState, executableActions];
     }
     return [cloneMachineSnapshot(nextState, {
       _nodes: nextStateNodes,
       historyValue
-    }), actions];
-  } finally {
-    actorScope.actionExecutor = originalExecutor;
+    }), executableActions];
   }
 }
 
@@ -2280,29 +1817,33 @@ function microstep(transitions, currentSnapshot, actorScope, event, isInitial, i
  * Gets the transition result for a given transition without executing the
  * transition.
  */
-function getTransitionResult(transition, snapshot, event, actorScope) {
+function getTransitionResult(transition, snapshot, event, actorScope, options) {
+  const transitionArgs = {
+    context: snapshot.context,
+    event,
+    output: getEventOutput(event),
+    value: snapshot.value,
+    children: snapshot.children,
+    system: actorScope.system,
+    parent: actorScope.self._parent,
+    self: actorScope.self,
+    actions: snapshot.machine.implementations.actions,
+    actorSources: snapshot.machine.implementations.actorSources,
+    guards: snapshot.machine.implementations.guards,
+    delays: snapshot.machine.implementations.delays,
+    input: getStateInput(snapshot, transition.source.id)
+  };
   if (transition.to) {
     const actions = [];
     const internalEvents = [];
-    const enqueue = createTransitionEnqueue(actorScope, actions, internalEvents);
-    const res = transition.to({
-      context: snapshot.context,
-      event,
-      value: snapshot.value,
-      children: snapshot.children,
-      parent: actorScope.self._parent,
-      self: actorScope.self,
-      actions: snapshot.machine.implementations.actions,
-      actors: snapshot.machine.implementations.actors,
-      guards: snapshot.machine.implementations.guards,
-      delays: snapshot.machine.implementations.delays
-    }, enqueue);
+    const enqueue = createTransitionEnqueue(actorScope, actions, internalEvents, false, options?.resolveActions ?? true);
+    const res = transition.to(transitionArgs, enqueue);
     const targets = res?.target ? resolveTarget(transition.source, toArray(res.target)) : undefined;
-    // Resolve input for .to transitions
-    const resolvedInput = typeof transition.input === 'function' ? transition.input({
+    const resolvedInput = res?.input ?? (typeof transition.input === 'function' ? transition.input({
       context: snapshot.context,
-      event
-    }) : transition.input;
+      event,
+      output: getEventOutput(event)
+    }) : transition.input);
     return {
       targets: targets,
       context: res?.context,
@@ -2316,11 +1857,13 @@ function getTransitionResult(transition, snapshot, event, actorScope) {
   // Resolve input for regular transitions
   const resolvedInput = typeof transition.input === 'function' ? transition.input({
     context: snapshot.context,
-    event
+    event,
+    output: getEventOutput(event)
   }) : transition.input;
+  const resolvedContext = typeof transition.context === 'function' ? transition.context(transitionArgs) : transition.context;
   return {
     targets: transition.target,
-    context: undefined,
+    context: resolvedContext,
     reenter: transition.reenter,
     actions: undefined,
     internalEvents: undefined,
@@ -2356,7 +1899,7 @@ function macrostep(snapshot, event, actorScope, internalQueue) {
   // Determine the next state based on the next microstep
   if (nextEvent.type !== XSTATE_INIT) {
     const currentEvent = nextEvent;
-    const isErr = isErrorActorEvent(currentEvent);
+    const isErr = isErrorEvent(currentEvent);
     const transitions = nextSnapshot.machine.getTransitionData(nextSnapshot, currentEvent, actorScope.self);
     if (isErr && !transitions.length) {
       // TODO: we should likely only allow transitions selected by very explicit descriptors
@@ -2427,31 +1970,13 @@ function resolveStateValue(rootNode, stateValue) {
   const allStateNodes = getAllStateNodes(getStateNodes(rootNode, stateValue));
   return getStateValue(rootNode, allStateNodes);
 }
-function createEnqueueObject(props, action) {
-  const enqueueFn = (fn, ...args) => {
-    action(fn, ...args);
-  };
-  Object.assign(enqueueFn, {
-    cancel: () => {},
-    emit: () => {},
-    log: () => {},
-    raise: () => {},
-    spawn: () => ({}),
-    sendTo: () => {},
-    stop: () => {},
-    listen: () => ({}),
-    subscribeTo: () => ({}),
-    ...props
-  });
-  return enqueueFn;
-}
 function hasEffect(transition, context, event, snapshot, self) {
   if (transition.to) {
-    return transitionToHasEffect(transition.to, context, event, snapshot, self, snapshot.machine.implementations);
+    return transitionToHasEffect(transition.to, context, event, snapshot, self, snapshot.machine.implementations, transition.source.id);
   }
   return false;
 }
-function transitionToHasEffect(transitionTo, context, event, snapshot, self, implementations) {
+function transitionToHasEffect(transitionTo, context, event, snapshot, self, implementations, sourceId) {
   let hasEffect = false;
   let res;
   try {
@@ -2462,16 +1987,19 @@ function transitionToHasEffect(transitionTo, context, event, snapshot, self, imp
     res = transitionTo({
       context,
       event,
+      output: getEventOutput(event),
       self,
+      system: self.system,
       value: snapshot.value,
       children: snapshot.children,
       parent: {
         send: triggerEffect
       },
       actions: implementations.actions,
-      actors: implementations.actors,
+      actorSources: implementations.actorSources,
       guards: implementations.guards,
-      delays: implementations.delays
+      delays: implementations.delays,
+      input: getStateInput(snapshot, sourceId)
     }, createEnqueueObject({
       emit: triggerEffect,
       cancel: triggerEffect,
@@ -2524,38 +2052,22 @@ function evaluateCandidate(candidate, event, snapshot, stateNode, self) {
     const guardArgs = {
       context: snapshot.context,
       event,
+      output: getEventOutput(event),
       self,
       parent: self._parent,
       children: snapshot.children,
       actions: stateNode.machine.implementations.actions,
-      actors: stateNode.machine.implementations.actors,
+      actorSources: stateNode.machine.implementations.actorSources,
       guards: stateNode.machine.implementations.guards,
       delays: stateNode.machine.implementations.delays,
       _snapshot: snapshot
     };
-    const guardConfig = candidate.guard;
-    const guardParams = typeof guardConfig?.params === 'function' ? guardConfig.params({
-      context: snapshot.context,
-      event
-    }) : guardConfig?.params;
-    let guardPassed = true;
-    if (typeof guardConfig === 'function') {
-      guardPassed = guardConfig(guardArgs, guardParams);
-    } else if (typeof guardConfig?.type === 'string') {
-      const guardImpl = stateNode.machine.implementations.guards[guardConfig.type];
-      if (!guardImpl) {
-        // A typo'd guard name must fail loudly — silently passing would
-        // take the guarded transition and corrupt machine behavior.
-        throw new Error(`Guard '${guardConfig.type}' is not implemented in machine '${stateNode.machine.id}'. Available guards: ${Object.keys(stateNode.machine.implementations.guards).map(key => `'${key}'`).join(', ') || '(none)'}.` );
-      }
-      guardPassed = guardImpl(guardArgs, guardParams);
-    }
-    if (!guardPassed) {
+    if (!candidate.guard(guardArgs)) {
       return false;
     }
   }
   if (candidate.to) {
-    return transitionToHasEffect(candidate.to, snapshot.context, event, snapshot, self, stateNode.machine.implementations);
+    return transitionToHasEffect(candidate.to, snapshot.context, event, snapshot, self, stateNode.machine.implementations, candidate.source.id);
   }
   return true;
 }
@@ -2563,29 +2075,6 @@ function evaluateCandidate(candidate, event, snapshot, stateNode, self) {
 function isMachineSnapshot(value) {
   return !!value && typeof value === 'object' && 'machine' in value && 'value' in value;
 }
-let emptyCanActor;
-let emptyCanActorScope;
-function getEmptyCanActor() {
-  return emptyCanActor ??= createEmptyActor();
-}
-function getEmptyCanActorScope() {
-  if (emptyCanActorScope) {
-    return emptyCanActorScope;
-  }
-  const actor = getEmptyCanActor();
-  emptyCanActorScope = {
-    self: actor,
-    logger: () => {},
-    id: '',
-    sessionId: '',
-    defer: () => {},
-    system: actor.system,
-    stopChild: () => {},
-    emit: () => {},
-    actionExecutor: () => {}
-  };
-  return emptyCanActorScope;
-}
 const machineSnapshotMatches = function matches(testValue) {
   return matchesState(testValue, this.value);
 };
@@ -2596,24 +2085,10 @@ const machineSnapshotCan = function can(event) {
   if (!this.machine) {
     console.warn(`state.can(...) used outside of a machine-created State object; this will always return false.`);
   }
-  const emptyActor = getEmptyCanActor();
-  const emptyActorScope = getEmptyCanActorScope();
-  const transitionData = this.machine.getTransitionData(this, event, emptyActor);
-  if (!transitionData?.length) {
-    return false;
-  }
 
-  // Check that at least one transition is not forbidden
-  for (const transition of transitionData) {
-    if (transition.target !== undefined) {
-      return true;
-    }
-    const res = getTransitionResult(transition, this, event, emptyActorScope);
-    if (res.targets?.length || res.context || hasEffect(transition, this.context, event, this, emptyActor)) {
-      return true;
-    }
-  }
-  return false;
+  // The dry-run logic lives on the machine so that non-machine bundles
+  // (e.g. `createFSM`) don't pay for the transition-resolution machinery.
+  return this.machine?._canTransition(this, event) ?? false;
 };
 const machineSnapshotToJSON = function toJSON() {
   const {
@@ -2744,7 +2219,7 @@ function getPersistedSnapshot(snapshot, options) {
     childrenJson[id] = {
       snapshot: child.getPersistedSnapshot(options),
       src: child.src,
-      systemId: child.systemId,
+      registryKey: child.registryKey,
       syncSnapshot: child._syncSnapshot
     };
   }
@@ -2754,6 +2229,9 @@ function getPersistedSnapshot(snapshot, options) {
     children: childrenJson,
     historyValue: serializeHistoryValue(jsonValues.historyValue)
   };
+  if (_stateInputs && Object.keys(_stateInputs).length > 0) {
+    persisted.stateInputs = _stateInputs;
+  }
   if (machine.version !== undefined) {
     persisted.version = machine.version;
   }
@@ -2889,24 +2367,38 @@ function toArray(value) {
   }
   return toArrayStrict(value);
 }
-function resolveOutput(mapper, context, event, self) {
+function resolveOutput(mapper, context, event, self, input) {
   if (typeof mapper === 'function') {
-    return mapper({
+    const outputMapper = mapper;
+    const args = {
       context,
       event,
-      self
-    });
+      output: getEventOutput(event),
+      self,
+      input
+    };
+    return outputMapper(args);
   }
   if (!!mapper && typeof mapper === 'object' && Object.values(mapper).some(val => typeof val === 'function')) {
     console.warn(`Dynamically mapping values to individual properties is deprecated. Use a single function that returns the mapped object instead.\nFound object containing properties whose values are possibly mapping functions: ${Object.entries(mapper).filter(([, value]) => typeof value === 'function').map(([key, value]) => `\n - ${key}: ${value.toString().replace(/\n\s*/g, '')}`).join('')}`);
   }
   return mapper;
 }
+function getEventOutput(event) {
+  if (isDoneEvent(event)) {
+    const doneEvent = event;
+    return doneEvent.output;
+  }
+  return undefined;
+}
+function isDoneEvent(event) {
+  return event.type.startsWith('xstate.done.actor.') || event.type.startsWith('xstate.done.state.');
+}
 function isArray(value) {
   return Array.isArray(value);
 }
-function isErrorActorEvent(event) {
-  return event.type.startsWith('xstate.error.actor');
+function isErrorEvent(event) {
+  return event.type.startsWith('xstate.error.');
 }
 function toTransitionConfigArray(configLike) {
   return toArrayStrict(configLike).map(transitionLike => {
@@ -2944,14 +2436,14 @@ function createInvokeId(stateNodeId, index) {
 function resolveReferencedActor(machine, src) {
   const match = src.match(/^xstate\.invoke\.(\d+)\.(.*)/);
   if (!match) {
-    return machine.implementations.actors[src];
+    return machine.implementations.actorSources[src];
   }
   const [, indexStr, nodeId] = match;
   const node = machine.getStateNodeById(nodeId);
   const invokeConfig = node.config.invoke;
   const configSrc = (Array.isArray(invokeConfig) ? invokeConfig[indexStr] : invokeConfig).src;
   // A referenced actor may itself be registered by name.
-  return typeof configSrc === 'string' ? machine.implementations.actors[configSrc] : configSrc;
+  return typeof configSrc === 'string' ? machine.implementations.actorSources[configSrc] : configSrc;
 }
 function getAllOwnEventDescriptors(snapshot) {
   return [...new Set([...snapshot._nodes.flatMap(sn => sn.ownEvents)])];
@@ -3004,7 +2496,7 @@ function matchesEventDescriptor(eventType, descriptor) {
 function createScheduledEventId(actor, id) {
   return `${actor.sessionId}.${id}`;
 }
-function createSystem(rootActor, options) {
+function createRuntimeSystem(rootActor, options) {
   let idCounter = 0;
   const children = new Map();
   const keyedActors = new Map();
@@ -3027,373 +2519,150 @@ function createSystem(rootActor, options) {
     collected.push({
       targetRef: target,
       targetId: target.id,
-      event,
-      delay,
-      id
-    });
-  };
-  const scheduler = {
-    schedule: (source, target, event, delay, id = Math.random().toString(36).slice(2)) => {
-      recordSent(source, target, event, delay, id);
-      const scheduledEvent = {
-        source,
-        target,
-        event,
-        delay,
-        id,
-        startedAt: Date.now()
-      };
-      const scheduledEventId = createScheduledEventId(source, id);
-      system._snapshot._scheduledEvents[scheduledEventId] = scheduledEvent;
-      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);
-      }, delay);
-      timerMap[scheduledEventId] = timeout;
-    },
-    cancel: (source, id) => {
-      const scheduledEventId = createScheduledEventId(source, id);
-      const timeout = timerMap[scheduledEventId];
-      delete timerMap[scheduledEventId];
-      delete system._snapshot._scheduledEvents[scheduledEventId];
-      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);
-        }
-      }
-    }
-  };
-  // Delivers an event to the target actor. Used by both `_relay` (which also
-  // records the send) and the scheduler's timer (which already recorded it).
-  const deliver = (source, target, event) => {
-    const targetMachine = target.logic;
-    const isInternalEvent = typeof targetMachine?.isInternalEventType === 'function' && targetMachine.isInternalEventType(event.type);
-    if (isInternalEvent && source !== target) {
-      throw new Error(`Internal event "${event.type}" cannot be sent to actor "${target.id}" from outside.`);
-    }
-
-    // remember the last source for unified transition inspect event
-    target._lastSourceRef = source;
-    target._send(event);
-  };
-  const sendInspectionEvent = event => {
-    if (!inspectionObservers.size) {
-      return;
-    }
-    const resolvedInspectionEvent = {
-      ...event,
-      rootId: rootActor.sessionId
-    };
-    inspectionObservers.forEach(observer => observer.next?.(resolvedInspectionEvent));
-  };
-  const system = {
-    children,
-    reverseKeyedActors,
-    keyedActors,
-    _snapshot: {
-      _scheduledEvents: (options?.snapshot && options.snapshot.scheduler) ?? {}
-    },
-    _bookId: () => `x:${idCounter++}`,
-    _register: (sessionId, actor) => {
-      children.set(sessionId, actor);
-      return sessionId;
-    },
-    _unregister: actor => {
-      children.delete(actor.sessionId);
-      const systemId = reverseKeyedActors.get(actor);
-      if (systemId !== undefined) {
-        keyedActors.delete(systemId);
-        reverseKeyedActors.delete(actor);
-      }
-    },
-    get: systemId => {
-      return keyedActors.get(systemId);
-    },
-    getAll: () => {
-      return Object.fromEntries(keyedActors.entries());
-    },
-    _set: (systemId, actor) => {
-      const existing = keyedActors.get(systemId);
-      if (existing && existing !== actor) {
-        throw new Error(`Actor with system ID '${systemId}' already exists.`);
-      }
-      keyedActors.set(systemId, actor);
-      reverseKeyedActors.set(actor, systemId);
-    },
-    inspect: observerOrFn => {
-      const observer = toObserver(observerOrFn);
-      inspectionObservers.add(observer);
-      return {
-        unsubscribe() {
-          inspectionObservers.delete(observer);
-        }
-      };
-    },
-    _sendInspectionEvent: sendInspectionEvent,
-    _relay: (source, target, event) => {
-      recordSent(source, target, event);
-      deliver(source, target, event);
-    },
-    scheduler,
-    getSnapshot: () => {
-      return {
-        _scheduledEvents: {
-          ...system._snapshot._scheduledEvents
-        }
-      };
-    },
-    start: () => {
-      const scheduledEvents = system._snapshot._scheduledEvents;
-      system._snapshot._scheduledEvents = {};
-      for (const scheduledId in scheduledEvents) {
-        const {
-          source,
-          target,
-          event,
-          delay,
-          id
-        } = scheduledEvents[scheduledId];
-        scheduler.schedule(source, target, event, delay, id);
-      }
-    },
-    _clock: clock,
-    _logger: logger,
-    _timerStrategy: options.timers
-  };
-  return system;
-}
-
-const effectStates = new WeakMap();
-const XSTATE_LOGIC_EFFECT_RESOLVE = 'xstate.logic.effect.resolve';
-const XSTATE_LOGIC_EFFECT_REJECT = 'xstate.logic.effect.reject';
-const XSTATE_LOGIC_EFFECT_START = 'xstate.logic.effect.start';
-function getEffectState(self) {
-  let state = effectStates.get(self);
-  if (!state) {
-    state = new Map();
-    effectStates.set(self, state);
-  }
-  return state;
-}
-function executeLogicEffects(effects, actorScope) {
-  if (!effects?.length) {
-    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;
-        }
-    }
-  }
-}
-function resolveContext(context, input) {
-  return typeof context === 'function' ? context({
-    input
-  }) : context;
-}
-function createLogic(config) {
-  const transition = (snapshot, event, actorScope) => {
-    if (snapshot.status !== 'active') {
-      return [snapshot, []];
-    }
-    if (event.type === XSTATE_STOP) {
-      return [{
-        ...snapshot,
-        status: 'stopped',
-        input: undefined
-      }, [{
-        type: 'cleanupEffects'
-      }]];
-    }
-    if (event.type === XSTATE_LOGIC_EFFECT_START) {
-      return [{
-        ...snapshot,
-        effects: {
-          ...snapshot.effects,
-          [event.key]: {
-            status: 'active'
-          }
-        }
-      }, []];
-    }
-    if (event.type === XSTATE_LOGIC_EFFECT_RESOLVE) {
-      return [{
-        ...snapshot,
-        effects: {
-          ...snapshot.effects,
-          [event.key]: {
-            status: 'done',
-            output: event.output
-          }
-        }
-      }, []];
-    }
-    if (event.type === XSTATE_LOGIC_EFFECT_REJECT) {
-      return [{
-        ...snapshot,
-        effects: {
-          ...snapshot.effects,
-          [event.key]: {
-            status: 'error',
-            error: event.error
-          }
-        }
-      }, []];
-    }
-    const effects = [];
-    const trackedEffects = {};
-    const enqueueEffect = (key, exec) => {
-      if (snapshot.effects?.[key]) {
-        return;
-      }
-      effects.push({
-        type: 'effect',
-        key,
-        exec
-      });
-      trackedEffects[key] = {
-        status: 'active'
+      event,
+      delay,
+      id
+    });
+  };
+  const scheduler = {
+    schedule: (source, target, event, delay, id = Math.random().toString(36).slice(2)) => {
+      recordSent(source, target, event, delay, id);
+      const scheduledEvent = {
+        source,
+        target,
+        event,
+        delay,
+        id,
+        startedAt: Date.now()
       };
-    };
-    const enq = {
-      emit: emitted => {
-        effects.push({
-          type: 'emit',
-          event: emitted
-        });
-      },
-      sendBack: sentEvent => {
-        effects.push({
-          type: 'sendBack',
-          event: sentEvent
-        });
-      },
-      raise: raisedEvent => {
-        effects.push({
-          type: 'raise',
-          event: raisedEvent
-        });
-      },
-      effect: (keyOrExec, maybeExec) => {
-        if (typeof keyOrExec === 'string') {
-          enqueueEffect(keyOrExec, maybeExec);
-          return;
+      const scheduledEventId = createScheduledEventId(source, id);
+      system._snapshot._scheduledEvents[scheduledEventId] = scheduledEvent;
+      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);
+      }, delay);
+      timerMap[scheduledEventId] = timeout;
+    },
+    cancel: (source, id) => {
+      const scheduledEventId = createScheduledEventId(source, id);
+      const timeout = timerMap[scheduledEventId];
+      delete timerMap[scheduledEventId];
+      delete system._snapshot._scheduledEvents[scheduledEventId];
+      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);
         }
-        effects.push({
-          type: 'effect',
-          exec: keyOrExec
-        });
       }
-    };
-    const patch = config.run({
-      context: snapshot.context,
-      event,
-      input: snapshot.input,
-      system: actorScope.system,
-      self: actorScope.self,
-      emit: actorScope.emit
-    }, enq);
-    const nextSnapshot = {
-      ...snapshot,
-      ...(patch || {})
-    };
-    if ('context' in snapshot || patch?.context !== undefined) {
-      nextSnapshot.context = patch?.context ?? snapshot.context;
     }
-    if (patch?.effects || Object.keys(trackedEffects).length) {
-      nextSnapshot.effects = {
-        ...snapshot.effects,
-        ...patch?.effects,
-        ...trackedEffects
-      };
+  };
+  // Delivers an event to the target actor. Used by both `_relay` (which also
+  // records the send) and the scheduler's timer (which already recorded it).
+  const deliver = (source, target, event) => {
+    const targetMachine = target.logic;
+    const isInternalEvent = typeof targetMachine?.isInternalEventType === 'function' && targetMachine.isInternalEventType(event.type);
+    if (isInternalEvent && source !== target) {
+      throw new Error(`Internal event "${event.type}" cannot be sent to actor "${target.id}" from outside.`);
     }
-    return [nextSnapshot, effects];
+
+    // remember the last source for unified transition inspect event
+    target._lastSourceRef = source;
+    target._send(event);
   };
-  const logic = {
-    id: config.id,
-    config,
-    transition,
-    start: (snapshot, actorScope) => {
-      const [nextSnapshot, effects] = transition(snapshot, createInitEvent(snapshot.input), actorScope);
-      Object.assign(snapshot, nextSnapshot);
-      executeLogicEffects(effects, actorScope);
+  const sendInspectionEvent = event => {
+    if (!inspectionObservers.size) {
+      return;
+    }
+    const resolvedInspectionEvent = {
+      ...event,
+      rootId: rootActor.sessionId
+    };
+    inspectionObservers.forEach(observer => observer.next?.(resolvedInspectionEvent));
+  };
+  const system = {
+    children,
+    reverseKeyedActors,
+    keyedActors,
+    _snapshot: {
+      _scheduledEvents: (options?.snapshot && options.snapshot.scheduler) ?? {}
     },
-    getInitialSnapshot: (_, input) => {
-      const context = resolveContext(config.context, input);
-      const snapshot = {
-        status: 'active',
-        output: undefined,
-        error: undefined,
-        input
-      };
-      if (context !== undefined) {
-        snapshot.context = context;
+    _bookId: () => `x:${idCounter++}`,
+    _register: (sessionId, actor) => {
+      children.set(sessionId, actor);
+      return sessionId;
+    },
+    _unregister: actor => {
+      children.delete(actor.sessionId);
+      const registryKey = reverseKeyedActors.get(actor);
+      if (registryKey !== undefined) {
+        keyedActors.delete(registryKey);
+        reverseKeyedActors.delete(actor);
       }
+    },
+    get: registryKey => {
+      return keyedActors.get(registryKey);
+    },
+    getAll: () => {
+      return Object.fromEntries(keyedActors.entries());
+    },
+    _set: (registryKey, actor) => {
+      const existing = keyedActors.get(registryKey);
+      if (existing && existing !== actor) {
+        throw new Error(`Actor with registry key '${registryKey}' already exists.`);
+      }
+      keyedActors.set(registryKey, actor);
+      reverseKeyedActors.set(actor, registryKey);
+    },
+    inspect: observerOrFn => {
+      const observer = toObserver(observerOrFn);
+      inspectionObservers.add(observer);
       return {
-        ...snapshot
+        unsubscribe() {
+          inspectionObservers.delete(observer);
+        }
       };
     },
-    getPersistedSnapshot: snapshot => snapshot,
-    restoreSnapshot: snapshot => snapshot
+    _sendInspectionEvent: sendInspectionEvent,
+    _relay: (source, target, event) => {
+      recordSent(source, target, event);
+      deliver(source, target, event);
+    },
+    scheduler,
+    getSnapshot: () => {
+      return {
+        _scheduledEvents: {
+          ...system._snapshot._scheduledEvents
+        }
+      };
+    },
+    start: () => {
+      const scheduledEvents = system._snapshot._scheduledEvents;
+      system._snapshot._scheduledEvents = {};
+      for (const scheduledId in scheduledEvents) {
+        const {
+          source,
+          target,
+          event,
+          delay,
+          id
+        } = scheduledEvents[scheduledId];
+        scheduler.schedule(source, target, event, delay, id);
+      }
+    },
+    _clock: clock,
+    _logger: logger,
+    _timerStrategy: options.timers
   };
-  return logic;
+  return system;
 }
 
 // those are needed to make JSDoc `@link` work properly
@@ -3419,6 +2688,30 @@ const defaultOptions = {
   },
   logger: console.log.bind(console)
 };
+function safeCall(fn, arg) {
+  try {
+    fn?.(arg);
+  } catch (err) {
+    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 [];
+  }
+  const logicEffects = [];
+  for (const effect of effects) {
+    if (isExecutableActionObject(effect)) {
+      actorScope.actionExecutor(effect);
+    } else {
+      logicEffects.push(effect);
+    }
+  }
+  return logicEffects;
+}
 
 /**
  * An Actor is a running process that can receive events, send events and change
@@ -3457,6 +2750,7 @@ class Actor {
     this.logger = void 0;
     /** @internal */
     this._processingStatus = ProcessingStatus.NotStarted;
+    this._forceDeferredActions = false;
     // Actor Ref
     this._parent = void 0;
     /** @internal */
@@ -3472,7 +2766,8 @@ class Actor {
     this._collectedActions = [];
     /** @internal Events relayed to other actors during the in-flight transition. */
     this._collectedSent = [];
-    this.systemId = void 0;
+    this._initialEffects = void 0;
+    this.registryKey = void 0;
     /** The globally unique process ID for this invocation. */
     this.sessionId = void 0;
     /** The system to which this actor belongs. */
@@ -3493,14 +2788,17 @@ class Actor {
       parent,
       syncSnapshot,
       id,
-      systemId,
+      registryKey,
       inspect
     } = resolvedOptions;
-    this.system = parent ? parent.system : createSystem(this, {
+    this.system = parent ? parent.system : resolvedOptions._systemRef?.current ?? createRuntimeSystem(this, {
       clock,
       logger,
       timers: resolvedOptions.timers
     });
+    if (!parent && resolvedOptions._systemRef && !resolvedOptions._systemRef.current) {
+      resolvedOptions._systemRef.current = this.system;
+    }
     if (inspect && !parent) {
       // Always inspect at the system-level
       this.system.inspect(toObserver(inspect));
@@ -3525,35 +2823,18 @@ class Actor {
       system: this.system,
       stopChild: child => {
         if (child._parent !== this) {
-          throw new Error(`Cannot stop child actor ${child.id} of ${this.id} because it is not a child`);
+          throw new Error(`Cannot stop child actor ${child.id} of ${this.id} because it is not a child` );
         }
         child._stop();
       },
       emit: emittedEvent => {
-        const listeners = this.eventListeners.get(emittedEvent.type);
-        const wildcardListener = this.eventListeners.get('*');
-        if (!listeners && !wildcardListener) {
-          return;
-        }
-        if (listeners) {
-          for (const handler of listeners) {
-            try {
-              handler(emittedEvent);
-            } catch (err) {
-              reportUnhandledError(err);
+        for (const listeners of [this.eventListeners.get(emittedEvent.type), this.eventListeners.get('*')]) {
+          if (listeners) {
+            for (const handler of listeners) {
+              safeCall(handler, emittedEvent);
             }
           }
         }
-        if (!wildcardListener) {
-          return;
-        }
-        for (const handler of wildcardListener) {
-          try {
-            handler(emittedEvent);
-          } catch (err) {
-            reportUnhandledError(err);
-          }
-        }
       },
       actionExecutor: action => {
         const exec = () => {
@@ -3574,7 +2855,7 @@ class Actor {
             executingCustomAction = saveExecutingCustomAction;
           }
         };
-        if (this._processingStatus === ProcessingStatus.Running) {
+        if (this._processingStatus === ProcessingStatus.Running && !this._forceDeferredActions) {
           exec();
         } else {
           this._deferred.push(exec);
@@ -3595,15 +2876,12 @@ class Actor {
         };
       }
     });
-
-    // unified '@xstate.transition' event replaces '@xstate.actor'
-
-    if (systemId) {
-      this.systemId = systemId;
-      this.system._set(systemId, this);
+    if (registryKey) {
+      this.registryKey = registryKey;
+      this.system._set(registryKey, this);
     }
 
-    // prepare to collect initial microsteps during getInitialSnapshot
+    // prepare to collect initial microsteps during initialTransition
     this._collectedMicrosteps = [];
     let persistedState = options?.snapshot ?? options?.state;
     if (persistedState && typeof persistedState === 'object' && '_pendingEffects' in persistedState) {
@@ -3617,7 +2895,17 @@ class Actor {
       persistedState = rest;
     }
     try {
-      this._snapshot = persistedState ? this.logic.restoreSnapshot ? this.logic.restoreSnapshot(persistedState, this._actorScope) : persistedState : this.logic.getInitialSnapshot(this._actorScope, this.options?.input);
+      if (persistedState) {
+        this._snapshot = 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;
+        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
@@ -3631,7 +2919,7 @@ class Actor {
       // computation so they can't run against an inconsistent actor
       this._deferred.length = 0;
     }
-    if (systemId && this._snapshot.status !== 'active') {
+    if (registryKey && this._snapshot.status !== 'active') {
       this.system._unregister(this);
     }
 
@@ -3654,13 +2942,35 @@ class Actor {
       error: err
     };
   }
+
+  /** Recover via the logic's error event if possible; otherwise error out. */
+  _recoverOrError(err, snapshot) {
+    if (!this._tryHandleExecutionError(err, snapshot)) {
+      this._setErrorSnapshot(err);
+      this._error(err);
+    }
+  }
+  _tryHandleExecutionError(err, snapshot = this._snapshot) {
+    // Machine logic can recover from execution errors via `onError`
+    // transitions; the logic decides (so the actor stays logic-agnostic).
+    const errorEvent = this.logic.getExecutionErrorEvent?.(snapshot, err);
+    if (!errorEvent) {
+      return false;
+    }
+    try {
+      const [nextSnapshot, effects] = this.logic.transition(snapshot, errorEvent, this._actorScope);
+      this._snapshot = nextSnapshot;
+      const logicEffects = executeExecutableEffects(effects, this._actorScope);
+      this.update(nextSnapshot, errorEvent);
+      this.logic.executeEffects?.(logicEffects, this._actorScope);
+      return true;
+    } catch {
+      return false;
+    }
+  }
   _next(snapshot) {
     for (const observer of this.observers) {
-      try {
-        observer.next?.(snapshot);
-      } catch (err) {
-        reportUnhandledError(err);
-      }
+      safeCall(observer.next, snapshot);
     }
   }
   update(snapshot, event) {
@@ -3679,6 +2989,9 @@ class Actor {
         // no "builtin deferred" should actually throw an error since they are either safe
         // or the control flow is passed through the mailbox and errors should be caught by the `_process` used by the mailbox
         this._deferred.length = 0;
+        if (this._tryHandleExecutionError(err, snapshot)) {
+          return;
+        }
         this._setErrorSnapshot(err, snapshot);
         break;
       }
@@ -3726,6 +3039,25 @@ class Actor {
     this._collectedActions = [];
     this._collectedSent = [];
   }
+  _flushInitialEffects() {
+    if (!this._initialEffects) {
+      return true;
+    }
+    this._forceDeferredActions = true;
+    try {
+      const logicEffects = executeExecutableEffects(this._initialEffects, this._actorScope);
+      this.logic.executeEffects?.(logicEffects, this._actorScope);
+      this._initialEffects = undefined;
+      return true;
+    } catch (err) {
+      this._initialEffects = undefined;
+      this._deferred.length = 0;
+      this._recoverOrError(err);
+      return this._snapshot.status === 'active';
+    } finally {
+      this._forceDeferredActions = false;
+    }
+  }
 
   /**
    * Subscribe an observer to an actor’s snapshot values.
@@ -3794,11 +3126,7 @@ class Actor {
     } else {
       switch (this._snapshot.status) {
         case 'done':
-          try {
-            observer.complete?.();
-          } catch (err) {
-            reportUnhandledError(err);
-          }
+          safeCall(observer.complete);
           break;
         case 'error':
           {
@@ -3806,11 +3134,7 @@ class Actor {
             if (!observer.error) {
               reportUnhandledError(err);
             } else {
-              try {
-                observer.error(err);
-              } catch (err) {
-                reportUnhandledError(err);
-              }
+              safeCall(observer.error, err);
             }
             break;
           }
@@ -3852,7 +3176,7 @@ class Actor {
           complete: observer.complete
         });
       },
-      get: () => selector(this.get())
+      get: () => selector(this.getSnapshot())
     };
   }
 
@@ -3862,6 +3186,9 @@ class Actor {
       // Do not restart the service if it is already started
       return this;
     }
+    if (this._processingStatus === ProcessingStatus.Stopped) {
+      return this;
+    }
     if (this._syncSnapshot) {
       this.subscribe({
         next: snapshot => {
@@ -3876,8 +3203,8 @@ class Actor {
       });
     }
     this.system._register(this.sessionId, this);
-    if (this.systemId) {
-      this.system._set(this.systemId, this);
+    if (this.registryKey) {
+      this.system._set(this.registryKey, this);
     }
     this._processingStatus = ProcessingStatus.Running;
 
@@ -3890,6 +3217,9 @@ 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._flushInitialEffects()) {
+          return this;
+        }
         this.update(this._snapshot, initEvent);
         // TODO: rethink cleanup of observers, mailbox, etc
         return this;
@@ -3909,6 +3239,9 @@ class Actor {
         return this;
       }
     }
+    if (!this._flushInitialEffects()) {
+      return this;
+    }
 
     // TODO: this notifies all subscribers but usually this is redundant
     // there is no real change happening here
@@ -3940,16 +3273,21 @@ class Actor {
       };
     }
     if (caughtError) {
-      const {
-        err
-      } = caughtError;
-      this._setErrorSnapshot(err);
-      this._error(err);
+      this._recoverOrError(caughtError.err);
+      return;
+    }
+    let snapshot = this._snapshot;
+    try {
+      const [nextSnapshot, effects] = nextState;
+      snapshot = nextSnapshot;
+      this._snapshot = snapshot;
+      const logicEffects = executeExecutableEffects(effects, this._actorScope);
+      this.update(snapshot, event);
+      this.logic.executeEffects?.(logicEffects, this._actorScope);
+    } catch (err) {
+      this._recoverOrError(err, snapshot);
       return;
     }
-    const [snapshot, effects] = Array.isArray(nextState) ? nextState : [nextState, undefined];
-    this.update(snapshot, event);
-    executeLogicEffects(effects, this._actorScope);
     if (event.type === XSTATE_STOP) {
       this._stopProcedure();
       this._complete();
@@ -3982,11 +3320,7 @@ class Actor {
   }
   _complete() {
     for (const observer of this.observers) {
-      try {
-        observer.complete?.();
-      } catch (err) {
-        reportUnhandledError(err);
-      }
+      safeCall(observer.complete);
     }
     this.observers.clear();
     this.eventListeners.clear();
@@ -3997,24 +3331,19 @@ class Actor {
       if (!this._parent) {
         reportUnhandledError(err);
       }
-      this.eventListeners.clear();
     } else {
       let reportError = false;
       for (const observer of this.observers) {
         const errorListener = observer.error;
         reportError ||= !errorListener;
-        try {
-          errorListener?.(err);
-        } catch (err2) {
-          reportUnhandledError(err2);
-        }
+        safeCall(errorListener, err);
       }
       this.observers.clear();
-      this.eventListeners.clear();
       if (reportError) {
         reportUnhandledError(err);
       }
     }
+    this.eventListeners.clear();
     if (this._parent) {
       this.system._relay(this, this._parent, createErrorActorEvent(this.id, err));
     }
@@ -4141,15 +3470,9 @@ class Actor {
    * @see {@link Actor.getPersistedSnapshot} to persist the internal state of an actor (which is more than just a snapshot).
    */
   getSnapshot() {
-    return this.get();
-  }
-
-  /** Read the actor's current snapshot as an atom value. */
-  get() {
     if (!this._snapshot) {
       throw new Error(`Snapshot can't be read while the actor initializes itself`);
     }
-    onActorRead?.(this);
     return this._snapshot;
   }
 }
@@ -4210,6 +3533,231 @@ function createActor(logic, options) {
   return new Actor(logic, options);
 }
 
+const effectStates = new WeakMap();
+const XSTATE_LOGIC_EFFECT_RESOLVE = 'xstate.logic.effect.resolve';
+const XSTATE_LOGIC_EFFECT_REJECT = 'xstate.logic.effect.reject';
+const XSTATE_LOGIC_EFFECT_START = 'xstate.logic.effect.start';
+function getEffectState(self) {
+  let state = effectStates.get(self);
+  if (!state) {
+    state = new Map();
+    effectStates.set(self, state);
+  }
+  return state;
+}
+function executeLogicEffects(effects, actorScope) {
+  if (!effects?.length) {
+    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;
+        }
+    }
+  }
+}
+function resolveContext(context, input) {
+  return typeof context === 'function' ? context({
+    input
+  }) : context;
+}
+function createLogic(config) {
+  const transition = (snapshot, event, actorScope) => {
+    if (snapshot.status !== 'active') {
+      return [snapshot, []];
+    }
+    if (event.type === XSTATE_STOP) {
+      return [{
+        ...snapshot,
+        status: 'stopped',
+        input: undefined
+      }, [{
+        type: 'cleanupEffects'
+      }]];
+    }
+    if (event.type === XSTATE_LOGIC_EFFECT_START) {
+      return [{
+        ...snapshot,
+        effects: {
+          ...snapshot.effects,
+          [event.key]: {
+            status: 'active'
+          }
+        }
+      }, []];
+    }
+    if (event.type === XSTATE_LOGIC_EFFECT_RESOLVE) {
+      return [{
+        ...snapshot,
+        effects: {
+          ...snapshot.effects,
+          [event.key]: {
+            status: 'done',
+            output: event.output
+          }
+        }
+      }, []];
+    }
+    if (event.type === XSTATE_LOGIC_EFFECT_REJECT) {
+      return [{
+        ...snapshot,
+        effects: {
+          ...snapshot.effects,
+          [event.key]: {
+            status: 'error',
+            error: event.error
+          }
+        }
+      }, []];
+    }
+    const effects = [];
+    const trackedEffects = {};
+    const enqueueEffect = (key, exec) => {
+      if (snapshot.effects?.[key]) {
+        return;
+      }
+      effects.push({
+        type: 'effect',
+        key,
+        exec
+      });
+      trackedEffects[key] = {
+        status: 'active'
+      };
+    };
+    const enq = {
+      emit: emitted => {
+        effects.push({
+          type: 'emit',
+          event: emitted
+        });
+      },
+      sendBack: sentEvent => {
+        effects.push({
+          type: 'sendBack',
+          event: sentEvent
+        });
+      },
+      raise: raisedEvent => {
+        effects.push({
+          type: 'raise',
+          event: raisedEvent
+        });
+      },
+      effect: (keyOrExec, maybeExec) => {
+        if (typeof keyOrExec === 'string') {
+          enqueueEffect(keyOrExec, maybeExec);
+          return;
+        }
+        effects.push({
+          type: 'effect',
+          exec: keyOrExec
+        });
+      }
+    };
+    const patch = config.run({
+      context: snapshot.context,
+      event,
+      input: snapshot.input,
+      system: actorScope.system,
+      self: actorScope.self,
+      emit: actorScope.emit
+    }, enq);
+    const nextSnapshot = {
+      ...snapshot,
+      ...(patch || {})
+    };
+    if ('context' in snapshot || patch?.context !== undefined) {
+      nextSnapshot.context = patch?.context ?? snapshot.context;
+    }
+    if (patch?.effects || Object.keys(trackedEffects).length) {
+      nextSnapshot.effects = {
+        ...snapshot.effects,
+        ...patch?.effects,
+        ...trackedEffects
+      };
+    }
+    return [nextSnapshot, effects];
+  };
+  const logic = {
+    id: config.id,
+    config,
+    transition,
+    start: (snapshot, actorScope) => {
+      const [nextSnapshot, effects] = transition(snapshot, createInitEvent(snapshot.input), actorScope);
+      Object.assign(snapshot, nextSnapshot);
+      executeLogicEffects(effects, actorScope);
+    },
+    initialTransition: (input, _) => {
+      const context = resolveContext(config.context, input);
+      const snapshot = {
+        status: 'active',
+        output: undefined,
+        error: undefined,
+        input
+      };
+      if (context !== undefined) {
+        snapshot.context = context;
+      }
+      return [{
+        ...snapshot
+      }, []];
+    },
+    getInitialSnapshot: (actorScope, input) => logic.initialTransition(input, actorScope)[0],
+    getPersistedSnapshot: snapshot => snapshot,
+    restoreSnapshot: snapshot => snapshot,
+    executeEffects: executeLogicEffects
+  };
+  return logic;
+}
+
 const instanceStates = /* #__PURE__ */new WeakMap();
 
 /**
@@ -4588,46 +4136,45 @@ function createEventObservableLogic(lazyObservableOrConfig) {
     config: lazyObservable,
     transition: (state, event) => {
       if (state.status !== 'active') {
-        return state;
+        return [state, []];
       }
       switch (event.type) {
         case XSTATE_OBSERVABLE_ERROR:
-          return {
+          return [{
             ...state,
             status: 'error',
             error: event.data,
             input: undefined,
             _subscription: undefined
-          };
+          }, []];
         case XSTATE_OBSERVABLE_COMPLETE:
-          return {
+          return [{
             ...state,
             status: 'done',
             input: undefined,
             _subscription: undefined
-          };
+          }, []];
         case XSTATE_STOP:
           state._subscription.unsubscribe();
-          return {
+          return [{
             ...state,
             status: 'stopped',
             input: undefined,
             _subscription: undefined
-          };
+          }, []];
         default:
-          return state;
+          return [state, []];
       }
     },
-    getInitialSnapshot: (_, input) => {
-      return {
-        status: 'active',
-        output: undefined,
-        error: undefined,
-        context: undefined,
-        input,
-        _subscription: undefined
-      };
-    },
+    initialTransition: (input, _) => [{
+      status: 'active',
+      output: undefined,
+      error: undefined,
+      context: undefined,
+      input,
+      _subscription: undefined
+    }, []],
+    getInitialSnapshot: (actorScope, input) => logic.initialTransition(input, actorScope)[0],
     start: (state, {
       self,
       system,
@@ -4945,4 +4492,4 @@ function createEmptyActor() {
   return createActor(emptyLogic);
 }
 
-export { isStateId as $, Actor as A, createAsyncLogic as B, createListenerLogic as C, listenerLogic as D, createSubscriptionLogic as E, subscriptionLogic as F, resolveReferencedActor as G, mapValues as H, createInvokeId as I, getDelayedTransitions as J, evaluateCandidate as K, formatTransition as L, toTransitionConfigArray as M, NULL_EVENT as N, createInvokeTimeoutEvent as O, ProcessingStatus as P, getCandidates as Q, formatRouteTransitions as R, STATE_DELIMITER as S, TimeoutError as T, resolveStateValue as U, getAllStateNodes as V, createMachineSnapshot as W, isInFinalState as X, transitionNode as Y, resolveAndExecuteActionsWithContext as Z, toStatePath as _, macrostep as a, getStateNodeByPath as a0, getPersistedSnapshot as a1, $$ACTOR_TYPE as a2, XSTATE_INIT as a3, createInitEvent as b, createActor as c, initialMicrostep as d, createAtom as e, createAtomConfig as f, getProperAncestors as g, createAsyncAtom as h, isAtomicStateNode as i, createReducerAtom as j, isAtom as k, isMachineSnapshot as l, matchesEventDescriptor as m, getStateNodes as n, getAllOwnEventDescriptors as o, parseDelayToMilliseconds as p, matchesState as q, checkStateIn as r, pathToStateValue as s, toArray as t, toObserver as u, createEmptyActor as v, createCallbackLogic as w, createObservableLogic as x, createEventObservableLogic as y, createLogic as z };
+export { transitionNode as $, Actor as A, createLogic as B, createAsyncLogic as C, createListenerLogic as D, listenerLogic as E, createSubscriptionLogic as F, subscriptionLogic as G, resolveReferencedActor as H, mapValues as I, createInvokeId as J, getDelayedTransitions as K, evaluateCandidate as L, formatTransition as M, NULL_EVENT as N, toTransitionConfigArray as O, ProcessingStatus as P, createInvokeTimeoutEvent as Q, getCandidates as R, STATE_DELIMITER as S, TimeoutError as T, formatRouteTransitions as U, resolveStateValue as V, getAllStateNodes as W, XSTATE_INIT as X, createMachineSnapshot as Y, isInFinalState as Z, cloneMachineSnapshot as _, XSTATE_STOP as a, getTransitionResult as a0, hasEffect as a1, createErrorPlatformEvent as a2, toStatePath as a3, isStateId as a4, getStateNodeByPath as a5, getPersistedSnapshot as a6, $$ACTOR_TYPE as a7, builtInActions as b, createTransitionEnqueue as c, deriveDeferredStarts as d, createActor as e, macrostep as f, createInitEvent as g, initialMicrostep as h, isAtomicStateNode as i, getProperAncestors as j, isMachineSnapshot as k, getStateNodes as l, matchesEventDescriptor as m, getAllOwnEventDescriptors as n, matchesState as o, parseDelayToMilliseconds as p, checkStateIn as q, resolveActionsWithContext as r, pathToStateValue as s, toArray as t, toObserver as u, isBuiltInExecutableAction as v, createEmptyActor as w, createCallbackLogic as x, createObservableLogic as y, createEventObservableLogic as z };