xstate 6.0.0-alpha.2 → 6.0.0-alpha.4

package/dist/{index-f6ef20d1.development.cjs.js → index-ebaf6fd8.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;
@@ -188,7 +175,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 +187,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 +243,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 +298,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 +315,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) {
@@ -1050,7 +415,7 @@ function createTransitionEnqueue(actorScope, actions, internalEvents, actorSubsc
     },
     stop: actor => {
       if (actor) {
-        pushBuiltInAction(actions, builtInActions['@xstate.stopChild'], actorScope, actor);
+        pushBuiltInAction(actions, builtInActions['@xstate.stop'], actorScope, actor);
         actions.push(unregisterChild(actor));
       }
     }
@@ -1091,16 +456,65 @@ function createTransitionEnqueue(actorScope, actions, internalEvents, actorSubsc
     pushBuiltInAction(actions, action, ...args);
   });
 }
-function resolveAndExecuteActionsWithContext(currentSnapshot, event, actorScope, actions) {
+function getBuiltInActionFields(action, args) {
+  switch (action) {
+    case builtInActions['@xstate.start']:
+      {
+        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 isBuiltInExecutableAction(action) {
+  return Object.prototype.hasOwnProperty.call(builtInActions, action.type);
+}
+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;
-    if (!resolvedAction && typeof action === 'object' && action !== null) {
-      actorScope.defer(() => {
-        actorScope.emit(action);
-      });
-    }
     const actionArgs = {
       context: intermediateSnapshot.context,
       event,
@@ -1120,7 +534,7 @@ function resolveAndExecuteActionsWithContext(currentSnapshot, event, actorScope,
       actionParams = emittedEventParams;
     }
     if (resolvedAction && '_special' in resolvedAction) {
-      actorScope.actionExecutor({
+      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: [],
@@ -1141,16 +555,18 @@ function resolveAndExecuteActionsWithContext(currentSnapshot, event, actorScope,
       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;
+      executableActions.push({
         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
       });
       continue;
     }
   }
-  return intermediateSnapshot;
+  return [intermediateSnapshot, executableActions];
 }
 function createEnqueueObject$1(props, action) {
   const enqueueFn = (fn, ...args) => {
@@ -1344,22 +760,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 +801,68 @@ 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
     }));
-    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),
@@ -1517,27 +927,13 @@ function formatRouteTransitions(rootStateNode) {
         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));
@@ -1868,16 +1264,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;
@@ -1950,7 +1341,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) {
@@ -2185,7 +1578,10 @@ function microstep(transitions, currentSnapshot, actorScope, event, isInitial, i
             }
           }
         }
-        nextState = resolveAndExecuteActionsWithContext(nextState, event, actorScope, actions);
+        const [resolvedState, resolvedActions] = resolveActionsWithContext(nextState, event, actorScope, actions);
+        nextState = resolvedState;
+        actions.length = 0;
+        executableActions.push(...resolvedActions);
         if (context) {
           nextState.context = context;
         }
@@ -2236,7 +1632,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
@@ -2259,22 +1657,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];
   }
 }
 
@@ -2535,24 +1933,7 @@ function evaluateCandidate(candidate, event, snapshot, stateNode, self) {
       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;
     }
   }
@@ -3377,7 +2758,7 @@ function createLogic(config) {
       Object.assign(snapshot, nextSnapshot);
       executeLogicEffects(effects, actorScope);
     },
