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

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

@@ -1,18 +1,5 @@
 'use strict';
 
-/**
- * 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;
@@ -66,6 +53,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';
 
 /**
@@ -142,6 +131,12 @@ function createErrorActorEvent(id, error) {
     actorId: id
   };
 }
+function createErrorPlatformEvent(kind, error) {
+  return {
+    type: `xstate.error.${kind}`,
+    error
+  };
+}
 function createInitEvent(input) {
   return {
     type: XSTATE_INIT,
@@ -166,6 +161,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();
   },
@@ -188,7 +186,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);
   }
 };
@@ -200,15 +198,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, {
@@ -251,20 +254,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
   };
@@ -310,620 +309,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()`.
@@ -941,15 +326,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) {
@@ -975,6 +351,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,
@@ -1010,11 +399,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);
@@ -1036,21 +425,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));
       }
     }
@@ -1067,7 +467,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) => {
@@ -1082,77 +482,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);
   };
@@ -1170,7 +668,7 @@ function createEnqueueObject$1(props, action) {
   });
   return enqueueFn;
 }
-const emptyEnqueueObject = createEnqueueObject$1({}, () => {});
+const emptyEnqueueObject = createEnqueueObject({}, () => {});
 
 function parseDurationToMilliseconds(duration) {
   const normalizedDuration = duration.trim();
@@ -1232,6 +730,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';
 }
@@ -1344,22 +845,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;
@@ -1398,61 +886,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),
@@ -1514,30 +1010,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));
@@ -1576,7 +1055,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}"?` );
@@ -1586,6 +1065,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 {
@@ -1627,12 +1114,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;
 }
@@ -1773,6 +1257,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;
@@ -1792,7 +1281,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 [];
   }
@@ -1814,19 +1305,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);
     }
   }
 
@@ -1834,17 +1350,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) {
@@ -1868,16 +1387,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;
@@ -1898,13 +1412,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];
       }
@@ -1940,7 +1454,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);
@@ -1950,7 +1464,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) {
@@ -1975,8 +1491,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);
@@ -1991,17 +1507,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();
@@ -2078,7 +1595,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);
@@ -2094,6 +1613,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);
@@ -2101,14 +1626,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;
           }
         }
       }
@@ -2125,7 +1654,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
@@ -2133,12 +1662,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,
@@ -2147,7 +1677,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) {
@@ -2159,18 +1689,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,
@@ -2182,13 +1717,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;
         }
@@ -2196,14 +1732,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') {
@@ -2213,7 +1749,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;
@@ -2227,8 +1763,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
         });
@@ -2236,7 +1771,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
@@ -2251,7 +1788,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) {
@@ -2259,22 +1796,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];
   }
 }
 
@@ -2282,29 +1819,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,
@@ -2318,11 +1859,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,
@@ -2358,7 +1901,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
@@ -2429,31 +1972,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 {
@@ -2464,16 +1989,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,
@@ -2526,38 +2054,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;
 }
@@ -2565,29 +2077,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);
 };
@@ -2598,24 +2087,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 {
@@ -2746,7 +2221,7 @@ function getPersistedSnapshot(snapshot, options) {
     childrenJson[id] = {
       snapshot: child.getPersistedSnapshot(options),
       src: child.src,
-      systemId: child.systemId,
+      registryKey: child.registryKey,
       syncSnapshot: child._syncSnapshot
     };
   }
@@ -2756,6 +2231,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;
   }
@@ -2891,24 +2369,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 => {
@@ -2946,14 +2438,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)])];
@@ -3006,7 +2498,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();
@@ -3029,373 +2521,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
@@ -3421,6 +2690,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
@@ -3459,6 +2752,7 @@ class Actor {
     this.logger = void 0;
     /** @internal */
     this._processingStatus = ProcessingStatus.NotStarted;
+    this._forceDeferredActions = false;
     // Actor Ref
     this._parent = void 0;
     /** @internal */
@@ -3474,7 +2768,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. */
@@ -3495,14 +2790,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));
@@ -3527,35 +2825,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 = () => {
@@ -3576,7 +2857,7 @@ class Actor {
             executingCustomAction = saveExecutingCustomAction;
           }
         };
-        if (this._processingStatus === ProcessingStatus.Running) {
+        if (this._processingStatus === ProcessingStatus.Running && !this._forceDeferredActions) {
           exec();
         } else {
           this._deferred.push(exec);
@@ -3597,15 +2878,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) {
@@ -3619,7 +2897,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
@@ -3633,7 +2921,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);
     }
 
