xstate 5.32.1 → 6.0.0-alpha.2

package/dist/index-9cb3b3a0.cjs.js

@@ -0,0 +1,4968 @@
+'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;
+    this._active = false;
+    this._current = null;
+    this._last = null;
+  }
+  start() {
+    this._active = true;
+    this.flush();
+  }
+  clear() {
+    // we can't set _current to null because we might be currently processing
+    // and enqueue following clear shouldn't start processing the enqueued item immediately
+    if (this._current) {
+      this._current.next = null;
+      this._last = this._current;
+    }
+  }
+  enqueue(event) {
+    const enqueued = {
+      value: event,
+      next: null
+    };
+    if (this._current) {
+      this._last.next = enqueued;
+      this._last = enqueued;
+      return;
+    }
+    this._current = enqueued;
+    this._last = enqueued;
+    if (this._active) {
+      this.flush();
+    }
+  }
+  flush() {
+    while (this._current) {
+      // atm the given _process is responsible for implementing proper try/catch handling
+      // we assume here that this won't throw in a way that can affect this mailbox
+      const consumed = this._current;
+      this._process(consumed.value);
+      this._current = consumed.next;
+    }
+    this._last = null;
+  }
+}
+
+const STATE_DELIMITER = '.';
+const TARGETLESS_KEY = '';
+const NULL_EVENT = '';
+const STATE_IDENTIFIER = '#';
+const WILDCARD = '*';
+const XSTATE_INIT = '@xstate.init';
+const XSTATE_STOP = '@xstate.stop';
+
+/**
+ * Returns an event that represents an implicit event that is sent after the
+ * specified `delay`.
+ *
+ * @param delayRef The delay in milliseconds
+ * @param id The state node ID where this event is handled
+ */
+function createAfterEvent(delayRef, id) {
+  return {
+    type: `xstate.after.${delayRef}.${id}`
+  };
+}
+
+/**
+ * Returns an event that represents an implicit state-level timeout. Fired when
+ * a state's `timeout` duration elapses without the state being exited.
+ *
+ * @param id The state node ID where this timeout is configured
+ */
+function createTimeoutEvent(id) {
+  return {
+    type: `xstate.timeout.${id}`
+  };
+}
+
+/**
+ * Returns an event that represents an implicit invoke-level timeout. Fired when
+ * an invoked actor has not completed within its `timeout` duration.
+ *
+ * @param invokeId The invoked actor's ID
+ */
+function createInvokeTimeoutEvent(invokeId) {
+  return {
+    type: `xstate.timeout.actor.${invokeId}`
+  };
+}
+
+/**
+ * Returns an event that represents that a final state node has been reached in
+ * the parent state node.
+ *
+ * @param id The final state node's parent state node `id`
+ * @param output The data to pass into the event
+ */
+function createDoneStateEvent(id, output) {
+  return {
+    type: `xstate.done.state.${id}`,
+    output
+  };
+}
+
+/**
+ * Returns an event that represents that an invoked service has terminated.
+ *
+ * An invoked service is terminated when it has reached a top-level final state
+ * node, but not when it is canceled.
+ *
+ * @param invokeId The invoked service ID
+ * @param output The data to pass into the event
+ */
+function createDoneActorEvent(invokeId, output) {
+  return {
+    type: `xstate.done.actor.${invokeId}`,
+    output,
+    actorId: invokeId
+  };
+}
+function createErrorActorEvent(id, error) {
+  return {
+    type: `xstate.error.actor.${id}`,
+    error,
+    actorId: id
+  };
+}
+function createInitEvent(input) {
+  return {
+    type: XSTATE_INIT,
+    input
+  };
+}
+
+/**
+ * This function makes sure that unhandled errors are thrown in a separate
+ * macrotask. It allows those errors to be detected by global error handlers and
+ * reported to bug tracking services without interrupting our own stack of
+ * execution.
+ *
+ * @param err Error to be thrown
+ */
+function reportUnhandledError(err) {
+  setTimeout(() => {
+    throw err;
+  });
+}
+
+const symbolObservable = (() => typeof Symbol === 'function' && Symbol.observable || '@@observable')();
+
+const builtInActions = {
+  ['@xstate.start']: actor => {
+    actor.start();
+  },
+  ['@xstate.raise']: (actorScope, event, options) => {
+    actorScope.system.scheduler.schedule(actorScope.self, actorScope.self, event, options?.delay ?? 0, options?.id);
+  },
+  ['@xstate.sendTo']: (actorScope, actor, event, options) => {
+    if (typeof event === 'string') {
+      throw new Error(`Only event objects may be used with sendTo`);
+    }
+    if (options?.delay !== undefined) {
+      actorScope.system.scheduler.schedule(actorScope.self, actor, event, options?.delay ?? 0, options?.id);
+    } else {
+      actorScope.defer(() => {
+        actorScope.system._relay(actorScope.self, actor, event);
+      });
+    }
+  },
+  ['@xstate.cancel']: (actorScope, sendId) => {
+    actorScope.system.scheduler.cancel(actorScope.self, sendId);
+  },
+  ['@xstate.stopChild']: (actorScope, actor) => {
+    actorScope.stopChild(actor);
+  }
+};
+
+const subscriptions = /* #__PURE__ */new WeakMap();
+
+/**
+ * Internal factory for actor logic that attaches to another actor on start
+ * (`enq.listen()` / `enq.subscribeTo()`) and detaches when stopped.
+ */
+function createAttachedLogic(attach) {
+  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.
+      const target = state.input.actor;
+      if (!target || typeof target.getSnapshot === 'function' && target.getSnapshot().status === 'stopped') {
+        return;
+      }
+      const subscription = attach(state.input, {
+        self,
+        system
+      });
+      if (!subscription) {
+        return;
+      }
+
+      // Attached actors are not registered as children (their `input` holds
+      // non-serializable function mappers), so a parent stop does not cascade
+      // to them. Subscribe to the parent and tear down when it stops/errors,
+      // so the subscription never relays to a stopped parent or leaks the
+      // source subscription.
+      let parentSubscription;
+      let torndown = false;
+      const teardown = () => {
+        if (torndown) {
+          return;
+        }
+        torndown = true;
+        subscription.unsubscribe();
+        parentSubscription?.unsubscribe();
+      };
+      const parent = self._parent;
+      if (parent) {
+        parentSubscription = parent.subscribe({
+          complete: teardown,
+          error: teardown
+        });
+      }
+      subscriptions.set(self, {
+        unsubscribe: teardown
+      });
+    },
+    transition: (state, event, {
+      self
+    }) => {
+      if (event.type === XSTATE_STOP) {
+        subscriptions.get(self)?.unsubscribe();
+        subscriptions.delete(self);
+        return {
+          ...state,
+          status: 'stopped',
+          error: undefined
+        };
+      }
+      return state;
+    },
+    getInitialSnapshot: (_, input) => ({
+      status: 'active',
+      output: undefined,
+      error: undefined,
+      input
+    }),
+    getPersistedSnapshot: snapshot => snapshot,
+    restoreSnapshot: snapshot => snapshot
+  };
+}
+
+/**
+ * Relays a mapped event to the attached actor's parent, unless the attached
+ * actor has been stopped (the mapper is not called in that case).
+ */
+function relayMappedToParent(self, system, getEvent) {
+  if (self.getSnapshot().status === 'stopped' || !self._parent) {
+    return;
+  }
+  system._relay(self, self._parent, getEvent());
+}
+
+/**
+ * Creates actor logic for listening to emitted events from another actor. Used
+ * internally by `enq.listen()`.
+ */
+function createListenerLogic() {
+  return createAttachedLogic(({
+    actor,
+    eventType,
+    mapper
+  }, {
+    self,
+    system
+  }) => {
+    // Determine the subscription type:
+    // - For exact matches or '*', subscribe directly
+    // - For partial wildcards ('data.*'), subscribe to '*' and filter
+    const isPartialWildcard = eventType !== '*' && eventType.endsWith('.*');
+    return actor.on(isPartialWildcard ? '*' : eventType, emittedEvent => {
+      if (isPartialWildcard && !matchesEventDescriptor(emittedEvent.type, eventType)) {
+        return;
+      }
+      relayMappedToParent(self, system, () => mapper(emittedEvent));
+    });
+  });
+}
+
+// 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()`.
+ */
+function createSubscriptionLogic() {
+  return createAttachedLogic(({
+    actor,
+    mappers
+  }, {
+    self,
+    system
+  }) => {
+    const {
+      done,
+      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) {
+          relayMappedToParent(self, system, () => done(snapshot.output));
+        } else if (snapshot.status === 'error' && error) {
+          relayMappedToParent(self, system, () => error(snapshot.error));
+        } else if (snapshot.status === 'active' && onSnapshot) {
+          relayMappedToParent(self, system, () => onSnapshot(snapshot));
+        }
+      },
+      error: err => {
+        if (error) {
+          relayMappedToParent(self, system, () => error(err));
+        }
+      },
+      complete: () => {
+        // Actor completed without output (stopped); no action needed
+      }
+    });
+  });
+}
+
+// Singleton logic instance
+const subscriptionLogic = /* #__PURE__ */createSubscriptionLogic();
+
+function pushBuiltInAction(actions, action, ...args) {
+  actions.push({
+    action,
+    args
+  });
+}
+function registerSpawnedChild(actor, id) {
+  return Object.assign(function registerChild(args) {
+    return {
+      children: {
+        ...args.children,
+        [id]: actor
+      }
+    };
+  }, {
+    _special: true
+  });
+}
+function unregisterChild(actor) {
+  return Object.assign(function removeChild(args) {
+    const children = {
+      ...args.children
+    };
+    for (const key of Object.keys(children)) {
+      if (children[key] === actor) {
+        delete children[key];
+      }
+    }
+    return {
+      children
+    };
+  }, {
+    _special: true
+  });
+}
+function pushStartedChild(actions, actor, id) {
+  pushBuiltInAction(actions, builtInActions['@xstate.start'], actor);
+  actions.push(registerSpawnedChild(actor, id ?? actor.id));
+}
+function createTransitionEnqueue(actorScope, actions, internalEvents, actorSubscriptions = false) {
+  const props = {
+    cancel: id => {
+      pushBuiltInAction(actions, builtInActions['@xstate.cancel'], actorScope, id);
+    },
+    emit: emittedEvent => {
+      actions.push(emittedEvent);
+    },
+    log: (...args) => {
+      pushBuiltInAction(actions, actorScope.logger, ...args);
+    },
+    raise: (raisedEvent, options) => {
+      if (typeof raisedEvent === 'string') {
+        throw new Error(`Only event objects may be used with raise`);
+      }
+      if (options?.delay !== undefined) {
+        pushBuiltInAction(actions, builtInActions['@xstate.raise'], actorScope, raisedEvent, options);
+      } else {
+        internalEvents.push(raisedEvent);
+      }
+    },
+    spawn: (logic, options) => {
+      const actor = createActor(logic, {
+        ...options,
+        parent: actorScope.self
+      });
+      pushStartedChild(actions, actor, options?.id);
+      return actor;
+    },
+    sendTo: (actor, event, options) => {
+      if (actor) {
+        pushBuiltInAction(actions, builtInActions['@xstate.sendTo'], actorScope, actor, event, options);
+      }
+    },
+    stop: actor => {
+      if (actor) {
+        pushBuiltInAction(actions, builtInActions['@xstate.stopChild'], actorScope, actor);
+        actions.push(unregisterChild(actor));
+      }
+    }
+  };
+  if (actorSubscriptions) {
+    Object.assign(props, {
+      listen: (actor, eventType, mapper) => {
+        const input = {
+          actor,
+          eventType,
+          mapper
+        };
+        const listenerActor = createActor(listenerLogic, {
+          input,
+          parent: actorScope.self
+        });
+        pushBuiltInAction(actions, builtInActions['@xstate.start'], listenerActor);
+        return listenerActor;
+      },
+      subscribeTo: (actor, mappers) => {
+        const normalizedMappers = typeof mappers === 'function' ? {
+          snapshot: mappers
+        } : mappers;
+        const input = {
+          actor,
+          mappers: normalizedMappers
+        };
+        const subscriptionActor = createActor(subscriptionLogic, {
+          input,
+          parent: actorScope.self
+        });
+        pushBuiltInAction(actions, builtInActions['@xstate.start'], subscriptionActor);
+        return subscriptionActor;
+      }
+    });
+  }
+  return createEnqueueObject$1(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
+          } : {})
+        });
+      }
+      continue;
+    }
+    if (!resolvedAction || !('resolve' in resolvedAction)) {
+      actorScope.actionExecutor({
+        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
+      });
+      continue;
+    }
+  }
+  return intermediateSnapshot;
+}
+function createEnqueueObject$1(props, action) {
+  const enqueueFn = (fn, ...args) => {
+    action(fn, ...args);
+  };
+  Object.assign(enqueueFn, {
+    cancel: () => {},
+    emit: () => {},
+    log: () => {},
+    raise: () => {},
+    spawn: () => ({}),
+    sendTo: () => {},
+    stop: () => {},
+    listen: () => ({}),
+    subscribeTo: () => ({}),
+    ...props
+  });
+  return enqueueFn;
+}
+const emptyEnqueueObject = createEnqueueObject$1({}, () => {});
+
+function parseDurationToMilliseconds(duration) {
+  const normalizedDuration = duration.trim();
+  const millisecondsMatch = normalizedDuration.match(/^(\d+)ms$/i);
+  if (millisecondsMatch) {
+    return parseInt(millisecondsMatch[1], 10);
+  }
+  const secondsMatch = normalizedDuration.match(/^(\d*)(\.?)(\d*)s$/i);
+  if (secondsMatch) {
+    const wholePart = secondsMatch[1] ? parseInt(secondsMatch[1], 10) : 0;
+    const hasDecimal = !!secondsMatch[2];
+    const fracPart = secondsMatch[3] ? parseInt(secondsMatch[3].padEnd(3, '0').slice(0, 3), 10) : 0;
+    return wholePart * 1000 + (hasDecimal ? fracPart : 0);
+  }
+  const iso8601DurationMatch = normalizedDuration.match(/^P(?:(?<weeks>\d+(?:[.,]\d+)?)W)?(?:(?<days>\d+(?:[.,]\d+)?)D)?(?:T(?:(?<hours>\d+(?:[.,]\d+)?)H)?(?:(?<minutes>\d+(?:[.,]\d+)?)M)?(?:(?<seconds>\d+(?:[.,]\d+)?)S)?)?$/i);
+  if (!iso8601DurationMatch?.groups) {
+    return undefined;
+  }
+  const {
+    weeks,
+    days,
+    hours,
+    minutes,
+    seconds
+  } = iso8601DurationMatch.groups;
+  if (!weeks && !days && !hours && !minutes && !seconds) {
+    return undefined;
+  }
+  const toNumber = value => value ? Number(value.replace(',', '.')) : 0;
+  return toNumber(weeks) * 7 * 24 * 60 * 60 * 1000 + toNumber(days) * 24 * 60 * 60 * 1000 + toNumber(hours) * 60 * 60 * 1000 + toNumber(minutes) * 60 * 1000 + toNumber(seconds) * 1000;
+}
+function parseDelayToMilliseconds(delay) {
+  if (delay === undefined) {
+    return undefined;
+  }
+  if (typeof delay === 'number') {
+    return delay;
+  }
+  return parseDurationToMilliseconds(delay);
+}
+
+function getConfiguredDelayValue(delay, delaySource) {
+  if (typeof delay !== 'string') {
+    return delay;
+  }
+  const referencedDelay = delaySource[delay];
+  if (referencedDelay !== undefined) {
+    return referencedDelay;
+  }
+  return parseDurationToMilliseconds(delay) ?? delay;
+}
+function resolveDelay(delay, delaySource, args) {
+  if (typeof delay === 'function') {
+    return delay(args);
+  }
+  const configuredDelay = getConfiguredDelayValue(delay, delaySource);
+  if (typeof configuredDelay === 'function') {
+    return configuredDelay(args);
+  }
+  return configuredDelay;
+}
+function isAtomicStateNode(stateNode) {
+  return stateNode.type === 'atomic' || stateNode.type === 'final' || stateNode.type === 'choice';
+}
+function getChildren(stateNode) {
+  return Object.values(stateNode.states).filter(sn => sn.type !== 'history');
+}
+function getProperAncestors(stateNode, toStateNode) {
+  const ancestors = [];
+  if (toStateNode === stateNode) {
+    return ancestors;
+  }
+
+  // add all ancestors
+  let m = stateNode.parent;
+  while (m && m !== toStateNode) {
+    ancestors.push(m);
+    m = m.parent;
+  }
+  return ancestors;
+}
+function getAllStateNodes(stateNodes) {
+  const nodeSet = new Set(stateNodes);
+  const activeParentSet = new Set();
+  for (const stateNode of nodeSet) {
+    if (stateNode.parent) {
+      activeParentSet.add(stateNode.parent);
+    }
+  }
+
+  // add descendants
+  for (const s of nodeSet) {
+    // if previously active, add existing child nodes
+    if (s.type === 'compound' && !activeParentSet.has(s)) {
+      for (const sn of getInitialStateNodes(s)) {
+        nodeSet.add(sn);
+      }
+      continue;
+    }
+    if (s.type === 'parallel') {
+      for (const child of getChildren(s)) {
+        if (!nodeSet.has(child)) {
+          const initialStates = getInitialStateNodes(child);
+          for (const initialStateNode of initialStates) {
+            nodeSet.add(initialStateNode);
+          }
+        }
+      }
+    }
+  }
+
+  // add all ancestors
+  // Stop walking up as soon as we hit a node already in the set: its own
+  // ancestor chain is guaranteed to be added when it is visited by this loop
+  // (Set iteration visits elements added during iteration), so shared ancestor
+  // chains are never re-walked once per descendant.
+  for (const s of nodeSet) {
+    let m = s.parent;
+    while (m && !nodeSet.has(m)) {
+      nodeSet.add(m);
+      m = m.parent;
+    }
+  }
+  return nodeSet;
+}
+function getStateValue(rootNode, stateNodes) {
+  const config = getAllStateNodes(stateNodes);
+  const adjList = new Map();
+  for (const s of config) {
+    if (!adjList.has(s)) {
+      adjList.set(s, []);
+    }
+    if (!s.parent) {
+      continue;
+    }
+    if (!adjList.has(s.parent)) {
+      adjList.set(s.parent, []);
+    }
+    adjList.get(s.parent).push(s);
+  }
+  const getValueFromAdj = baseNode => {
+    const childStateNodes = adjList.get(baseNode);
+    if (!childStateNodes) {
+      return {}; // todo: fix?
+    }
+    if (baseNode.type === 'compound') {
+      const childStateNode = childStateNodes[0];
+      if (!childStateNode) {
+        return {};
+      }
+      if (isAtomicStateNode(childStateNode)) {
+        return childStateNode.key;
+      }
+    }
+    const stateValue = {};
+    for (const childStateNode of childStateNodes) {
+      stateValue[childStateNode.key] = getValueFromAdj(childStateNode);
+    }
+    return stateValue;
+  };
+  return getValueFromAdj(rootNode);
+}
+function isInFinalState(stateNodeSet, stateNode) {
+  if (stateNode.type === 'compound') {
+    return getChildren(stateNode).some(s => s.type === 'final' && stateNodeSet.has(s));
+  }
+  if (stateNode.type === 'parallel') {
+    return getChildren(stateNode).every(sn => isInFinalState(stateNodeSet, sn));
+  }
+  return stateNode.type === 'final';
+}
+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;
+}
+function scheduleDelayedEvent(stateNode, event, resolveScheduledDelay) {
+  const eventType = event.type;
+  const oldEntry = stateNode.entry;
+  stateNode.entry = (x, enq) => {
+    enq.raise(event, {
+      id: eventType,
+      delay: resolveScheduledDelay(x)
+    });
+    return typeof oldEntry === 'function' ? oldEntry(x, enq) : undefined;
+  };
+  const oldExit = stateNode.exit;
+  stateNode.exit = (_, enq) => {
+    enq.cancel(eventType);
+    return typeof oldExit === 'function' ? oldExit(_, enq) : undefined;
+  };
+  return eventType;
+}
+
+/** All delayed transitions from the config. */
+function getDelayedTransitions(stateNode) {
+  const afterConfig = stateNode.config.after;
+  const timeoutConfig = stateNode.config.timeout;
+  const onTimeoutConfig = stateNode.config.onTimeout;
+  const invokeDefs = stateNode.invoke.filter(invokeDef => invokeDef.timeout !== undefined);
+  if (!afterConfig && timeoutConfig === undefined && invokeDefs.length === 0) {
+    return [];
+  }
+  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
+      });
+    }
+  };
+  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);
+    }
+  }
+
+  // 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);
+  }
+
+  // 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, {}, {
+      context: x.context,
+      event: x.event,
+      stateNode
+    }));
+    const invokeOnTimeout = invokeDef.onTimeout;
+    addDelayedTransitions(invokeOnTimeout, invokeTimeoutEventType, invokeTimeout);
+  }
+  return delayedTransitions.map(delayedTransition => ({
+    ...formatTransition(stateNode, delayedTransition.event, delayedTransition),
+    delay: delayedTransition.delay
+  }));
+}
+function formatTransition(stateNode, descriptor, transitionConfig) {
+  const normalizedTarget = normalizeTarget(transitionConfig.target);
+  const reenter = transitionConfig.reenter ?? false;
+  const target = resolveTarget(stateNode, normalizedTarget);
+  const transition = {
+    ...transitionConfig,
+    target,
+    source: stateNode,
+    reenter,
+    eventType: descriptor,
+    toJSON: () => ({
+      ...transition,
+      source: `#${stateNode.id}`,
+      target: target ? target.map(t => `#${t.id}`) : undefined
+    })
+  };
+  return transition;
+}
+
+/**
+ * Collects route transitions from all descendants with explicit IDs. Called
+ * once on the root node to avoid O(N²) repeated traversals.
+ */
+function formatRouteTransitions(rootStateNode) {
+  const routeTransitions = [];
+  const collectRoutes = states => {
+    Object.values(states).forEach(sn => {
+      if (sn.config.route && sn.config.id) {
+        const routeId = sn.config.id;
+        const routeConfig = sn.config.route;
+        const routeMatches = ({
+          event
+        }) => event.to === `#${routeId}`;
+        if (typeof routeConfig === 'function') {
+          // Transition-style route: the function is the guard and resolver.
+          // Returning undefined/false blocks the route; returning true or a
+          // config object allows it.
+          routeTransitions.push(formatTransition(rootStateNode, 'xstate.route', {
+            guard: routeMatches,
+            to: args => {
+              const result = routeConfig(args);
+              if (!result) {
+                return undefined;
+              }
+              return {
+                ...(result === true ? {} : result),
+                target: `#${routeId}`
+              };
+            }
+          }));
+          if (sn.states) {
+            collectRoutes(sn.states);
+          }
+          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 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}'.`);
+              }
+              return guardImpl(args);
+            }
+            return true;
+          } : routeMatches,
+          target: `#${routeId}`
+        };
+        routeTransitions.push(formatTransition(rootStateNode, 'xstate.route', transition));
+      }
+      if (sn.states) {
+        collectRoutes(sn.states);
+      }
+    });
+  };
+  collectRoutes(rootStateNode.states);
+  if (routeTransitions.length > 0) {
+    rootStateNode.transitions.set('xstate.route', routeTransitions);
+  }
+}
+function resolveTarget(stateNode, targets) {
+  if (targets === undefined) {
+    // an undefined target signals that the state node should not transition from that state when receiving that event
+    return undefined;
+  }
+  return targets.map(target => {
+    if (typeof target !== 'string') {
+      return target;
+    }
+    if (isStateId(target)) {
+      return stateNode.machine.getStateNodeById(target);
+    }
+    const isInternalTarget = target[0] === STATE_DELIMITER;
+    // If internal target is defined on machine,
+    // do not include machine key on target
+    if (isInternalTarget && !stateNode.parent) {
+      return getStateNodeByPath(stateNode, target.slice(1));
+    }
+    const resolvedTarget = isInternalTarget ? stateNode.key + target : target;
+    if (stateNode.parent) {
+      try {
+        const targetStateNode = getStateNodeByPath(stateNode.parent, resolvedTarget);
+        return targetStateNode;
+      } catch (err) {
+        throw new Error(`Invalid transition definition for state node '${stateNode.id}':\n${err.message}`);
+      }
+    } else {
+      throw new Error(`Invalid target: "${target}"`);
+    }
+  });
+}
+function resolveHistoryDefaultTransition(stateNode) {
+  const normalizedTarget = normalizeTarget(stateNode.config.target);
+  if (!normalizedTarget) {
+    return stateNode.parent.initial;
+  }
+  return {
+    target: normalizedTarget.map(t => typeof t === 'string' ? getStateNodeByPath(stateNode.parent, t) : t),
+    source: stateNode,
+    reenter: false,
+    eventType: ''
+  };
+}
+function isHistoryNode(stateNode) {
+  return stateNode.type === 'history';
+}
+function getInitialStateNodes(stateNode) {
+  const set = new Set();
+  function iter(descStateNode) {
+    if (set.has(descStateNode)) {
+      return;
+    }
+    set.add(descStateNode);
+    if (descStateNode.type === 'compound') {
+      iter(descStateNode.initial.target[0]);
+    } else if (descStateNode.type === 'parallel') {
+      for (const child of getChildren(descStateNode)) {
+        iter(child);
+      }
+    }
+  }
+  iter(stateNode);
+  for (const initialState of set) {
+    for (const ancestor of getProperAncestors(initialState, stateNode)) {
+      set.add(ancestor);
+    }
+  }
+  return set;
+}
+
+/** Returns the child state node from its relative `stateKey`, or throws. */
+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];
+  if (!result) {
+    throw new Error(`Child state '${stateKey}' does not exist on '${stateNode.id}'`);
+  }
+  return result;
+}
+
+/**
+ * Returns the relative state node from the given `statePath`, or throws.
+ *
+ * @param statePath The string or string array relative path to the state node.
+ */
+function getStateNodeByPath(stateNode, statePath) {
+  if (typeof statePath === 'string' && isStateId(statePath)) {
+    try {
+      return stateNode.machine.getStateNodeById(statePath);
+    } catch {
+      // try individual paths
+      // throw e;
+    }
+  }
+  const arrayStatePath = toStatePath(statePath).slice();
+  let currentStateNode = stateNode;
+  while (arrayStatePath.length) {
+    const key = arrayStatePath.shift();
+    if (!key.length) {
+      break;
+    }
+    currentStateNode = getStateNode(currentStateNode, key);
+  }
+  return currentStateNode;
+}
+
+/**
+ * Returns the state nodes represented by the current state value.
+ *
+ * @param stateValue The state value or State instance
+ */
+function getStateNodes(stateNode, stateValue) {
+  if (typeof stateValue === 'string') {
+    const childStateNode = stateNode.states[stateValue];
+    if (!childStateNode) {
+      throw new Error(`State '${stateValue}' does not exist on '${stateNode.id}'`);
+    }
+    return [stateNode, childStateNode];
+  }
+  const childStateKeys = Object.keys(stateValue);
+  const childStateNodes = new Array(childStateKeys.length);
+  const allStateNodes = [stateNode.machine.root, stateNode];
+  for (let i = 0; i < childStateKeys.length; i++) {
+    const subStateNode = getStateNode(stateNode, childStateKeys[i]);
+    childStateNodes[i] = subStateNode;
+    allStateNodes.push(subStateNode);
+  }
+  for (let i = 0; i < childStateKeys.length; i++) {
+    allStateNodes.push(...getStateNodes(childStateNodes[i], stateValue[childStateKeys[i]]));
+  }
+  return allStateNodes;
+}
+function transitionNode(stateNode, stateValue, snapshot, event, self) {
+  // leaf node
+  if (typeof stateValue === 'string') {
+    const childStateNode = getStateNode(stateNode, stateValue);
+    const next = childStateNode.next(snapshot, event, self);
+    if (!next || !next.length) {
+      return stateNode.next(snapshot, event, self);
+    }
+    return next;
+  }
+  const subStateKeys = Object.keys(stateValue);
+  const subStateKey = subStateKeys[0];
+  if (subStateKeys.length === 1) {
+    const childStateNode = getStateNode(stateNode, subStateKey);
+    const next = transitionNode(childStateNode, stateValue[subStateKey], snapshot, event, self);
+    if (!next || !next.length) {
+      return stateNode.next(snapshot, event, self);
+    }
+    return next;
+  }
+  const allInnerTransitions = [];
+  for (const subStateKey of subStateKeys) {
+    const subStateValue = stateValue[subStateKey];
+    if (!subStateValue) {
+      continue;
+    }
+    const subStateNode = getStateNode(stateNode, subStateKey);
+    const innerTransitions = transitionNode(subStateNode, subStateValue, snapshot, event, self);
+    if (innerTransitions) {
+      allInnerTransitions.push(...innerTransitions);
+    }
+  }
+  if (!allInnerTransitions.length) {
+    return stateNode.next(snapshot, event, self);
+  }
+  return allInnerTransitions;
+}
+function isDescendant(childStateNode, parentStateNode) {
+  let marker = childStateNode;
+  while (marker.parent && marker.parent !== parentStateNode) {
+    marker = marker.parent;
+  }
+  return marker.parent === parentStateNode;
+}
+function hasDescendantState(stateNodes, parentStateNode) {
+  for (const stateNode of stateNodes) {
+    if (isDescendant(stateNode, parentStateNode)) {
+      return true;
+    }
+  }
+  return false;
+}
+function hasIntersection(s1, s2) {
+  const s1Size = s1 instanceof Set ? s1.size : Array.isArray(s1) ? s1.length : undefined;
+  const s2Size = s2 instanceof Set ? s2.size : Array.isArray(s2) ? s2.length : undefined;
+  if (s1Size !== undefined && s2Size !== undefined && s2Size < s1Size) {
+    [s1, s2] = [s2, s1];
+  }
+  const set1 = s1 instanceof Set ? s1 : new Set(s1);
+  for (const item of s2) {
+    if (set1.has(item)) {
+      return true;
+    }
+  }
+  return false;
+}
+function removeConflictingTransitions(enabledTransitions, stateNodeSet, snapshot, event, actorScope) {
+  const filteredTransitions = new Set();
+  const exitSets = new Map();
+  const getExitSet = transition => {
+    let exitSet = exitSets.get(transition);
+    if (!exitSet) {
+      exitSet = computeExitSet([transition], stateNodeSet, snapshot, event, actorScope);
+      exitSets.set(transition, exitSet);
+    }
+    return exitSet;
+  };
+  for (const t1 of enabledTransitions) {
+    let t1Preempted = false;
+    const transitionsToRemove = new Set();
+    for (const t2 of filteredTransitions) {
+      if (hasIntersection(getExitSet(t1), getExitSet(t2))) {
+        if (isDescendant(t1.source, t2.source)) {
+          transitionsToRemove.add(t2);
+        } else {
+          t1Preempted = true;
+          break;
+        }
+      }
+    }
+    if (!t1Preempted) {
+      for (const t3 of transitionsToRemove) {
+        filteredTransitions.delete(t3);
+      }
+      filteredTransitions.add(t1);
+    }
+  }
+  return Array.from(filteredTransitions);
+}
+function getEffectiveTargetStates(transition, snapshot, event, actorScope) {
+  const historyValue = snapshot.historyValue;
+  const {
+    targets
+  } = getTransitionResult(transition, snapshot, event, actorScope);
+  if (!targets) {
+    return [];
+  }
+  const targetSet = new Set();
+  for (const targetNode of targets) {
+    if (isHistoryNode(targetNode)) {
+      if (historyValue[targetNode.id]) {
+        for (const node of historyValue[targetNode.id]) {
+          targetSet.add(node);
+        }
+      } else {
+        for (const node of getEffectiveTargetStates(resolveHistoryDefaultTransition(targetNode), snapshot, event, actorScope)) {
+          targetSet.add(node);
+        }
+      }
+    } else {
+      targetSet.add(targetNode);
+    }
+  }
+  return [...targetSet];
+}
+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;
+  }
+  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;
+    }
+  }
+
+  // at this point we know that it's a root transition since LCA couldn't be found
+  if (reenter) {
+    return;
+  }
+  return transition.source.machine.root;
+}
+function computeExitSet(transitions, stateNodeSet, snapshot, event, actorScope) {
+  const statesToExit = new Set();
+  for (const transition of transitions) {
+    const {
+      targets
+    } = getTransitionResult(transition, snapshot, event, actorScope);
+    if (targets?.length) {
+      const domain = getTransitionDomain(transition, snapshot, event, actorScope);
+      if (transition.reenter && transition.source === domain) {
+        statesToExit.add(domain);
+      }
+      for (const stateNode of stateNodeSet) {
+        if (isDescendant(stateNode, domain)) {
+          statesToExit.add(stateNode);
+        }
+      }
+    }
+  }
+  return [...statesToExit];
+}
+function initialMicrostep(root, preInitialState, actorScope, initEvent, internalQueue) {
+  return microstep([{
+    target: [...getInitialStateNodes(root)],
+    source: root,
+    reenter: true,
+    eventType: null,
+    toJSON: null
+  }], preInitialState, actorScope, initEvent, true, internalQueue);
+}
+
+/** https://www.w3.org/TR/scxml/#microstepProcedure */
+function microstep(transitions, currentSnapshot, actorScope, event, isInitial, internalQueue) {
+  const actions = [];
+  if (!transitions.length) {
+    return [currentSnapshot, actions];
+  }
+  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;
+    const filteredTransitions = removeConflictingTransitions(transitions, mutStateNodeSet, currentSnapshot, event, actorScope);
+    const getCurrentTransitionResult = transition => getTransitionResult(transition, currentSnapshot, event, actorScope);
+    const getStateActionsAndContext = (transitionFn, context, children, input) => {
+      if (transitionFn.length === 2) {
+        // enqueue action; retrieve
+        const actions = [];
+        const internalEvents = [];
+        let updatedContext;
+        const enqueue = createTransitionEnqueue(actorScope, actions, internalEvents, true);
+        const res = transitionFn({
+          context,
+          event,
+          parent: actorScope.self._parent,
+          self: actorScope.self,
+          children,
+          system: actorScope.system,
+          actions: currentSnapshot.machine.implementations.actions,
+          actors: currentSnapshot.machine.implementations.actors,
+          guards: currentSnapshot.machine.implementations.guards,
+          delays: currentSnapshot.machine.implementations.delays,
+          input
+        }, enqueue);
+        if (res?.context) {
+          updatedContext = res.context;
+        }
+        return [actions, updatedContext, internalEvents];
+      }
+
+      // For 1-argument actions, wrap them to include input
+      // Preserve _special flag if present (for entry/exit actions)
+      const wrappedAction = Object.assign((args, enqueue) => transitionFn({
+        ...args,
+        input
+      }, enqueue), '_special' in transitionFn ? {
+        _special: true
+      } : {});
+      return [[wrappedAction], undefined, undefined];
+    };
+    let nextState = currentSnapshot;
+    const exitStates = () => {
+      const statesToExit = computeExitSet(filteredTransitions, mutStateNodeSet, currentSnapshot, event, actorScope);
+      statesToExit.sort((a, b) => b.order - a.order);
+      let changedHistory;
+      const currentStateNodes = [...mutStateNodeSet];
+
+      // From SCXML algorithm: https://www.w3.org/TR/scxml/#exitStates
+      for (const exitStateNode of statesToExit) {
+        for (const historyNode of Object.values(exitStateNode.states)) {
+          if (historyNode.type !== 'history') {
+            continue;
+          }
+          const predicate = historyNode.history === 'deep' ? sn => isAtomicStateNode(sn) && isDescendant(sn, exitStateNode) : sn => sn.parent === exitStateNode;
+          changedHistory ??= {
+            ...historyValue
+          };
+          changedHistory[historyNode.id] = currentStateNodes.filter(predicate);
+        }
+      }
+      for (const exitStateNode of statesToExit) {
+        const stateInput = currentSnapshot._stateInputs?.[exitStateNode.id];
+        const [exitActions, nextContext, internalEvents] = exitStateNode.exit ? getStateActionsAndContext(exitStateNode.exit, nextState.context, currentSnapshot.children, stateInput) : [[]];
+        if (internalEvents?.length) {
+          internalQueue.push(...internalEvents);
+        }
+        if (nextContext) {
+          nextState = cloneMachineSnapshot(nextState, {
+            context: nextContext
+          });
+        }
+        nextState = resolveAndExecuteActionsWithContext(nextState, event, actorScope, exitActions);
+        for (const def of exitStateNode.invoke) {
+          const childActor = nextState.children[def.id];
+          if (childActor && !childActor._isExternal) {
+            actorScope.stopChild(childActor);
+          }
+          delete nextState.children[def.id];
+        }
+        mutStateNodeSet.delete(exitStateNode);
+      }
+      historyValue = changedHistory || historyValue;
+    };
+
+    // Exit states
+    if (!isInitial) {
+      exitStates();
+    }
+    let context = nextState.context;
+    const transitionActions = [];
+    const internalEvents = [];
+    for (const t of filteredTransitions) {
+      if (t.actions) {
+        transitionActions.push(...toArray(t.actions));
+      }
+      const res = getCurrentTransitionResult(t);
+      if (res.context) {
+        context = res.context;
+      }
+      if (res.actions) {
+        transitionActions.push(...res.actions);
+      }
+      if (res.internalEvents) {
+        internalEvents.push(...res.internalEvents);
+      }
+    }
+    if (internalEvents.length) {
+      internalQueue.push(...internalEvents);
+    }
+    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);
+        } else if (rootCompletionNode.type === 'parallel') {
+          const parallelDoneType = `xstate.done.state.${rootCompletionNode.id}`;
+          const parallelDoneEvent = internalQueue.find(e => e.type === parallelDoneType);
+          completionOutput = parallelDoneEvent?.output;
+        }
+        return resolveOutput(rootNode.output, nextState.context, createDoneStateEvent(rootCompletionNode.id, completionOutput), actorScope.self);
+      };
+      const statesToEnter = new Set();
+      // those are states that were directly targeted or indirectly targeted by the explicit target
+      // in other words, those are states for which initial actions should be executed
+      // when we target `#deep_child` initial actions of its ancestors shouldn't be executed
+      const statesForDefaultEntry = new Set();
+      const addAncestorStatesToEnter = (ancestors, reentrancyDomain) => {
+        for (const anc of ancestors) {
+          if (!reentrancyDomain || isDescendant(anc, reentrancyDomain)) {
+            statesToEnter.add(anc);
+          }
+          if (anc.type === 'parallel') {
+            for (const child of getChildren(anc)) {
+              if (!hasDescendantState(statesToEnter, child)) {
+                statesToEnter.add(child);
+                addDescendantStatesToEnter(child);
+              }
+            }
+          }
+        }
+      };
+      const addDescendantStatesToEnter = stateNode => {
+        if (isHistoryNode(stateNode)) {
+          if (historyValue[stateNode.id]) {
+            const historyStateNodes = historyValue[stateNode.id];
+            for (const s of historyStateNodes) {
+              statesToEnter.add(s);
+              addDescendantStatesToEnter(s);
+            }
+            for (const s of historyStateNodes) {
+              addAncestorStatesToEnter(getProperAncestors(s, stateNode.parent), undefined);
+            }
+          } else {
+            const historyDefaultTransition = resolveHistoryDefaultTransition(stateNode);
+            const {
+              targets
+            } = getCurrentTransitionResult(historyDefaultTransition);
+            for (const s of targets ?? []) {
+              statesToEnter.add(s);
+              if (historyDefaultTransition === stateNode.parent?.initial) {
+                statesForDefaultEntry.add(stateNode.parent);
+              }
+              addDescendantStatesToEnter(s);
+            }
+            for (const s of targets ?? []) {
+              addAncestorStatesToEnter(getProperAncestors(s, stateNode.parent), undefined);
+            }
+          }
+          return;
+        }
+        if (stateNode.type === 'compound') {
+          const [initialState] = getCurrentTransitionResult(stateNode.initial).targets;
+          if (!isHistoryNode(initialState)) {
+            statesToEnter.add(initialState);
+            statesForDefaultEntry.add(initialState);
+          }
+          addDescendantStatesToEnter(initialState);
+          addAncestorStatesToEnter(getProperAncestors(initialState, stateNode), undefined);
+          return;
+        }
+        if (stateNode.type === 'parallel') {
+          for (const child of getChildren(stateNode)) {
+            if (!hasDescendantState(statesToEnter, child)) {
+              statesToEnter.add(child);
+              statesForDefaultEntry.add(child);
+              addDescendantStatesToEnter(child);
+            }
+          }
+        }
+      };
+      for (const transition of filteredTransitions) {
+        const domain = getTransitionDomain(transition, currentSnapshot, event, actorScope);
+        const {
+          targets,
+          reenter
+        } = getCurrentTransitionResult(transition);
+        for (const targetNode of targets ?? []) {
+          if (!isHistoryNode(targetNode) && (transition.source !== targetNode || transition.source !== domain || reenter)) {
+            statesToEnter.add(targetNode);
+            statesForDefaultEntry.add(targetNode);
+          }
+          addDescendantStatesToEnter(targetNode);
+        }
+        const targetStates = getEffectiveTargetStates(transition, currentSnapshot, event, actorScope);
+        for (const s of targetStates) {
+          const ancestors = getProperAncestors(s, domain);
+          if (domain?.type === 'parallel') {
+            ancestors.push(domain);
+          }
+          addAncestorStatesToEnter(ancestors, !transition.source.parent && reenter ? undefined : domain);
+        }
+      }
+      if (isInitial) {
+        statesForDefaultEntry.add(currentSnapshot.machine.root);
+      }
+      const stateInputMap = {
+        ...currentSnapshot._stateInputs
+      };
+      for (const transition of filteredTransitions) {
+        const {
+          targets,
+          input
+        } = getCurrentTransitionResult(transition);
+        if (input && targets) {
+          for (const targetNode of targets) {
+            stateInputMap[targetNode.id] = input;
+          }
+        }
+      }
+      const completedNodes = new Set();
+      const children = {
+        ...currentSnapshot.children
+      };
+      for (const stateNodeToEnter of [...statesToEnter].sort((a, b) => a.order - b.order)) {
+        mutStateNodeSet.add(stateNodeToEnter);
+        const actions = [];
+        let invoked = false;
+        for (const invokeDef of stateNodeToEnter.invoke) {
+          invoked = true;
+          let src = invokeDef.logic;
+          if (typeof src === 'function') {
+            src = src({
+              actors: currentSnapshot.machine.implementations.actors,
+              context: nextState.context,
+              event,
+              self: actorScope.self
+            });
+          }
+          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}'`);
+          }
+          const input = typeof invokeDef.input === 'function' ? invokeDef.input({
+            self: actorScope.self,
+            context: nextState.context,
+            event
+          }) : invokeDef.input;
+          const actor = createActor(logic, {
+            ...invokeDef,
+            input,
+            parent: actorScope.self,
+            syncSnapshot: !!invokeDef.onSnapshot
+          });
+          actions.push({
+            action: builtInActions['@xstate.start'],
+            args: [actor]
+          });
+          if (invokeDef.id) {
+            children[invokeDef.id] = actor;
+          }
+        }
+        if (invoked) {
+          nextState = cloneMachineSnapshot(nextState, {
+            children
+          });
+        }
+        let context;
+        const stateInput = stateInputMap[stateNodeToEnter.id];
+        if (stateNodeToEnter.entry) {
+          const [resultActions, nextContext, nextInternalEvents] = getStateActionsAndContext(stateNodeToEnter.entry, nextState.context, children, stateInput);
+          actions.push(...resultActions);
+          if (nextInternalEvents?.length) {
+            internalQueue.push(...nextInternalEvents);
+          }
+          if (nextContext) {
+            context = nextContext;
+          }
+        }
+        if (statesForDefaultEntry.has(stateNodeToEnter)) {
+          const {
+            actions: initialActions,
+            input: initialInput
+          } = getTransitionResult(stateNodeToEnter.initial, nextState, event, actorScope);
+          if (initialActions) {
+            actions.push(...initialActions);
+          }
+          if (initialInput && stateNodeToEnter.initial?.target) {
+            for (const targetNode of stateNodeToEnter.initial.target) {
+              stateInputMap[targetNode.id] = initialInput;
+            }
+          }
+        }
+        nextState = resolveAndExecuteActionsWithContext(nextState, event, actorScope, actions);
+        if (context) {
+          nextState.context = context;
+        }
+        if (stateNodeToEnter.type !== 'final') {
+          continue;
+        }
+        const parent = stateNodeToEnter.parent;
+        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));
+        }
+        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;
+              continue;
+            }
+            if (region.type === 'parallel') {
+              const regionDoneType = `xstate.done.state.${region.id}`;
+              const regionDoneEvent = internalQueue.find(e => e.type === regionDoneType);
+              regionOutput[region.key] = regionDoneEvent?.output;
+              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;
+          }
+          internalQueue.push(createDoneStateEvent(ancestorMarker.id, regionOutput));
+          rootCompletionNode = ancestorMarker;
+          ancestorMarker = ancestorMarker.parent;
+        }
+        if (ancestorMarker) {
+          continue;
+        }
+        nextState = cloneMachineSnapshot(nextState, {
+          status: 'done',
+          output: getMachineOutput(rootCompletionNode)
+        });
+      }
+      const inputChanged = JSON.stringify(stateInputMap) !== JSON.stringify(currentSnapshot._stateInputs || {});
+      if (inputChanged) {
+        nextState = cloneMachineSnapshot(nextState, {
+          _stateInputs: stateInputMap
+        });
+      }
+    };
+
+    // Execute transition content
+    nextState = resolveAndExecuteActionsWithContext(nextState, event, actorScope, transitionActions);
+    if (context && context !== currentSnapshot.context) {
+      nextState = cloneMachineSnapshot(nextState, {
+        context
+      });
+    }
+
+    // Enter states
+    enterStates();
+    const nextStateNodes = [...mutStateNodeSet];
+    if (nextState.status === 'done') {
+      const allExitActions = [];
+      const nextStateNodesToExit = nextStateNodes.sort((a, b) => b.order - a.order);
+      nextStateNodesToExit.forEach(stateNode => {
+        if (stateNode.exit) {
+          const stateInput = nextState._stateInputs?.[stateNode.id];
+          const [exitActions,, nextInternalEvents] = getStateActionsAndContext(stateNode.exit, nextState.context, nextState.children, stateInput);
+          allExitActions.push(...exitActions);
+          if (nextInternalEvents?.length) {
+            internalQueue.push(...nextInternalEvents);
+          }
+        }
+      });
+      nextState = resolveAndExecuteActionsWithContext(nextState, event, actorScope, allExitActions);
+    }
+    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 [nextState, actions];
+    }
+    return [cloneMachineSnapshot(nextState, {
+      _nodes: nextStateNodes,
+      historyValue
+    }), actions];
+  } finally {
+    actorScope.actionExecutor = originalExecutor;
+  }
+}
+
+/**
+ * Gets the transition result for a given transition without executing the
+ * transition.
+ */
+function getTransitionResult(transition, snapshot, event, actorScope) {
+  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 targets = res?.target ? resolveTarget(transition.source, toArray(res.target)) : undefined;
+    // Resolve input for .to transitions
+    const resolvedInput = typeof transition.input === 'function' ? transition.input({
+      context: snapshot.context,
+      event
+    }) : transition.input;
+    return {
+      targets: targets,
+      context: res?.context,
+      reenter: res?.reenter,
+      actions,
+      internalEvents,
+      input: resolvedInput
+    };
+  }
+
+  // Resolve input for regular transitions
+  const resolvedInput = typeof transition.input === 'function' ? transition.input({
+    context: snapshot.context,
+    event
+  }) : transition.input;
+  return {
+    targets: transition.target,
+    context: undefined,
+    reenter: transition.reenter,
+    actions: undefined,
+    internalEvents: undefined,
+    input: resolvedInput
+  };
+}
+function macrostep(snapshot, event, actorScope, internalQueue) {
+  let nextSnapshot = snapshot;
+  const microsteps = [];
+  function addMicrostep(step, transitions) {
+    // collect microsteps; surfaced on the enclosing '@xstate.transition' event
+    // via its `microsteps[]` facet (there is no standalone microstep event)
+    const collectedMicrosteps = actorScope.self._collectedMicrosteps || [];
+    collectedMicrosteps.push(...transitions);
+    actorScope.self._collectedMicrosteps = collectedMicrosteps;
+    microsteps.push(step);
+  }
+
+  // Handle stop event
+  if (event.type === XSTATE_STOP) {
+    nextSnapshot = cloneMachineSnapshot(stopChildren(nextSnapshot, actorScope), {
+      status: 'stopped'
+    });
+    addMicrostep([nextSnapshot, []], []);
+    return {
+      snapshot: nextSnapshot,
+      microsteps
+    };
+  }
+  let nextEvent = event;
+
+  // Assume the state is at rest (no raised events)
+  // Determine the next state based on the next microstep
+  if (nextEvent.type !== XSTATE_INIT) {
+    const currentEvent = nextEvent;
+    const isErr = isErrorActorEvent(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
+      // `*` shouldn't be matched, likely `xstate.error.*` shouldn't be either
+      // similarly `xstate.error.actor.*` and `xstate.error.actor.todo.*` have to be considered too
+      nextSnapshot = cloneMachineSnapshot(snapshot, {
+        status: 'error',
+        error: currentEvent.error
+      });
+      addMicrostep([nextSnapshot, []], []);
+      return {
+        snapshot: nextSnapshot,
+        microsteps
+      };
+    }
+    const step = microstep(transitions, snapshot, actorScope, nextEvent, false,
+    // isInitial
+    internalQueue);
+    nextSnapshot = step[0];
+    addMicrostep(step, transitions);
+  }
+  let shouldSelectEventlessTransitions = true;
+  const maxIterations = snapshot.machine.options?.maxIterations ?? Infinity;
+  let iterationCount = 0;
+  let microstepCount = 0;
+  while (nextSnapshot.status === 'active') {
+    microstepCount++;
+    if (microstepCount > 1000) {
+      throw new Error('Microstep count exceeded 1000');
+    }
+    iterationCount++;
+    if (iterationCount > maxIterations) {
+      throw new Error(`Infinite loop detected (>${maxIterations} microsteps)`);
+    }
+    let enabledTransitions = shouldSelectEventlessTransitions ? selectEventlessTransitions(nextSnapshot, nextEvent, actorScope) : [];
+
+    // eventless transitions should always be selected after selecting *regular* transitions
+    // by assigning `undefined` to `previousState` we ensure that `shouldSelectEventlessTransitions` gets always computed to true in such a case
+    const previousState = enabledTransitions.length ? nextSnapshot : undefined;
+    if (!enabledTransitions.length) {
+      if (!internalQueue.length) {
+        break;
+      }
+      nextEvent = internalQueue.shift();
+      enabledTransitions = nextSnapshot.machine.getTransitionData(nextSnapshot, nextEvent, actorScope.self);
+    }
+    const step = microstep(enabledTransitions, nextSnapshot, actorScope, nextEvent, false, internalQueue);
+    nextSnapshot = step[0];
+    shouldSelectEventlessTransitions = nextSnapshot !== previousState;
+    addMicrostep(step, enabledTransitions);
+  }
+  if (nextSnapshot.status !== 'active' && nextSnapshot.children) {
+    stopChildren(nextSnapshot, actorScope);
+  }
+  return {
+    snapshot: nextSnapshot,
+    microsteps
+  };
+}
+
+/**
+ * Resolves a partial state value with its full representation in the state
+ * node's machine.
+ *
+ * @param stateValue The partial state value to resolve.
+ */
+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 false;
+}
+function transitionToHasEffect(transitionTo, context, event, snapshot, self, implementations) {
+  let hasEffect = false;
+  let res;
+  try {
+    const triggerEffect = () => {
+      hasEffect = true;
+      throw new Error('Effect triggered');
+    };
+    res = transitionTo({
+      context,
+      event,
+      self,
+      value: snapshot.value,
+      children: snapshot.children,
+      parent: {
+        send: triggerEffect
+      },
+      actions: implementations.actions,
+      actors: implementations.actors,
+      guards: implementations.guards,
+      delays: implementations.delays
+    }, createEnqueueObject({
+      emit: triggerEffect,
+      cancel: triggerEffect,
+      log: triggerEffect,
+      raise: triggerEffect,
+      spawn: triggerEffect,
+      sendTo: triggerEffect,
+      stop: triggerEffect
+    }, triggerEffect));
+  } catch (err) {
+    if (hasEffect) {
+      return true;
+    }
+    throw err;
+  }
+  return res !== undefined;
+}
+function stopChildren(snapshot, actorScope) {
+  let children;
+  if (!snapshot.children || (children = Object.values(snapshot.children).filter(Boolean)).length === 0) {
+    return snapshot;
+  }
+  for (const child of children) {
+    actorScope.stopChild(child);
+  }
+  return cloneMachineSnapshot(snapshot, {
+    children: {}
+  });
+}
+function selectEventlessTransitions(snapshot, event, actorScope) {
+  const enabledTransitionSet = new Set();
+  const atomicStates = snapshot._nodes.filter(isAtomicStateNode);
+  for (const atomicStateNode of atomicStates) {
+    loop: for (let stateNode = atomicStateNode; stateNode; stateNode = stateNode.parent) {
+      if (!stateNode.always) {
+        continue;
+      }
+      for (const transition of stateNode.always) {
+        if (evaluateCandidate(transition, event, snapshot, stateNode, actorScope.self)) {
+          enabledTransitionSet.add(transition);
+          break loop;
+        }
+      }
+    }
+  }
+  return removeConflictingTransitions(Array.from(enabledTransitionSet), new Set(snapshot._nodes), snapshot, event, actorScope);
+}
+function evaluateCandidate(candidate, event, snapshot, stateNode, self) {
+  if (candidate.guard) {
+    const guardArgs = {
+      context: snapshot.context,
+      event,
+      self,
+      parent: self._parent,
+      children: snapshot.children,
+      actions: stateNode.machine.implementations.actions,
+      actors: stateNode.machine.implementations.actors,
+      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}'.`);
+      }
+      guardPassed = guardImpl(guardArgs, guardParams);
+    }
+    if (!guardPassed) {
+      return false;
+    }
+  }
+  if (candidate.to) {
+    return transitionToHasEffect(candidate.to, snapshot.context, event, snapshot, self, stateNode.machine.implementations);
+  }
+  return true;
+}
+
+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);
+};
+const machineSnapshotHasTag = function hasTag(tag) {
+  return this.tags.has(tag);
+};
+const machineSnapshotCan = function can(event) {
+  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;
+};
+const machineSnapshotToJSON = function toJSON() {
+  const {
+    _nodes: nodes,
+    _stateInputs,
+    tags,
+    machine,
+    getMeta,
+    getInputs,
+    toJSON,
+    can,
+    hasTag,
+    matches,
+    ...jsonValues
+  } = this;
+  return {
+    ...jsonValues,
+    tags: Array.from(tags)
+  };
+};
+const machineSnapshotGetMeta = function getMeta() {
+  const meta = {};
+  for (const stateNode of this._nodes) {
+    if (stateNode.meta !== undefined) {
+      meta[stateNode.id] = stateNode.meta;
+    }
+  }
+  return meta;
+};
+const machineSnapshotGetInputs = function getInputs() {
+  return this._stateInputs;
+};
+function collectTags(stateNodes) {
+  const tags = new Set();
+  for (const stateNode of stateNodes) {
+    for (const tag of stateNode.tags) {
+      tags.add(tag);
+    }
+  }
+  return tags;
+}
+function createMachineSnapshot(config, machine) {
+  return {
+    status: config.status,
+    output: config.output,
+    error: config.error,
+    machine,
+    context: config.context,
+    _nodes: config._nodes,
+    value: config.value ?? getStateValue(machine.root, config._nodes),
+    tags: collectTags(config._nodes),
+    children: config.children,
+    historyValue: config.historyValue || {},
+    _stateInputs: config._stateInputs || {},
+    matches: machineSnapshotMatches,
+    hasTag: machineSnapshotHasTag,
+    can: machineSnapshotCan,
+    getMeta: machineSnapshotGetMeta,
+    getInputs: machineSnapshotGetInputs,
+    toJSON: machineSnapshotToJSON
+  };
+}
+function cloneMachineSnapshot(snapshot, config = {}) {
+  const configWithSnapshot = {
+    ...snapshot,
+    ...config
+  };
+  if ((config._nodes ?? snapshot._nodes) === snapshot._nodes) {
+    return {
+      status: configWithSnapshot.status,
+      output: configWithSnapshot.output,
+      error: configWithSnapshot.error,
+      machine: snapshot.machine,
+      context: configWithSnapshot.context,
+      _nodes: snapshot._nodes,
+      value: snapshot.value,
+      tags: snapshot.tags,
+      children: configWithSnapshot.children,
+      historyValue: configWithSnapshot.historyValue || {},
+      _stateInputs: configWithSnapshot._stateInputs || {},
+      matches: machineSnapshotMatches,
+      hasTag: machineSnapshotHasTag,
+      can: machineSnapshotCan,
+      getMeta: machineSnapshotGetMeta,
+      getInputs: machineSnapshotGetInputs,
+      toJSON: machineSnapshotToJSON
+    };
+  }
+  return createMachineSnapshot({
+    ...configWithSnapshot,
+    value: undefined
+  }, snapshot.machine);
+}
+function serializeHistoryValue(historyValue) {
+  const result = {};
+  for (const key in historyValue) {
+    const value = historyValue[key];
+    if (Array.isArray(value)) {
+      result[key] = value.map(item => ({
+        id: item.id
+      }));
+    }
+  }
+  return result;
+}
+function getPersistedSnapshot(snapshot, options) {
+  const {
+    _nodes: nodes,
+    _stateInputs,
+    tags,
+    machine,
+    children,
+    context,
+    can,
+    hasTag,
+    matches,
+    getMeta,
+    getInputs,
+    toJSON,
+    ...jsonValues
+  } = snapshot;
+  const childrenJson = {};
+  for (const id in children) {
+    const child = children[id];
+    childrenJson[id] = {
+      snapshot: child.getPersistedSnapshot(options),
+      src: child.src,
+      systemId: child.systemId,
+      syncSnapshot: child._syncSnapshot
+    };
+  }
+  const persisted = {
+    ...jsonValues,
+    context: persistContext(context),
+    children: childrenJson,
+    historyValue: serializeHistoryValue(jsonValues.historyValue)
+  };
+  if (machine.version !== undefined) {
+    persisted.version = machine.version;
+  }
+  return persisted;
+}
+function persistContext(contextPart) {
+  let copy;
+  for (const key in contextPart) {
+    const value = contextPart[key];
+    if (value && typeof value === 'object') {
+      if ('sessionId' in value && 'send' in value && 'ref' in value) {
+        copy ??= Array.isArray(contextPart) ? contextPart.slice() : {
+          ...contextPart
+        };
+        copy[key] = {
+          xstate$$type: $$ACTOR_TYPE,
+          id: value.id
+        };
+      } else {
+        const result = persistContext(value);
+        if (result !== value) {
+          copy ??= Array.isArray(contextPart) ? contextPart.slice() : {
+            ...contextPart
+          };
+          copy[key] = result;
+        }
+      }
+    }
+  }
+  return copy ?? contextPart;
+}
+
+function matchesState(parentStateId, childStateId) {
+  const parentStateValue = toStateValue(parentStateId);
+  const childStateValue = toStateValue(childStateId);
+  if (typeof childStateValue === 'string') {
+    if (typeof parentStateValue === 'string') {
+      return childStateValue === parentStateValue;
+    }
+
+    // Parent more specific than child
+    return false;
+  }
+  if (typeof parentStateValue === 'string') {
+    return parentStateValue in childStateValue;
+  }
+  return Object.keys(parentStateValue).every(key => {
+    if (!(key in childStateValue)) {
+      return false;
+    }
+    return matchesState(parentStateValue[key], childStateValue[key]);
+  });
+}
+function checkStateIn(snapshot, stateValue) {
+  if (typeof stateValue === 'string' && isStateId(stateValue)) {
+    const target = snapshot.machine.getStateNodeById(stateValue);
+    return snapshot._nodes.some(sn => sn === target);
+  }
+  return snapshot.matches(stateValue);
+}
+function toStatePath(stateId) {
+  if (isArray(stateId)) {
+    return stateId;
+  }
+  const result = [];
+  let segment = '';
+  for (let i = 0; i < stateId.length; i++) {
+    const char = stateId.charCodeAt(i);
+    switch (char) {
+      // \
+      case 92:
+        // consume the next character
+        segment += stateId[i + 1];
+        // and skip over it
+        i++;
+        continue;
+      // .
+      case 46:
+        result.push(segment);
+        segment = '';
+        continue;
+    }
+    segment += stateId[i];
+  }
+  result.push(segment);
+  return result;
+}
+function toStateValue(stateValue) {
+  if (isMachineSnapshot(stateValue)) {
+    return stateValue.value;
+  }
+  if (typeof stateValue !== 'string') {
+    return stateValue;
+  }
+  const statePath = toStatePath(stateValue);
+  return pathToStateValue(statePath);
+}
+function pathToStateValue(statePath) {
+  if (statePath.length === 1) {
+    return statePath[0];
+  }
+  const value = {};
+  let marker = value;
+  for (let i = 0; i < statePath.length - 1; i++) {
+    if (i === statePath.length - 2) {
+      marker[statePath[i]] = statePath[i + 1];
+    } else {
+      const previous = marker;
+      marker = {};
+      previous[statePath[i]] = marker;
+    }
+  }
+  return value;
+}
+function mapValues(collection, iteratee) {
+  const result = {};
+  const collectionKeys = Object.keys(collection);
+  for (let i = 0; i < collectionKeys.length; i++) {
+    const key = collectionKeys[i];
+    result[key] = iteratee(collection[key], key, collection, i);
+  }
+  return result;
+}
+function toArrayStrict(value) {
+  if (isArray(value)) {
+    return value;
+  }
+  return [value];
+}
+function toArray(value) {
+  if (value === undefined) {
+    return [];
+  }
+  return toArrayStrict(value);
+}
+function resolveOutput(mapper, context, event, self) {
+  if (typeof mapper === 'function') {
+    return mapper({
+      context,
+      event,
+      self
+    });
+  }
+  return mapper;
+}
+function isArray(value) {
+  return Array.isArray(value);
+}
+function isErrorActorEvent(event) {
+  return event.type.startsWith('xstate.error.actor');
+}
+function toTransitionConfigArray(configLike) {
+  return toArrayStrict(configLike).map(transitionLike => {
+    if (typeof transitionLike === 'undefined' || typeof transitionLike === 'string') {
+      return {
+        target: transitionLike
+      };
+    }
+    if (typeof transitionLike === 'function') {
+      return {
+        to: transitionLike
+      };
+    }
+    return transitionLike;
+  });
+}
+function normalizeTarget(target) {
+  if (target === undefined || target === TARGETLESS_KEY) {
+    return undefined;
+  }
+  return toArray(target);
+}
+function toObserver(nextHandler, errorHandler, completionHandler) {
+  const isObserver = typeof nextHandler === 'object';
+  const self = isObserver ? nextHandler : undefined;
+  return {
+    next: (isObserver ? nextHandler.next : nextHandler)?.bind(self),
+    error: (isObserver ? nextHandler.error : errorHandler)?.bind(self),
+    complete: (isObserver ? nextHandler.complete : completionHandler)?.bind(self)
+  };
+}
+function createInvokeId(stateNodeId, index) {
+  return `${index}.${stateNodeId}`;
+}
+function resolveReferencedActor(machine, src) {
+  const match = src.match(/^xstate\.invoke\.(\d+)\.(.*)/);
+  if (!match) {
+    return machine.implementations.actors[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;
+}
+function getAllOwnEventDescriptors(snapshot) {
+  return [...new Set([...snapshot._nodes.flatMap(sn => sn.ownEvents)])];
+}
+
+/**
+ * Checks if an event type matches an event descriptor, supporting wildcards.
+ * Event descriptors can be:
+ *
+ * - Exact matches: "event.type"
+ * - Wildcard: "*"
+ * - Partial matches: "event.*"
+ *
+ * @param eventType - The actual event type string
+ * @param descriptor - The event descriptor to match against
+ * @returns True if the event type matches the descriptor
+ */
+function matchesEventDescriptor(eventType, descriptor) {
+  if (descriptor === eventType) {
+    return true;
+  }
+  if (descriptor === WILDCARD) {
+    return true;
+  }
+  if (!descriptor.endsWith('.*')) {
+    return false;
+  }
+  const partialEventTokens = descriptor.split('.');
+  const eventTokens = eventType.split('.');
+  for (let tokenIndex = 0; tokenIndex < partialEventTokens.length; tokenIndex++) {
+    const partialEventToken = partialEventTokens[tokenIndex];
+    const eventToken = eventTokens[tokenIndex];
+    if (partialEventToken === '*') {
+      const isLastToken = tokenIndex === partialEventTokens.length - 1;
+      return isLastToken;
+    }
+    if (partialEventToken !== eventToken) {
+      return false;
+    }
+  }
+  return true;
+}
+
+function createScheduledEventId(actor, id) {
+  return `${actor.sessionId}.${id}`;
+}
+function createSystem(rootActor, options) {
+  let idCounter = 0;
+  const children = new Map();
+  const keyedActors = new Map();
+  const reverseKeyedActors = new WeakMap();
+  const inspectionObservers = new Set();
+  const timerMap = {};
+  const {
+    clock,
+    logger
+  } = options;
+
+  // Records a send on the *sender's* transition for the `sent[]` inspection
+  // facet. Captures the send when it is initiated (including delayed sends that
+  // may never deliver), keyed to the source actor's in-flight transition.
+  const recordSent = (source, target, event, delay, id) => {
+    if (!inspectionObservers.size || !source) {
+      return;
+    }
+    const collected = source._collectedSent ??= [];
+    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'
+      };
+    };
+    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);
+    },
+    getInitialSnapshot: (_, input) => {
+      const context = resolveContext(config.context, input);
+      const snapshot = {
+        status: 'active',
+        output: undefined,
+        error: undefined,
+        input
+      };
+      if (context !== undefined) {
+        snapshot.context = context;
+      }
+      return {
+        ...snapshot
+      };
+    },
+    getPersistedSnapshot: snapshot => snapshot,
+    restoreSnapshot: snapshot => snapshot
+  };
+  return logic;
+}
+
+// those are needed to make JSDoc `@link` work properly
+
+let executingCustomAction = false;
+const $$ACTOR_TYPE = 1;
+
+// those values are currently used by @xstate/react directly so it's important to keep the assigned values in sync
+let ProcessingStatus = /*#__PURE__*/function (ProcessingStatus) {
+  ProcessingStatus[ProcessingStatus["NotStarted"] = 0] = "NotStarted";
+  ProcessingStatus[ProcessingStatus["Running"] = 1] = "Running";
+  ProcessingStatus[ProcessingStatus["Stopped"] = 2] = "Stopped";
+  return ProcessingStatus;
+}({});
+const defaultOptions = {
+  clock: {
+    setTimeout: (fn, ms) => {
+      return setTimeout(fn, ms);
+    },
+    clearTimeout: id => {
+      return clearTimeout(id);
+    }
+  },
+  logger: console.log.bind(console)
+};
+
+/**
+ * An Actor is a running process that can receive events, send events and change
+ * its behavior based on the events it receives, which can cause effects outside
+ * of the actor. When you run a state machine, it becomes an actor.
+ *
+ * An `Actor` is the concrete runtime instance with lifecycle methods and
+ * system-owned internals. It also satisfies the narrower `ActorRef` contract,
+ * so consumer APIs should accept `ActorRef` when they only need to send events
+ * or read snapshots.
+ */
+class Actor {
+  /**
+   * Creates a new actor instance for the given logic with the provided options,
+   * if any.
+   *
+   * @param logic The logic to create an actor from
+   * @param options Actor options
+   */
+  constructor(logic, options) {
+    this.logic = logic;
+    /** The current internal state of the actor. */
+    this._snapshot = void 0;
+    /**
+     * The clock that is responsible for setting and clearing timeouts, such as
+     * delayed events and transitions.
+     */
+    this.clock = void 0;
+    this.options = void 0;
+    /** The unique identifier for this actor relative to its parent. */
+    this.id = void 0;
+    this._boundProcess = this._process.bind(this);
+    this.mailbox = new Mailbox(this._boundProcess);
+    this.observers = new Set();
+    this.eventListeners = new Map();
+    this.logger = void 0;
+    /** @internal */
+    this._processingStatus = ProcessingStatus.NotStarted;
+    // Actor Ref
+    this._parent = void 0;
+    /** @internal */
+    this._syncSnapshot = void 0;
+    this.ref = void 0;
+    // TODO: add typings for system
+    this._actorScope = void 0;
+    /** @internal */
+    this._lastSourceRef = void 0;
+    /** @internal */
+    this._collectedMicrosteps = [];
+    /** @internal Actions executed during the in-flight transition. */
+    this._collectedActions = [];
+    /** @internal Events relayed to other actors during the in-flight transition. */
+    this._collectedSent = [];
+    this.systemId = void 0;
+    /** The globally unique process ID for this invocation. */
+    this.sessionId = void 0;
+    /** The system to which this actor belongs. */
+    this.system = void 0;
+    this.trigger = void 0;
+    this.src = void 0;
+    // array of functions to defer
+    this._deferred = [];
+    // pending effects (timers) from a persisted snapshot, rescheduled on `start()`
+    this._pendingEffects = void 0;
+    const resolvedOptions = {
+      ...defaultOptions,
+      ...options
+    };
+    const {
+      clock,
+      logger,
+      parent,
+      syncSnapshot,
+      id,
+      systemId,
+      inspect
+    } = resolvedOptions;
+    this.system = parent ? parent.system : createSystem(this, {
+      clock,
+      logger,
+      timers: resolvedOptions.timers
+    });
+    if (inspect && !parent) {
+      // Always inspect at the system-level
+      this.system.inspect(toObserver(inspect));
+    }
+    this.sessionId = this.system._bookId();
+    this.id = id ?? this.sessionId;
+    this.logger = options?.logger ?? this.system._logger;
+    this.clock = options?.clock ?? this.system._clock;
+    this._parent = parent;
+    this._syncSnapshot = syncSnapshot;
+    this.options = resolvedOptions;
+    this.src = resolvedOptions.src ?? logic;
+    this.ref = this;
+    this._actorScope = {
+      self: this,
+      id: this.id,
+      sessionId: this.sessionId,
+      logger: this.logger,
+      defer: fn => {
+        this._deferred.push(fn);
+      },
+      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`);
+        }
+        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);
+            }
+          }
+        }
+        if (!wildcardListener) {
+          return;
+        }
+        for (const handler of wildcardListener) {
+          try {
+            handler(emittedEvent);
+          } catch (err) {
+            reportUnhandledError(err);
+          }
+        }
+      },
+      actionExecutor: action => {
+        const exec = () => {
+          // Record every executed action for the '@xstate.transition' inspection
+          // event's `actions[]` facet (replaces the v5 '@xstate.action' event).
+          this._collectedActions.push({
+            type: action.type,
+            params: action.params
+          });
+          if (!action.exec) {
+            return;
+          }
+          const saveExecutingCustomAction = executingCustomAction;
+          try {
+            executingCustomAction = true;
+            action.exec();
+          } finally {
+            executingCustomAction = saveExecutingCustomAction;
+          }
+        };
+        if (this._processingStatus === ProcessingStatus.Running) {
+          exec();
+        } else {
+          this._deferred.push(exec);
+        }
+      }
+    };
+
+    // Ensure that the send method is bound to this Actor instance
+    // if destructured
+    this.send = this.send.bind(this);
+    this.trigger = new Proxy({}, {
+      get: (_, eventType) => {
+        return payload => {
+          this.send({
+            ...payload,
+            type: eventType
+          });
+        };
+      }
+    });
+
+    // unified '@xstate.transition' event replaces '@xstate.actor'
+
+    if (systemId) {
+      this.systemId = systemId;
+      this.system._set(systemId, this);
+    }
+
+    // prepare to collect initial microsteps during getInitialSnapshot
+    this._collectedMicrosteps = [];
+    let persistedState = options?.snapshot ?? options?.state;
+    if (persistedState && typeof persistedState === 'object' && '_pendingEffects' in persistedState) {
+      // Pending effects are restored by this actor on `start()`; the logic
+      // only sees the rest of the persisted snapshot.
+      const {
+        _pendingEffects,
+        ...rest
+      } = persistedState;
+      this._pendingEffects = _pendingEffects;
+      persistedState = rest;
+    }
+    try {
+      this._snapshot = persistedState ? this.logic.restoreSnapshot ? this.logic.restoreSnapshot(persistedState, this._actorScope) : persistedState : this.logic.getInitialSnapshot(this._actorScope, this.options?.input);
+    } catch (err) {
+      // if we get here then it means that we assign a value to this._snapshot that is not of the correct type
+      // we can't get the true `TSnapshot & { status: 'error'; }`, it's impossible
+      // so right now this is a lie of sorts
+      this._snapshot = {
+        status: 'error',
+        output: undefined,
+        error: err
+      };
+      // discard any functions deferred during the failed initial snapshot
+      // computation so they can't run against an inconsistent actor
+      this._deferred.length = 0;
+    }
+    if (systemId && this._snapshot.status !== 'active') {
+      this.system._unregister(this);
+    }
+
+    // Announce actor topology: emitted once for every actor (root and every
+    // spawned/invoked child) so the actor graph can be drawn before any
+    // transitions occur. This is the only place actor identity is announced.
+    this.system._sendInspectionEvent({
+      type: '@xstate.actor',
+      actorRef: this,
+      parentRef: this._parent,
+      id: this.id,
+      src: this.src,
+      snapshot: this._snapshot
+    });
+  }
+  _setErrorSnapshot(err, snapshot = this._snapshot) {
+    this._snapshot = {
+      ...snapshot,
+      status: 'error',
+      error: err
+    };
+  }
+  _next(snapshot) {
+    for (const observer of this.observers) {
+      try {
+        observer.next?.(snapshot);
+      } catch (err) {
+        reportUnhandledError(err);
+      }
+    }
+  }
+  update(snapshot, event) {
+    // Update state
+    this._snapshot = snapshot;
+
+    // Execute deferred effects
+    for (let i = 0; i < this._deferred.length; i++) {
+      const deferredFn = this._deferred[i];
+      try {
+        deferredFn();
+      } catch (err) {
+        // this error can only be caught when executing *initial* actions
+        // it's the only time when we call actions provided by the user through those deferreds
+        // when the actor is already running we always execute them synchronously while transitioning
+        // 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;
+        this._setErrorSnapshot(err, snapshot);
+        break;
+      }
+    }
+    this._deferred.length = 0;
+    switch (this._snapshot.status) {
+      case 'active':
+        this._next(snapshot);
+        break;
+      case 'done':
+        {
+          // next observers are meant to be notified about done snapshots
+          // this can be seen as something that is different from how observable work
+          // but with observables `complete` callback is called without any arguments
+          // it's more ergonomic for XState to treat a done snapshot as a "next" value
+          // and the completion event as something that is separate,
+          // something that merely follows emitting that done snapshot
+          this._next(snapshot);
+          this._stopProcedure();
+          this._complete();
+          const doneEvent = createDoneActorEvent(this.id, this._snapshot.output);
+          if (this._parent) {
+            this.system._relay(this, this._parent, doneEvent);
+          }
+          break;
+        }
+      case 'error':
+        this._error(this._snapshot.error);
+        break;
+    }
+    this.system._sendInspectionEvent({
+      type: '@xstate.transition',
+      actorRef: this,
+      event,
+      sourceRef: this._lastSourceRef,
+      targetRef: this,
+      snapshot,
+      microsteps: this._collectedMicrosteps,
+      actions: this._collectedActions,
+      sent: this._collectedSent,
+      eventType: event.type
+    });
+    // reset facets after emission
+    this._collectedMicrosteps = [];
+    this._collectedActions = [];
+    this._collectedSent = [];
+  }
+
+  /**
+   * Subscribe an observer to an actor’s snapshot values.
+   *
+   * @remarks
+   * The observer will receive the actor’s snapshot value when it is emitted.
+   * The observer can be:
+   *
+   * - A plain function that receives the latest snapshot, or
+   * - An observer object whose `.next(snapshot)` method receives the latest
+   *   snapshot
+   *
+   * @example
+   *
+   * ```ts
+   * // Observer as a plain function
+   * const subscription = actor.subscribe((snapshot) => {
+   *   console.log(snapshot);
+   * });
+   * ```
+   *
+   * @example
+   *
+   * ```ts
+   * // Observer as an object
+   * const subscription = actor.subscribe({
+   *   next(snapshot) {
+   *     console.log(snapshot);
+   *   },
+   *   error(err) {
+   *     // ...
+   *   },
+   *   complete() {
+   *     // ...
+   *   }
+   * });
+   * ```
+   *
+   * The return value of `actor.subscribe(observer)` is a subscription object
+   * that has an `.unsubscribe()` method. You can call
+   * `subscription.unsubscribe()` to unsubscribe the observer:
+   *
+   * @example
+   *
+   * ```ts
+   * const subscription = actor.subscribe((snapshot) => {
+   *   // ...
+   * });
+   *
+   * // Unsubscribe the observer
+   * subscription.unsubscribe();
+   * ```
+   *
+   * When the actor is stopped, all of its observers will automatically be
+   * unsubscribed.
+   *
+   * @param observer - Either a plain function that receives the latest
+   *   snapshot, or an observer object whose `.next(snapshot)` method receives
+   *   the latest snapshot
+   */
+
+  subscribe(nextListenerOrObserver, errorListener, completeListener) {
+    const observer = toObserver(nextListenerOrObserver, errorListener, completeListener);
+    if (this._processingStatus !== ProcessingStatus.Stopped) {
+      this.observers.add(observer);
+    } else {
+      switch (this._snapshot.status) {
+        case 'done':
+          try {
+            observer.complete?.();
+          } catch (err) {
+            reportUnhandledError(err);
+          }
+          break;
+        case 'error':
+          {
+            const err = this._snapshot.error;
+            if (!observer.error) {
+              reportUnhandledError(err);
+            } else {
+              try {
+                observer.error(err);
+              } catch (err) {
+                reportUnhandledError(err);
+              }
+            }
+            break;
+          }
+      }
+    }
+    return {
+      unsubscribe: () => {
+        this.observers.delete(observer);
+      }
+    };
+  }
+  on(type, handler) {
+    let listeners = this.eventListeners.get(type);
+    if (!listeners) {
+      listeners = new Set();
+      this.eventListeners.set(type, listeners);
+    }
+    listeners.add(handler);
+    return {
+      unsubscribe: () => {
+        listeners.delete(handler);
+      }
+    };
+  }
+  select(selector, equalityFn = Object.is) {
+    return {
+      subscribe: (observerOrFn, errorListener, completeListener) => {
+        const observer = toObserver(observerOrFn, errorListener, completeListener);
+        let selected = selector(this.getSnapshot());
+        return this.subscribe({
+          next: snapshot => {
+            const next = selector(snapshot);
+            if (!equalityFn(selected, next)) {
+              selected = next;
+              observer.next?.(next);
+            }
+          },
+          error: observer.error,
+          complete: observer.complete
+        });
+      },
+      get: () => selector(this.get())
+    };
+  }
+
+  /** Starts the Actor from the initial state */
+  start() {
+    if (this._processingStatus === ProcessingStatus.Running) {
+      // Do not restart the service if it is already started
+      return this;
+    }
+    if (this._syncSnapshot) {
+      this.subscribe({
+        next: snapshot => {
+          if (snapshot.status === 'active') {
+            this.system._relay(this, this._parent, {
+              type: `xstate.snapshot.${this.id}`,
+              snapshot
+            });
+          }
+        },
+        error: () => {}
+      });
+    }
+    this.system._register(this.sessionId, this);
+    if (this.systemId) {
+      this.system._set(this.systemId, this);
+    }
+    this._processingStatus = ProcessingStatus.Running;
+
+    // TODO: this isn't correct when rehydrating
+    const initEvent = createInitEvent(this.options.input);
+    // remember source of init as parent for unified transition event
+    this._lastSourceRef = this._parent;
+    const status = this._snapshot.status;
+    switch (status) {
+      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
+        this.update(this._snapshot, initEvent);
+        // TODO: rethink cleanup of observers, mailbox, etc
+        return this;
+      case 'error':
+        this._error(this._snapshot.error);
+        return this;
+    }
+    if (!this._parent) {
+      this.system.start();
+    }
+    if (this.logic.start) {
+      try {
+        this.logic.start(this._snapshot, this._actorScope);
+      } catch (err) {
+        this._setErrorSnapshot(err);
+        this._error(err);
+        return this;
+      }
+    }
+
+    // TODO: this notifies all subscribers but usually this is redundant
+    // there is no real change happening here
+    // we need to rethink if this needs to be refactored
+    this.update(this._snapshot, initEvent);
+    if (this._pendingEffects) {
+      const strategy = this.options.timers ?? this.system._timerStrategy ?? 'resume';
+      for (const effect of this._pendingEffects) {
+        // Re-execute the pending effect with its remaining delay. Only
+        // self-targeted raises exist today; other effect types are ignored.
+        if (effect.type === '@xstate.raise') {
+          this.system.scheduler.schedule(this, this, effect.event, resolveRestoredTimerDelay(strategy, effect), effect.id);
+        }
+      }
+      this._pendingEffects = undefined;
+    }
+    this.mailbox.start();
+    return this;
+  }
+  _process(event) {
+    let nextState;
+    let caughtError;
+    try {
+      nextState = this.logic.transition(this._snapshot, event, this._actorScope);
+    } catch (err) {
+      // we wrap it in a box so we can rethrow it later even if falsy value gets caught here
+      caughtError = {
+        err
+      };
+    }
+    if (caughtError) {
+      const {
+        err
+      } = caughtError;
+      this._setErrorSnapshot(err);
+      this._error(err);
+      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();
+    }
+  }
+
+  /** @internal */
+  _stop() {
+    if (this._processingStatus === ProcessingStatus.Stopped) {
+      return this;
+    }
+    this.mailbox.clear();
+    if (this._processingStatus === ProcessingStatus.NotStarted) {
+      this._processingStatus = ProcessingStatus.Stopped;
+      return this;
+    }
+    this.mailbox.enqueue({
+      type: XSTATE_STOP
+    });
+    this.system._unregister(this);
+    return this;
+  }
+
+  /** Stops the Actor and unsubscribe all listeners. */
+  stop() {
+    if (this._parent) {
+      throw new Error('A non-root actor cannot be stopped directly.');
+    }
+    return this._stop();
+  }
+  _complete() {
+    for (const observer of this.observers) {
+      try {
+        observer.complete?.();
+      } catch (err) {
+        reportUnhandledError(err);
+      }
+    }
+    this.observers.clear();
+    this.eventListeners.clear();
+  }
+  _error(err) {
+    this._stopProcedure();
+    if (!this.observers.size) {
+      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);
+        }
+      }
+      this.observers.clear();
+      this.eventListeners.clear();
+      if (reportError) {
+        reportUnhandledError(err);
+      }
+    }
+    if (this._parent) {
+      this.system._relay(this, this._parent, createErrorActorEvent(this.id, err));
+    }
+  }
+  // TODO: atm children don't belong entirely to the actor so
+  // in a way - it's not even super aware of them
+  // so we can't stop them from here but we really should!
+  // right now, they are being stopped within the machine's transition
+  // but that could throw and leave us with "orphaned" active actors
+  _stopProcedure() {
+    if (this._processingStatus !== ProcessingStatus.Running) {
+      // Actor already stopped; do nothing
+      return;
+    }
+
+    // Cancel all delayed events
+    this.system.scheduler.cancelAll(this);
+
+    // TODO: mailbox.reset
+    this.mailbox.clear();
+    // TODO: after `stop` we must prepare ourselves for receiving events again
+    // events sent *after* stop signal must be queued
+    // it seems like this should be the common behavior for all of our consumers
+    // so perhaps this should be unified somehow for all of them
+    this.mailbox = new Mailbox(this._boundProcess);
+    this._processingStatus = ProcessingStatus.Stopped;
+    this.system._unregister(this);
+  }
+
+  /** @internal */
+  _send(event) {
+    if (this._processingStatus === ProcessingStatus.Stopped) {
+      return;
+    }
+    this.mailbox.enqueue(event);
+  }
+
+  /**
+   * Sends an event to the running Actor to trigger a transition.
+   *
+   * @param event The event to send
+   */
+  send(event) {
+    this.system._relay(undefined, this, event);
+  }
+  toJSON() {
+    return {
+      xstate$$type: $$ACTOR_TYPE,
+      id: this.id
+    };
+  }
+
+  /**
+   * Obtain the internal state of the actor, which can be persisted.
+   *
+   * @remarks
+   * The internal state can be persisted from any actor, not only machines.
+   *
+   * Note that the persisted state is not the same as the snapshot from
+   * {@link Actor.getSnapshot}. Persisted state represents the internal state of
+   * the actor, while snapshots represent the actor's last emitted value.
+   *
+   * Can be restored with {@link ActorOptions.state}
+   * @see https://stately.ai/docs/persistence
+   */
+
+  getPersistedSnapshot(options) {
+    const persisted = this.logic.getPersistedSnapshot(this._snapshot, options);
+
+    // Capture this actor's pending self-targeted effects (delayed
+    // events/transitions) as serialized action descriptors plus their
+    // runtime progress, so they can be restored on `start()`.
+    const scheduledEvents = this.system._snapshot._scheduledEvents;
+    let pendingEffects;
+    const now = Date.now();
+    for (const key in scheduledEvents) {
+      const scheduled = scheduledEvents[key];
+      if (scheduled.source === this && scheduled.target === this) {
+        (pendingEffects ??= []).push({
+          type: '@xstate.raise',
+          event: scheduled.event,
+          id: scheduled.id,
+          delay: scheduled.delay,
+          startedAt: scheduled.startedAt,
+          elapsed: Math.max(0, now - scheduled.startedAt)
+        });
+      }
+    }
+
+    // If this actor was restored but not yet started, its pending effects
+    // are not in the scheduler yet — carry them through as-is.
+    pendingEffects ??= this._pendingEffects;
+    return pendingEffects ? {
+      ...persisted,
+      _pendingEffects: pendingEffects
+    } : persisted;
+  }
+  [symbolObservable]() {
+    return this;
+  }
+
+  /**
+   * Read an actor’s snapshot synchronously.
+   *
+   * @remarks
+   * The snapshot represent an actor's last emitted value.
+   *
+   * When an actor receives an event, its internal state may change. An actor
+   * may emit a snapshot when a state transition occurs.
+   *
+   * Note that some actors, such as callback actors generated with
+   * `createCallbackLogic`, will not emit snapshots.
+   * @see {@link Actor.subscribe} to subscribe to an actor’s snapshot values.
+   * @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() {
+    onActorRead?.(this);
+    return this._snapshot;
+  }
+}
+function resolveRestoredTimerDelay(strategy, effect) {
+  if (typeof strategy === 'function') {
+    return strategy(effect);
+  }
+  switch (strategy) {
+    case 'restart':
+      return effect.delay;
+    case 'absolute':
+      return Math.max(0, effect.startedAt + effect.delay - Date.now());
+    case 'resume':
+    default:
+      return Math.max(0, effect.delay - effect.elapsed);
+  }
+}
+/**
+ * Creates a new actor instance for the given actor logic with the provided
+ * options, if any.
+ *
+ * @remarks
+ * When you create an actor from actor logic via `createActor(logic)`, you
+ * implicitly create an actor system where the created actor is the root actor.
+ * Any actors spawned from this root actor and its descendants are part of that
+ * actor system.
+ * @example
+ *
+ * ```ts
+ * import { createActor } from 'xstate';
+ * import { someActorLogic } from './someActorLogic.ts';
+ *
+ * // Creating the actor, which implicitly creates an actor system with itself as the root actor
+ * const actor = createActor(someActorLogic);
+ *
+ * actor.subscribe((snapshot) => {
+ *   console.log(snapshot);
+ * });
+ *
+ * // Actors must be started by calling `actor.start()`, which will also start the actor system.
+ * actor.start();
+ *
+ * // Actors can receive events
+ * actor.send({ type: 'someEvent' });
+ *
+ * // You can stop root actors by calling `actor.stop()`, which will also stop the actor system and all actors in that system.
+ * actor.stop();
+ * ```
+ *
+ * @param logic - The actor logic to create an actor from. For a state machine
+ *   actor logic creator, see {@link createMachine}. Other actor logic creators
+ *   include {@link createCallbackLogic}, {@link createEventObservableLogic},
+ *   {@link createObservableLogic}, {@link createLogic}, and
+ *   {@link createAsyncLogic}.
+ * @param options - Actor options
+ */
+function createActor(logic, options) {
+  return new Actor(logic, options);
+}
+
+const instanceStates = /* #__PURE__ */new WeakMap();
+
+/**
+ * Represents an actor created by `createCallbackLogic`.
+ *
+ * The type of `self` within the actor's logic.
+ *
+ * @example
+ *
+ * ```ts
+ * import { createCallbackLogic, createActor } from 'xstate';
+ *
+ * // The events the actor receives.
+ * type Event = { type: 'someEvent' };
+ * // The actor's input.
+ * type Input = { name: string };
+ *
+ * // Actor logic that logs whenever it receives an event of type `someEvent`.
+ * const logic = createCallbackLogic<Event, Input>(
+ *   ({ self, input, receive }) => {
+ *     self;
+ *     // ^? CallbackActorRef<Event, Input>
+ *
+ *     receive((event) => {
+ *       if (event.type === 'someEvent') {
+ *         console.log(`${input.name}: received "someEvent" event`);
+ *         // logs 'myActor: received "someEvent" event'
+ *       }
+ *     });
+ *   }
+ * );
+ *
+ * const actor = createActor(logic, { input: { name: 'myActor' } });
+ * //    ^? CallbackActorRef<Event, Input>
+ * ```
+ *
+ * @see {@link createCallbackLogic}
+ */
+
+/**
+ * An actor logic creator which returns callback logic as defined by a callback
+ * function.
+ *
+ * @remarks
+ * Useful for subscription-based or other free-form logic that can send events
+ * back to the parent actor.
+ *
+ * Actors created from callback logic (“callback actors”) can:
+ *
+ * - Receive events via the `receive` function
+ * - Send events to the parent actor via the `sendBack` function
+ *
+ * Callback actors are a bit different from other actors in that they:
+ *
+ * - Do not work with `onDone`
+ * - Do not produce a snapshot using `.getSnapshot()`
+ * - Do not emit values when used with `.subscribe()`
+ * - Can not be stopped with `.stop()`
+ *
+ * @example
+ *
+ * ```typescript
+ * const callbackLogic = createCallbackLogic(({ sendBack, receive }) => {
+ *   let lockStatus = 'unlocked';
+ *
+ *   const handler = (event) => {
+ *     if (lockStatus === 'locked') {
+ *       return;
+ *     }
+ *     sendBack(event);
+ *   };
+ *
+ *   receive((event) => {
+ *     if (event.type === 'lock') {
+ *       lockStatus = 'locked';
+ *     } else if (event.type === 'unlock') {
+ *       lockStatus = 'unlocked';
+ *     }
+ *   });
+ *
+ *   document.body.addEventListener('click', handler);
+ *
+ *   return () => {
+ *     document.body.removeEventListener('click', handler);
+ *   };
+ * });
+ * ```
+ *
+ * @param callback - The callback function used to describe the callback logic
+ *   The callback function is passed an object with the following properties:
+ *
+ *   - `receive` - A function that can send events back to the parent actor; the
+ *       listener is then called whenever events are received by the callback
+ *       actor
+ *   - `sendBack` - A function that can send events back to the parent actor
+ *   - `input` - Data that was provided to the callback actor
+ *   - `self` - The parent actor of the callback actor
+ *   - `system` - The actor system to which the callback actor belongs The callback
+ *       function can (optionally) return a cleanup function, which is called
+ *       when the actor is stopped.
+ *
+ * @returns Callback logic
+ * @see {@link CallbackLogicFunction} for more information about the callback function and its object argument
+ * @see {@link https://stately.ai/docs/input | Input docs} for more information about how input is passed
+ */
+
+function createCallbackLogic(callbackOrConfig) {
+  const callback = typeof callbackOrConfig === 'function' ? callbackOrConfig : callbackOrConfig.run;
+  const schemas = typeof callbackOrConfig === 'function' ? undefined : callbackOrConfig.schemas;
+  return createLogic({
+    schemas,
+    context: undefined,
+    run: (args, enq) => {
+      const {
+        event,
+        input,
+        self,
+        system
+      } = args;
+      const emit = args.emit;
+      const callbackState = instanceStates.get(self);
+      callbackState?.receivers?.forEach(receiver => receiver(event));
+      enq.effect('callback', () => {
+        const callbackState = {
+          receivers: undefined,
+          dispose: undefined
+        };
+        instanceStates.set(self, callbackState);
+        callbackState.dispose = callback({
+          input,
+          system,
+          self: self,
+          sendBack: event => {
+            if (self.getSnapshot().status === 'stopped') {
+              return;
+            }
+            const parent = self._parent;
+            if (parent) {
+              system._relay(self, parent, event);
+            }
+          },
+          receive: listener => {
+            callbackState.receivers ??= new Set();
+            callbackState.receivers.add(listener);
+          },
+          emit: emit
+        });
+        return () => {
+          instanceStates.delete(self);
+          callbackState.receivers?.clear();
+          callbackState.dispose?.();
+        };
+      });
+    }
+  });
+}
+
+const XSTATE_OBSERVABLE_NEXT = 'xstate.observable.next';
+const XSTATE_OBSERVABLE_ERROR = 'xstate.observable.error';
+const XSTATE_OBSERVABLE_COMPLETE = 'xstate.observable.complete';
+
+/**
+ * Represents an actor created by `createObservableLogic` or
+ * `createEventObservableLogic`.
+ *
+ * The type of `self` within the actor's logic.
+ *
+ * @example
+ *
+ * ```ts
+ * import { createObservableLogic, createActor } from 'xstate';
+ * import { interval } from 'rxjs';
+ *
+ * // The type of the value observed by the actor's logic.
+ * type Context = number;
+ * // The actor's input.
+ * type Input = { period?: number };
+ *
+ * // Actor logic that observes a number incremented every `input.period`
+ * // milliseconds (default: 1_000).
+ * const logic = createObservableLogic<Context, Input>(
+ *   ({ input, self }) => {
+ *     self;
+ *     // ^? ObservableActor<Event, Input>
+ *
+ *     return interval(input.period ?? 1_000);
+ *   }
+ * );
+ *
+ * const actor = createActor(logic, { input: { period: 2_000 } });
+ * //    ^? ObservableActor<Event, Input>
+ * ```
+ *
+ * @see {@link createObservableLogic}
+ * @see {@link createEventObservableLogic}
+ */
+
+/**
+ * Observable actor logic is described by an observable stream of values. Actors
+ * created from observable logic (“observable actors”) can:
+ *
+ * - Emit snapshots of the observable’s emitted value
+ *
+ * The observable’s emitted value is used as its observable actor’s `context`.
+ *
+ * Sending events to observable actors will have no effect.
+ *
+ * @example
+ *
+ * ```ts
+ * import { createObservableLogic, createActor } from 'xstate';
+ * import { interval } from 'rxjs';
+ *
+ * const logic = createObservableLogic((obj) => interval(1000));
+ *
+ * const actor = createActor(logic);
+ *
+ * actor.subscribe((snapshot) => {
+ *   console.log(snapshot.context);
+ * });
+ *
+ * actor.start();
+ * // At every second:
+ * // Logs 0
+ * // Logs 1
+ * // Logs 2
+ * // ...
+ * ```
+ *
+ * @param observableCreator A function that creates an observable. It receives
+ *   one argument, an object with the following properties:
+ *
+ *   - `input` - Data that was provided to the observable actor
+ *   - `self` - The parent actor
+ *   - `system` - The actor system to which the observable actor belongs
+ *
+ *   It should return a {@link Subscribable}, which is compatible with an RxJS
+ *   Observable, although RxJS is not required to create them.
+ * @see {@link https://rxjs.dev} for documentation on RxJS Observable and observable creators.
+ * @see {@link Subscribable} interface in XState, which is based on and compatible with RxJS Observable.
+ */
+
+function createObservableLogic(observableCreatorOrConfig) {
+  const observableCreator = typeof observableCreatorOrConfig === 'function' ? observableCreatorOrConfig : observableCreatorOrConfig.run;
+  const schemas = typeof observableCreatorOrConfig === 'function' ? undefined : observableCreatorOrConfig.schemas;
+  return createLogic({
+    schemas,
+    context: undefined,
+    run: (args, enq) => {
+      const {
+        event,
+        input,
+        self,
+        system
+      } = args;
+      const emit = args.emit;
+      switch (event.type) {
+        case XSTATE_OBSERVABLE_NEXT:
+          {
+            return {
+              context: event.data
+            };
+          }
+        case XSTATE_OBSERVABLE_ERROR:
+          return {
+            status: 'error',
+            error: event.data,
+            input: undefined,
+            effects: {
+              observable: {
+                status: 'error',
+                error: event.data
+              }
+            }
+          };
+        case XSTATE_OBSERVABLE_COMPLETE:
+          return {
+            status: 'done',
+            input: undefined,
+            effects: {
+              observable: {
+                status: 'done'
+              }
+            }
+          };
+      }
+      enq.effect('observable', () => {
+        const actorSelf = self;
+        const subscription = observableCreator({
+          input,
+          system,
+          self: self,
+          emit: emit
+        }).subscribe({
+          next: value => {
+            system._relay(actorSelf, actorSelf, {
+              type: XSTATE_OBSERVABLE_NEXT,
+              data: value
+            });
+          },
+          error: err => {
+            system._relay(actorSelf, actorSelf, {
+              type: XSTATE_OBSERVABLE_ERROR,
+              data: err
+            });
+          },
+          complete: () => {
+            system._relay(actorSelf, actorSelf, {
+              type: XSTATE_OBSERVABLE_COMPLETE
+            });
+          }
+        });
+        return () => subscription.unsubscribe();
+      });
+    }
+  });
+}
+
+/**
+ * Creates event observable logic that listens to an observable that delivers
+ * event objects.
+ *
+ * Event observable actor logic is described by an observable stream of
+ * {@link https://stately.ai/docs/transitions#event-objects | event objects}.
+ * Actors created from event observable logic (“event observable actors”) can:
+ *
+ * - Implicitly send events to its parent actor
+ * - Emit snapshots of its emitted event objects
+ *
+ * Sending events to event observable actors will have no effect.
+ *
+ * @example
+ *
+ * ```ts
+ * import {
+ *   createEventObservableLogic,
+ *   Subscribable,
+ *   EventObject,
+ *   createMachine,
+ *   createActor
+ * } from 'xstate';
+ * import { fromEvent } from 'rxjs';
+ *
+ * const mouseClickLogic = createEventObservableLogic(
+ *   () => fromEvent(document.body, 'click') as Subscribable<EventObject>
+ * );
+ *
+ * const canvasMachine = createMachine({
+ *   invoke: {
+ *     // Will send mouse `click` events to the canvas actor
+ *     src: mouseClickLogic
+ *   }
+ * });
+ *
+ * const canvasActor = createActor(canvasMachine);
+ * canvasActor.start();
+ * ```
+ *
+ * @param lazyObservable A function that creates an observable that delivers
+ *   event objects. It receives one argument, an object with the following
+ *   properties:
+ *
+ *   - `input` - Data that was provided to the event observable actor
+ *   - `self` - The parent actor
+ *   - `system` - The actor system to which the event observable actor belongs.
+ *
+ *   It should return a {@link Subscribable}, which is compatible with an RxJS
+ *   Observable, although RxJS is not required to create them.
+ */
+
+function createEventObservableLogic(lazyObservableOrConfig) {
+  const lazyObservable = typeof lazyObservableOrConfig === 'function' ? lazyObservableOrConfig : lazyObservableOrConfig.run;
+
+  // TODO: event types
+  const logic = {
+    config: lazyObservable,
+    transition: (state, event) => {
+      if (state.status !== 'active') {
+        return state;
+      }
+      switch (event.type) {
+        case XSTATE_OBSERVABLE_ERROR:
+          return {
+            ...state,
+            status: 'error',
+            error: event.data,
+            input: undefined,
+            _subscription: undefined
+          };
+        case XSTATE_OBSERVABLE_COMPLETE:
+          return {
+            ...state,
+            status: 'done',
+            input: undefined,
+            _subscription: undefined
+          };
+        case XSTATE_STOP:
+          state._subscription.unsubscribe();
+          return {
+            ...state,
+            status: 'stopped',
+            input: undefined,
+            _subscription: undefined
+          };
+        default:
+          return state;
+      }
+    },
+    getInitialSnapshot: (_, input) => {
+      return {
+        status: 'active',
+        output: undefined,
+        error: undefined,
+        context: undefined,
+        input,
+        _subscription: undefined
+      };
+    },
+    start: (state, {
+      self,
+      system,
+      emit
+    }) => {
+      if (state.status === 'done') {
+        // Do not restart a completed observable
+        return;
+      }
+      state._subscription = lazyObservable({
+        input: state.input,
+        system,
+        self,
+        emit
+      }).subscribe({
+        next: value => {
+          if (self._parent) {
+            system._relay(self, self._parent, value);
+          }
+        },
+        error: err => {
+          system._relay(self, self, {
+            type: XSTATE_OBSERVABLE_ERROR,
+            data: err
+          });
+        },
+        complete: () => {
+          system._relay(self, self, {
+            type: XSTATE_OBSERVABLE_COMPLETE
+          });
+        }
+      });
+    },
+    getPersistedSnapshot: ({
+      _subscription,
+      ...snapshot
+    }) => snapshot,
+    restoreSnapshot: snapshot => ({
+      ...snapshot,
+      _subscription: undefined
+    })
+  };
+  return logic;
+}
+
+const XSTATE_ASYNC_RESOLVE = 'xstate.async.resolve';
+const XSTATE_ASYNC_REJECT = 'xstate.async.reject';
+class TimeoutError extends Error {
+  constructor(timeout) {
+    super(`Async logic timed out after ${timeout}.`);
+    this.name = 'TimeoutError';
+  }
+}
+
+/**
+ * Represents an actor created by `createAsyncLogic`.
+ *
+ * The type of `self` within the actor's logic.
+ *
+ * @example
+ *
+ * ```ts
+ * import { createAsyncLogic, createActor } from 'xstate';
+ *
+ * // The actor's resolved output
+ * type Output = string;
+ * // The actor's input.
+ * type Input = { message: string };
+ *
+ * // Actor logic that fetches the url of an image of a cat saying `input.message`.
+ * const logic = createAsyncLogic<Output, Input>({
+ *   run: async ({ input, self }, enq) => {
+ *     self;
+ *     // ^? AsyncActor<Output, Input>
+ *     enq.emit({ type: 'request.start' });
+ *
+ *     const data = await fetch(
+ *       `https://cataas.com/cat/says/${input.message}`
+ *     );
+ *     const url = await data.json();
+ *     return url;
+ *   }
+ * });
+ *
+ * const actor = createActor(logic, { input: { message: 'hello world' } });
+ * //    ^? AsyncActor<Output, Input>
+ * ```
+ *
+ * @see {@link createAsyncLogic}
+ */
+
+/**
+ * An actor logic creator which returns async logic as defined by an async
+ * process that resolves or rejects after some time.
+ *
+ * Actors created from async actor logic can:
+ *
+ * - Output the resolved value of the async process
+ * - Error with the rejected value of the async process
+ * - Abort when stopped or timed out
+ *
+ * Sending events to async actors will have no effect.
+ *
+ * @example
+ *
+ * ```ts
+ * const asyncLogic = createAsyncLogic({
+ *   id: 'fetch-user',
+ *   timeout: '30s',
+ *   run: async ({ signal }, enq) => {
+ *     enq.emit({ type: 'request.start' });
+ *     const result = await fetch('https://example.com/...', {
+ *       signal
+ *     }).then((data) => data.json());
+ *
+ *     return result;
+ *   }
+ * });
+ *
+ * const asyncActor = createActor(asyncLogic);
+ * asyncActor.subscribe((snapshot) => {
+ *   console.log(snapshot);
+ * });
+ * asyncActor.start();
+ * // => {
+ * //   output: undefined,
+ * //   status: 'active'
+ * //   ...
+ * // }
+ *
+ * // After promise resolves
+ * // => {
+ * //   output: { ... },
+ * //   status: 'done',
+ * //   ...
+ * // }
+ * ```
+ *
+ * @param asyncLogic A config object with a `run` function which returns a
+ *   Promise, and accepts an object with the following properties:
+ *
+ *   - `input` - Data that was provided to the async actor
+ *   - `self` - The async actor ref
+ *   - `system` - The actor system to which the async actor belongs
+ *   - `signal` - An abort signal for cancellation
+ *
+ *   `run` also receives an `enq` object with the following properties:
+ *
+ *   - `emit` - Emits an event that can be observed with `actor.on(...)`
+ *
+ * @see {@link https://stately.ai/docs/input | Input docs} for more information about how input is passed
+ */
+
+function createAsyncLogic(asyncLogic) {
+  const config = asyncLogic;
+  function waitForEffect(self, key) {
+    return new Promise((resolve, reject) => {
+      const subscription = self.subscribe(snapshot => {
+        const effect = snapshot.effects?.[key];
+        if (effect?.status === 'done') {
+          subscription.unsubscribe();
+          resolve(effect.output);
+        } else if (effect?.status === 'error') {
+          subscription.unsubscribe();
+          reject(effect.error);
+        }
+      });
+    });
+  }
+  return createLogic({
+    id: config.id,
+    schemas: config.schemas,
+    context: undefined,
+    run: ({
+      event,
+      input,
+      self,
+      system
+    }, enq) => {
+      switch (event.type) {
+        case XSTATE_ASYNC_RESOLVE:
+          {
+            const resolvedValue = event.data ?? event.output;
+            return {
+              status: 'done',
+              output: resolvedValue,
+              input: undefined,
+              effects: {
+                async: {
+                  status: 'done',
+                  output: resolvedValue
+                }
+              }
+            };
+          }
+        case XSTATE_ASYNC_REJECT:
+          {
+            const error = event.data ?? event.error;
+            return {
+              status: 'error',
+              error,
+              input: undefined,
+              effects: {
+                async: {
+                  status: 'error',
+                  error
+                }
+              }
+            };
+          }
+      }
+      if (event.type !== XSTATE_INIT) {
+        return;
+      }
+      enq.effect(() => {
+        const actorSelf = self;
+        const controller = new AbortController();
+        const timeout = config.timeout;
+        const timeoutMs = parseDelayToMilliseconds(timeout);
+        const timeoutId = timeoutMs === undefined ? undefined : system._clock.setTimeout(() => {
+          if (self.getSnapshot().status !== 'active') {
+            return;
+          }
+          controller.abort();
+          system._relay(actorSelf, actorSelf, {
+            type: XSTATE_ASYNC_REJECT,
+            data: new TimeoutError(timeout)
+          });
+        }, timeoutMs);
+        const clearTimeout = () => {
+          if (timeoutId !== undefined) {
+            system._clock.clearTimeout(timeoutId);
+          }
+        };
+        const resolvedPromise = Promise.resolve(config.run({
+          input,
+          system,
+          self: self,
+          signal: controller.signal
+        }, {
+          emit: enq.emit,
+          step: async (key, exec) => {
+            const effect = self.getSnapshot().effects?.[key];
+            if (effect?.status === 'done') {
+              return effect.output;
+            }
+            if (effect?.status === 'error') {
+              throw effect.error;
+            }
+            if (effect?.status === 'active') {
+              return waitForEffect(self, key);
+            }
+            system._relay(actorSelf, actorSelf, {
+              type: XSTATE_LOGIC_EFFECT_START,
+              key
+            });
+            try {
+              const output = await exec();
+              system._relay(actorSelf, actorSelf, {
+                type: XSTATE_LOGIC_EFFECT_RESOLVE,
+                key,
+                output
+              });
+              return output;
+            } catch (error) {
+              system._relay(actorSelf, actorSelf, {
+                type: XSTATE_LOGIC_EFFECT_REJECT,
+                key,
+                error
+              });
+              throw error;
+            }
+          }
+        }));
+        resolvedPromise.then(response => {
+          clearTimeout();
+          if (self.getSnapshot().status !== 'active') {
+            return;
+          }
+          system._relay(actorSelf, actorSelf, {
+            type: XSTATE_ASYNC_RESOLVE,
+            data: response
+          });
+        }, errorData => {
+          clearTimeout();
+          if (self.getSnapshot().status !== 'active') {
+            return;
+          }
+          system._relay(actorSelf, actorSelf, {
+            type: XSTATE_ASYNC_REJECT,
+            data: errorData
+          });
+        });
+        return () => {
+          controller.abort();
+          clearTimeout();
+        };
+      });
+      return {
+        effects: {
+          async: {
+            status: 'active'
+          }
+        }
+      };
+    }
+  });
+}
+
+const emptyLogic = /* #__PURE__ */createLogic({
+  context: undefined,
+  run: () => undefined
+});
+function createEmptyActor() {
+  return createActor(emptyLogic);
+}
+
+exports.$$ACTOR_TYPE = $$ACTOR_TYPE;
+exports.Actor = Actor;
+exports.NULL_EVENT = NULL_EVENT;
+exports.ProcessingStatus = ProcessingStatus;
+exports.STATE_DELIMITER = STATE_DELIMITER;
+exports.TimeoutError = TimeoutError;
+exports.XSTATE_INIT = XSTATE_INIT;
+exports.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;
+exports.createInitEvent = createInitEvent;
+exports.createInvokeId = createInvokeId;
+exports.createInvokeTimeoutEvent = createInvokeTimeoutEvent;
+exports.createListenerLogic = createListenerLogic;
+exports.createLogic = createLogic;
+exports.createMachineSnapshot = createMachineSnapshot;
+exports.createObservableLogic = createObservableLogic;
+exports.createReducerAtom = createReducerAtom;
+exports.createSubscriptionLogic = createSubscriptionLogic;
+exports.evaluateCandidate = evaluateCandidate;
+exports.formatRouteTransitions = formatRouteTransitions;
+exports.formatTransition = formatTransition;
+exports.getAllOwnEventDescriptors = getAllOwnEventDescriptors;
+exports.getAllStateNodes = getAllStateNodes;
+exports.getCandidates = getCandidates;
+exports.getDelayedTransitions = getDelayedTransitions;
+exports.getPersistedSnapshot = getPersistedSnapshot;
+exports.getProperAncestors = getProperAncestors;
+exports.getStateNodeByPath = getStateNodeByPath;
+exports.getStateNodes = getStateNodes;
+exports.initialMicrostep = initialMicrostep;
+exports.isAtom = isAtom;
+exports.isAtomicStateNode = isAtomicStateNode;
+exports.isInFinalState = isInFinalState;
+exports.isMachineSnapshot = isMachineSnapshot;
+exports.isStateId = isStateId;
+exports.listenerLogic = listenerLogic;
+exports.macrostep = macrostep;
+exports.mapValues = mapValues;
+exports.matchesEventDescriptor = matchesEventDescriptor;
+exports.matchesState = matchesState;
+exports.parseDelayToMilliseconds = parseDelayToMilliseconds;
+exports.pathToStateValue = pathToStateValue;
+exports.resolveAndExecuteActionsWithContext = resolveAndExecuteActionsWithContext;
+exports.resolveReferencedActor = resolveReferencedActor;
+exports.resolveStateValue = resolveStateValue;
+exports.subscriptionLogic = subscriptionLogic;
+exports.toArray = toArray;
+exports.toObserver = toObserver;
+exports.toStatePath = toStatePath;
+exports.toTransitionConfigArray = toTransitionConfigArray;
+exports.transitionNode = transitionNode;