-    getInitialSnapshot: (_, input) => {
+    initialTransition: (input, _) => {
       const context = resolveContext(config.context, input);
       const snapshot = {
         status: 'active',
@@ -3388,10 +2769,11 @@ function createLogic(config) {
       if (context !== undefined) {
         snapshot.context = context;
       }
-      return {
+      return [{
         ...snapshot
-      };
+      }, []];
     },
+    getInitialSnapshot: (actorScope, input) => logic.initialTransition(input, actorScope)[0],
     getPersistedSnapshot: snapshot => snapshot,
     restoreSnapshot: snapshot => snapshot
   };
@@ -3421,6 +2803,23 @@ const defaultOptions = {
   },
   logger: console.log.bind(console)
 };
+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 +2858,7 @@ class Actor {
     this.logger = void 0;
     /** @internal */
     this._processingStatus = ProcessingStatus.NotStarted;
+    this._forceDeferredActions = false;
     // Actor Ref
     this._parent = void 0;
     /** @internal */
@@ -3474,6 +2874,7 @@ class Actor {
     this._collectedActions = [];
     /** @internal Events relayed to other actors during the in-flight transition. */
     this._collectedSent = [];
+    this._initialEffects = void 0;
     this.systemId = void 0;
     /** The globally unique process ID for this invocation. */
     this.sessionId = void 0;
@@ -3576,7 +2977,7 @@ class Actor {
             executingCustomAction = saveExecutingCustomAction;
           }
         };
-        if (this._processingStatus === ProcessingStatus.Running) {
+        if (this._processingStatus === ProcessingStatus.Running && !this._forceDeferredActions) {
           exec();
         } else {
           this._deferred.push(exec);
@@ -3605,7 +3006,7 @@ class Actor {
       this.system._set(systemId, 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 +3020,13 @@ 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 {
+        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
@@ -3728,6 +3135,26 @@ class Actor {
     this._collectedActions = [];
     this._collectedSent = [];
   }
+  _flushInitialEffects() {
+    if (!this._initialEffects) {
+      return true;
+    }
+    this._forceDeferredActions = true;
+    try {
+      const logicEffects = executeExecutableEffects(this._initialEffects, this._actorScope);
+      executeLogicEffects(logicEffects, this._actorScope);
+      this._initialEffects = undefined;
+      return true;
+    } catch (err) {
+      this._initialEffects = undefined;
+      this._deferred.length = 0;
+      this._setErrorSnapshot(err);
+      this._error(err);
+      return false;
+    } finally {
+      this._forceDeferredActions = false;
+    }
+  }
 
   /**
    * Subscribe an observer to an actor’s snapshot values.
@@ -3854,7 +3281,7 @@ class Actor {
           complete: observer.complete
         });
       },
-      get: () => selector(this.get())
+      get: () => selector(this.getSnapshot())
     };
   }
 
@@ -3892,6 +3319,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 +3341,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
@@ -3949,9 +3382,16 @@ class Actor {
       this._error(err);
       return;
     }
-    const [snapshot, effects] = Array.isArray(nextState) ? nextState : [nextState, undefined];
-    this.update(snapshot, event);
-    executeLogicEffects(effects, this._actorScope);
+    try {
+      const [snapshot, effects] = nextState;
+      const logicEffects = executeExecutableEffects(effects, this._actorScope);
+      this.update(snapshot, event);
+      executeLogicEffects(logicEffects, this._actorScope);
+    } catch (err) {
+      this._setErrorSnapshot(err);
+      this._error(err);
+      return;
+    }
     if (event.type === XSTATE_STOP) {
       this._stopProcedure();
       this._complete();
@@ -4143,15 +3583,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;
   }
 }
@@ -4590,46 +4024,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,
@@ -4956,10 +4389,7 @@ exports.TimeoutError = TimeoutError;
 exports.XSTATE_INIT = XSTATE_INIT;
 exports.checkStateIn = checkStateIn;
 exports.createActor = createActor;
-exports.createAsyncAtom = createAsyncAtom;
 exports.createAsyncLogic = createAsyncLogic;
-exports.createAtom = createAtom;
-exports.createAtomConfig = createAtomConfig;
 exports.createCallbackLogic = createCallbackLogic;
 exports.createEmptyActor = createEmptyActor;
 exports.createEventObservableLogic = createEventObservableLogic;
@@ -4970,7 +4400,6 @@ exports.createListenerLogic = createListenerLogic;
 exports.createLogic = createLogic;
 exports.createMachineSnapshot = createMachineSnapshot;
 exports.createObservableLogic = createObservableLogic;
-exports.createReducerAtom = createReducerAtom;
 exports.createSubscriptionLogic = createSubscriptionLogic;
 exports.evaluateCandidate = evaluateCandidate;
 exports.formatRouteTransitions = formatRouteTransitions;
@@ -4984,8 +4413,8 @@ exports.getProperAncestors = getProperAncestors;
 exports.getStateNodeByPath = getStateNodeByPath;
 exports.getStateNodes = getStateNodes;
 exports.initialMicrostep = initialMicrostep;
-exports.isAtom = isAtom;
 exports.isAtomicStateNode = isAtomicStateNode;
+exports.isBuiltInExecutableAction = isBuiltInExecutableAction;
 exports.isInFinalState = isInFinalState;
 exports.isMachineSnapshot = isMachineSnapshot;
 exports.isStateId = isStateId;
@@ -4996,7 +4425,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;