@@ -3656,13 +2944,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) {
@@ -3681,6 +2991,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;
       }
@@ -3728,6 +3041,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.
@@ -3796,11 +3128,7 @@ class Actor {
     } else {
       switch (this._snapshot.status) {
         case 'done':
-          try {
-            observer.complete?.();
-          } catch (err) {
-            reportUnhandledError(err);
-          }
+          safeCall(observer.complete);
           break;
         case 'error':
           {
@@ -3808,11 +3136,7 @@ class Actor {
             if (!observer.error) {
               reportUnhandledError(err);
             } else {
-              try {
-                observer.error(err);
-              } catch (err) {
-                reportUnhandledError(err);
-              }
+              safeCall(observer.error, err);
             }
             break;
           }
@@ -3854,7 +3178,7 @@ class Actor {
           complete: observer.complete
         });
       },
-      get: () => selector(this.get())
+      get: () => selector(this.getSnapshot())
     };
   }
 
@@ -3864,6 +3188,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 => {
@@ -3878,8 +3205,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;
 
@@ -3892,6 +3219,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;
@@ -3911,6 +3241,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
@@ -3942,16 +3275,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();
@@ -3984,11 +3322,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();
@@ -3999,24 +3333,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));
     }
@@ -4143,15 +3472,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;
   }
 }
@@ -4212,6 +3535,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();
 
 /**
@@ -4590,46 +4138,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,
@@ -4954,14 +4501,15 @@ exports.ProcessingStatus = ProcessingStatus;
 exports.STATE_DELIMITER = STATE_DELIMITER;
 exports.TimeoutError = TimeoutError;
 exports.XSTATE_INIT = XSTATE_INIT;
+exports.XSTATE_STOP = XSTATE_STOP;
+exports.builtInActions = builtInActions;
 exports.checkStateIn = checkStateIn;
+exports.cloneMachineSnapshot = cloneMachineSnapshot;
 exports.createActor = createActor;
-exports.createAsyncAtom = createAsyncAtom;
 exports.createAsyncLogic = createAsyncLogic;
-exports.createAtom = createAtom;
-exports.createAtomConfig = createAtomConfig;
 exports.createCallbackLogic = createCallbackLogic;
 exports.createEmptyActor = createEmptyActor;
+exports.createErrorPlatformEvent = createErrorPlatformEvent;
 exports.createEventObservableLogic = createEventObservableLogic;
 exports.createInitEvent = createInitEvent;
 exports.createInvokeId = createInvokeId;
@@ -4970,8 +4518,9 @@ exports.createListenerLogic = createListenerLogic;
 exports.createLogic = createLogic;
 exports.createMachineSnapshot = createMachineSnapshot;
 exports.createObservableLogic = createObservableLogic;
-exports.createReducerAtom = createReducerAtom;
 exports.createSubscriptionLogic = createSubscriptionLogic;
+exports.createTransitionEnqueue = createTransitionEnqueue;
+exports.deriveDeferredStarts = deriveDeferredStarts;
 exports.evaluateCandidate = evaluateCandidate;
 exports.formatRouteTransitions = formatRouteTransitions;
 exports.formatTransition = formatTransition;
@@ -4983,9 +4532,11 @@ exports.getPersistedSnapshot = getPersistedSnapshot;
 exports.getProperAncestors = getProperAncestors;
 exports.getStateNodeByPath = getStateNodeByPath;
 exports.getStateNodes = getStateNodes;
+exports.getTransitionResult = getTransitionResult;
+exports.hasEffect = hasEffect;
 exports.initialMicrostep = initialMicrostep;
-exports.isAtom = isAtom;
 exports.isAtomicStateNode = isAtomicStateNode;
+exports.isBuiltInExecutableAction = isBuiltInExecutableAction;
 exports.isInFinalState = isInFinalState;
 exports.isMachineSnapshot = isMachineSnapshot;
 exports.isStateId = isStateId;
@@ -4996,7 +4547,7 @@ exports.matchesEventDescriptor = matchesEventDescriptor;
 exports.matchesState = matchesState;
 exports.parseDelayToMilliseconds = parseDelayToMilliseconds;
 exports.pathToStateValue = pathToStateValue;
-exports.resolveAndExecuteActionsWithContext = resolveAndExecuteActionsWithContext;
+exports.resolveActionsWithContext = resolveActionsWithContext;
 exports.resolveReferencedActor = resolveReferencedActor;
 exports.resolveStateValue = resolveStateValue;
 exports.subscriptionLogic = subscriptionLogic;