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

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

@@ -1,16 +1,3 @@
-/**
- * Reactivity interop between actors and atoms.
- *
- * `Actor#get()` calls this hook (when installed) so that computed atoms can
- * track actor reads as dependencies. The hook is installed by `atom.ts` on
- * module evaluation, which only happens when atoms are actually used — apps
- * that never import atoms don't bundle the reactive system.
- */
-let onActorRead;
-function installActorReadHook(hook) {
-  onActorRead = hook;
-}
-
 class Mailbox {
   constructor(_process) {
     this._process = _process;
@@ -186,7 +173,7 @@ const builtInActions = {
   ['@xstate.cancel']: (actorScope, sendId) => {
     actorScope.system.scheduler.cancel(actorScope.self, sendId);
   },
-  ['@xstate.stopChild']: (actorScope, actor) => {
+  ['@xstate.stop']: (actorScope, actor) => {
     actorScope.stopChild(actor);
   }
 };
@@ -198,15 +185,20 @@ const subscriptions = /* #__PURE__ */new WeakMap();
  * (`enq.listen()` / `enq.subscribeTo()`) and detaches when stopped.
  */
 function createAttachedLogic(attach) {
+  const initialTransition = (input, _) => [{
+    status: 'active',
+    output: undefined,
+    error: undefined,
+    input
+  }, []];
   return {
     start: (state, {
       self,
       system
     }) => {
-      // Don't attach if the target doesn't exist, or (for actors) is stopped.
-      // Atoms have no `getSnapshot` / lifecycle, so they always attach.
+      // Don't attach if the target doesn't exist or is stopped.
       const target = state.input.actor;
-      if (!target || typeof target.getSnapshot === 'function' && target.getSnapshot().status === 'stopped') {
+      if (!target || target.getSnapshot().status === 'stopped') {
         return;
       }
       const subscription = attach(state.input, {
@@ -249,20 +241,16 @@ function createAttachedLogic(attach) {
       if (event.type === XSTATE_STOP) {
         subscriptions.get(self)?.unsubscribe();
         subscriptions.delete(self);
-        return {
+        return [{
           ...state,
           status: 'stopped',
           error: undefined
-        };
+        }, []];
       }
-      return state;
+      return [state, []];
     },
-    getInitialSnapshot: (_, input) => ({
-      status: 'active',
-      output: undefined,
-      error: undefined,
-      input
-    }),
+    initialTransition,
+    getInitialSnapshot: (actorScope, input) => initialTransition(input)[0],
     getPersistedSnapshot: snapshot => snapshot,
     restoreSnapshot: snapshot => snapshot
   };
@@ -308,620 +296,6 @@ function createListenerLogic() {
 // Singleton logic instance
 const listenerLogic = /* #__PURE__ */createListenerLogic();
 
-/* eslint-disable */
-// Adapted from Alien Signals
-// https://github.com/stackblitz/alien-signals/
-
-let ReactiveFlags = /*#__PURE__*/function (ReactiveFlags) {
-  ReactiveFlags[ReactiveFlags["None"] = 0] = "None";
-  ReactiveFlags[ReactiveFlags["Mutable"] = 1] = "Mutable";
-  ReactiveFlags[ReactiveFlags["Watching"] = 2] = "Watching";
-  ReactiveFlags[ReactiveFlags["RecursedCheck"] = 4] = "RecursedCheck";
-  ReactiveFlags[ReactiveFlags["Recursed"] = 8] = "Recursed";
-  ReactiveFlags[ReactiveFlags["Dirty"] = 16] = "Dirty";
-  ReactiveFlags[ReactiveFlags["Pending"] = 32] = "Pending";
-  return ReactiveFlags;
-}({});
-function createReactiveSystem({
-  update,
-  notify,
-  unwatched
-}) {
-  return {
-    link,
-    unlink,
-    propagate,
-    checkDirty,
-    shallowPropagate
-  };
-  function link(dep, sub, version) {
-    const prevDep = sub.depsTail;
-    if (prevDep !== undefined && prevDep.dep === dep) {
-      return;
-    }
-    const nextDep = prevDep !== undefined ? prevDep.nextDep : sub.deps;
-    if (nextDep !== undefined && nextDep.dep === dep) {
-      nextDep.version = version;
-      sub.depsTail = nextDep;
-      return;
-    }
-    const prevSub = dep.subsTail;
-    if (prevSub !== undefined && prevSub.version === version && prevSub.sub === sub) {
-      return;
-    }
-    const newLink = sub.depsTail = dep.subsTail = {
-      version,
-      dep,
-      sub,
-      prevDep,
-      nextDep,
-      prevSub,
-      nextSub: undefined
-    };
-    if (nextDep !== undefined) {
-      nextDep.prevDep = newLink;
-    }
-    if (prevDep !== undefined) {
-      prevDep.nextDep = newLink;
-    } else {
-      sub.deps = newLink;
-    }
-    if (prevSub !== undefined) {
-      prevSub.nextSub = newLink;
-    } else {
-      dep.subs = newLink;
-    }
-  }
-  function unlink(link, sub = link.sub) {
-    const dep = link.dep;
-    const prevDep = link.prevDep;
-    const nextDep = link.nextDep;
-    const nextSub = link.nextSub;
-    const prevSub = link.prevSub;
-    if (nextDep !== undefined) {
-      nextDep.prevDep = prevDep;
-    } else {
-      sub.depsTail = prevDep;
-    }
-    if (prevDep !== undefined) {
-      prevDep.nextDep = nextDep;
-    } else {
-      sub.deps = nextDep;
-    }
-    if (nextSub !== undefined) {
-      nextSub.prevSub = prevSub;
-    } else {
-      dep.subsTail = prevSub;
-    }
-    if (prevSub !== undefined) {
-      prevSub.nextSub = nextSub;
-    } else if ((dep.subs = nextSub) === undefined) {
-      unwatched(dep);
-    }
-    return nextDep;
-  }
-  function propagate(link) {
-    let next = link.nextSub;
-    let stack;
-    top: do {
-      const sub = link.sub;
-      let flags = sub.flags;
-      if (!(flags & (ReactiveFlags.RecursedCheck | ReactiveFlags.Recursed | ReactiveFlags.Dirty | ReactiveFlags.Pending))) {
-        sub.flags = flags | ReactiveFlags.Pending;
-      } else if (!(flags & (ReactiveFlags.RecursedCheck | ReactiveFlags.Recursed))) {
-        flags = ReactiveFlags.None;
-      } else if (!(flags & ReactiveFlags.RecursedCheck)) {
-        sub.flags = flags & ~ReactiveFlags.Recursed | ReactiveFlags.Pending;
-      } else if (!(flags & (ReactiveFlags.Dirty | ReactiveFlags.Pending)) && isValidLink(link, sub)) {
-        sub.flags = flags | (ReactiveFlags.Recursed | ReactiveFlags.Pending);
-        flags &= ReactiveFlags.Mutable;
-      } else {
-        flags = ReactiveFlags.None;
-      }
-      if (flags & ReactiveFlags.Watching) {
-        notify(sub);
-      }
-      if (flags & ReactiveFlags.Mutable) {
-        const subSubs = sub.subs;
-        if (subSubs !== undefined) {
-          const nextSub = (link = subSubs).nextSub;
-          if (nextSub !== undefined) {
-            stack = {
-              value: next,
-              prev: stack
-            };
-            next = nextSub;
-          }
-          continue;
-        }
-      }
-      if ((link = next) !== undefined) {
-        next = link.nextSub;
-        continue;
-      }
-      while (stack !== undefined) {
-        link = stack.value;
-        stack = stack.prev;
-        if (link !== undefined) {
-          next = link.nextSub;
-          continue top;
-        }
-      }
-      break;
-    } while (true);
-  }
-  function checkDirty(link, sub) {
-    let stack;
-    let checkDepth = 0;
-    let dirty = false;
-    top: do {
-      const dep = link.dep;
-      const flags = dep.flags;
-      if (sub.flags & ReactiveFlags.Dirty) {
-        dirty = true;
-      } else if ((flags & (ReactiveFlags.Mutable | ReactiveFlags.Dirty)) === (ReactiveFlags.Mutable | ReactiveFlags.Dirty)) {
-        if (update(dep)) {
-          const subs = dep.subs;
-          if (subs.nextSub !== undefined) {
-            shallowPropagate(subs);
-          }
-          dirty = true;
-        }
-      } else if ((flags & (ReactiveFlags.Mutable | ReactiveFlags.Pending)) === (ReactiveFlags.Mutable | ReactiveFlags.Pending)) {
-        if (link.nextSub !== undefined || link.prevSub !== undefined) {
-          stack = {
-            value: link,
-            prev: stack
-          };
-        }
-        link = dep.deps;
-        sub = dep;
-        ++checkDepth;
-        continue;
-      }
-      if (!dirty) {
-        const nextDep = link.nextDep;
-        if (nextDep !== undefined) {
-          link = nextDep;
-          continue;
-        }
-      }
-      while (checkDepth--) {
-        const firstSub = sub.subs;
-        const hasMultipleSubs = firstSub.nextSub !== undefined;
-        if (hasMultipleSubs) {
-          link = stack.value;
-          stack = stack.prev;
-        } else {
-          link = firstSub;
-        }
-        if (dirty) {
-          if (update(sub)) {
-            if (hasMultipleSubs) {
-              shallowPropagate(firstSub);
-            }
-            sub = link.sub;
-            continue;
-          }
-          dirty = false;
-        } else {
-          sub.flags &= ~ReactiveFlags.Pending;
-        }
-        sub = link.sub;
-        const nextDep = link.nextDep;
-        if (nextDep !== undefined) {
-          link = nextDep;
-          continue top;
-        }
-      }
-      return dirty;
-    } while (true);
-  }
-  function shallowPropagate(link) {
-    do {
-      const sub = link.sub;
-      const flags = sub.flags;
-      if ((flags & (ReactiveFlags.Pending | ReactiveFlags.Dirty)) === ReactiveFlags.Pending) {
-        sub.flags = flags | ReactiveFlags.Dirty;
-        if ((flags & (ReactiveFlags.Watching | ReactiveFlags.RecursedCheck)) === ReactiveFlags.Watching) {
-          notify(sub);
-        }
-      }
-    } while ((link = link.nextSub) !== undefined);
-  }
-  function isValidLink(checkLink, sub) {
-    let link = sub.depsTail;
-    while (link !== undefined) {
-      if (link === checkLink) {
-        return true;
-      }
-      link = link.prevDep;
-    }
-    return false;
-  }
-}
-
-/**
- * Nominal brand (phantom, compile-time only) marking a value as an XState atom.
- * Real atoms get the runtime brand ({@link $$atom}) in `createAtom`; this type
- * brand keeps atom-only APIs (e.g. `enq.subscribeTo`) from structurally
- * accepting plain readables like `actor.select(...)` that would be dispatched
- * down the non-atom path at runtime.
- */
-
-/** Brand marking an object as an atom, so it can be detected structurally. */
-const $$atom = /* #__PURE__ */Symbol.for('xstate.atom');
-
-/**
- * Returns `true` if the value is an atom (writable, computed, async, or
- * reducer). Lets actor-consuming APIs (e.g. `enq.subscribeTo`) accept atoms
- * directly.
- */
-function isAtom(value) {
-  return !!value && typeof value === 'object' && $$atom in value;
-}
-const queuedEffects = [];
-let cycle = 0;
-// Initialized lazily on first atom creation (instead of at module evaluation)
-// so the reactive system stays tree-shakeable for apps that never use atoms —
-
-// would be retained by consumer bundlers even when atoms are unused.
-let link;
-let unlink;
-let propagate;
-let checkDirty;
-let shallowPropagate;
-let reactiveSystemInstalled = false;
-function ensureReactiveSystem() {
-  if (reactiveSystemInstalled) {
-    return;
-  }
-  reactiveSystemInstalled = true;
-  ({
-    link,
-    unlink,
-    propagate,
-    checkDirty,
-    shallowPropagate
-  } = createReactiveSystem({
-    update(atom) {
-      return atom._update();
-    },
-    notify(effect) {
-      queuedEffects[queuedEffectsLength++] = effect;
-      effect.flags &= ~ReactiveFlags.Watching;
-    },
-    unwatched(atom) {
-      if (atom.depsTail !== undefined) {
-        atom.depsTail = undefined;
-        atom.flags = ReactiveFlags.Mutable | ReactiveFlags.Dirty;
-        purgeDeps(atom);
-      }
-    }
-  }));
-}
-let notifyIndex = 0;
-let queuedEffectsLength = 0;
-let activeSub;
-function purgeDeps(sub) {
-  const depsTail = sub.depsTail;
-  let dep = depsTail !== undefined ? depsTail.nextDep : sub.deps;
-  while (dep !== undefined) {
-    dep = unlink(dep, sub);
-  }
-}
-function flush() {
-  while (notifyIndex < queuedEffectsLength) {
-    const effect = queuedEffects[notifyIndex];
-    queuedEffects[notifyIndex++] = undefined;
-    effect.notify();
-  }
-  notifyIndex = 0;
-  queuedEffectsLength = 0;
-}
-
-/** The current state of an async atom. */
-
-/** Options passed to an async atom getter. */
-
-function compareAsyncAtomState(a, b) {
-  if (a.status !== b.status) {
-    return false;
-  }
-  if (a.status === 'done' && b.status === 'done') {
-    return Object.is(a.data, b.data);
-  }
-  if (a.status === 'error' && b.status === 'error') {
-    return Object.is(a.error, b.error);
-  }
-  // both 'pending'
-  return true;
-}
-function updateAsyncAtom(atom, nextValue) {
-  if (atom._update(nextValue)) {
-    const subs = atom.subs;
-    if (subs !== undefined) {
-      propagate(subs);
-      shallowPropagate(subs);
-      flush();
-    }
-  }
-}
-
-/**
- * Creates a read-only atom whose value is loaded from an async getter.
- *
- * The getter receives an `AbortSignal`; when the async atom recomputes, the
- * previous signal is aborted and stale resolutions are ignored.
- */
-function createAsyncAtom(getValue, options) {
-  const ref = {};
-  let currentController;
-  let currentRunId = 0;
-  const atom = createAtom(() => {
-    currentController?.abort();
-    const controller = new AbortController();
-    const runId = ++currentRunId;
-    currentController = controller;
-    getValue({
-      signal: controller.signal
-    }).then(data => {
-      if (runId !== currentRunId || controller.signal.aborted) {
-        return;
-      }
-      updateAsyncAtom(ref.current, {
-        status: 'done',
-        data
-      });
-    }, error => {
-      if (runId !== currentRunId || controller.signal.aborted) {
-        return;
-      }
-      updateAsyncAtom(ref.current, {
-        status: 'error',
-        error
-      });
-    });
-    return {
-      status: 'pending'
-    };
-  }, {
-    compare: compareAsyncAtomState,
-    ...options
-  });
-  ref.current = atom;
-  return atom;
-}
-
-/**
- * Mirror atoms that bump a version whenever a tracked actor emits a snapshot,
- * letting computed atoms depend on `actor.get()` reads.
- *
- * The hook is installed lazily on first atom creation (not at module
- * evaluation) so that it remains tree-shakeable for apps that never use atoms —
- * any tracked read necessarily happens inside an atom computation, so first-use
- * installation is always early enough.
- */
-let actorInteropInstalled = false;
-function ensureActorInterop() {
-  if (actorInteropInstalled) {
-    return;
-  }
-  actorInteropInstalled = true;
-  const actorVersions = new WeakMap();
-  installActorReadHook(actorRef => {
-    if (activeSub === undefined) {
-      return;
-    }
-    let version = actorVersions.get(actorRef);
-    if (version === undefined) {
-      version = createAtom(0);
-      actorVersions.set(actorRef, version);
-      actorRef.subscribe({
-        next: () => version.set(v => v + 1),
-        error: () => {}
-      });
-    }
-    version.get();
-  });
-}
-
-/**
- * Creates an atom.
- *
- * Pass a value for a writable atom or a getter for a computed read-only atom.
- */
-
-function createAtom(valueOrFn, optionsOrInput) {
-  ensureReactiveSystem();
-  ensureActorInterop();
-  const isComputed = typeof valueOrFn === 'function';
-  const getter = valueOrFn;
-
-  // Create plain object atom
-  const atom = {
-    _snapshot: isComputed ? undefined : valueOrFn,
-    subs: undefined,
-    subsTail: undefined,
-    deps: undefined,
-    depsTail: undefined,
-    flags: isComputed ? ReactiveFlags.None : ReactiveFlags.Mutable,
-    get() {
-      if (activeSub !== undefined) {
-        link(atom, activeSub, cycle);
-      }
-      return atom._snapshot;
-    },
-    subscribe(observerOrFn) {
-      const observer = typeof observerOrFn === 'function' ? {
-        next: observerOrFn
-      } : observerOrFn;
-      const observed = {
-        current: false
-      };
-      const e = effect(() => {
-        atom.get();
-        if (!observed.current) {
-          observed.current = true;
-        } else {
-          const prevSub = activeSub;
-          activeSub = undefined;
-          try {
-            observer.next?.(atom._snapshot);
-          } catch (err) {
-            reportUnhandledError(err);
-          } finally {
-            activeSub = prevSub;
-          }
-
-          // If the observer synchronously updates any of our deps we'll be
-          // marked as dirty preventing this effect from re-running. Request
-          // the value again to reconcile any dirty deps.
-          atom.get();
-        }
-      });
-      return {
-        unsubscribe: () => {
-          e.stop();
-        }
-      };
-    },
-    _update(getValue) {
-      const prevSub = activeSub;
-      const compare = optionsOrInput?.compare ?? Object.is;
-      activeSub = atom;
-      ++cycle;
-      atom.depsTail = undefined;
-      if (isComputed) {
-        atom.flags = ReactiveFlags.Mutable | ReactiveFlags.RecursedCheck;
-      }
-      try {
-        const oldValue = atom._snapshot;
-        const newValue = typeof getValue === 'function' ? getValue(oldValue) : getValue === undefined && isComputed ? getter(oldValue) : getValue;
-        if (oldValue === undefined || !compare(oldValue, newValue)) {
-          atom._snapshot = newValue;
-          return true;
-        }
-        return false;
-      } finally {
-        activeSub = prevSub;
-        if (isComputed) {
-          atom.flags &= ~ReactiveFlags.RecursedCheck;
-        }
-        purgeDeps(atom);
-      }
-    }
-  };
-  if (isComputed) {
-    atom.flags = ReactiveFlags.Mutable | ReactiveFlags.Dirty;
-    atom.get = function () {
-      const flags = atom.flags;
-      if (flags & ReactiveFlags.Dirty || flags & ReactiveFlags.Pending && checkDirty(atom.deps, atom)) {
-        if (atom._update()) {
-          const subs = atom.subs;
-          if (subs !== undefined) {
-            shallowPropagate(subs);
-          }
-        }
-      } else if (flags & ReactiveFlags.Pending) {
-        atom.flags = flags & ~ReactiveFlags.Pending;
-      }
-      if (activeSub !== undefined) {
-        link(atom, activeSub, cycle);
-      }
-      return atom._snapshot;
-    };
-  } else {
-    atom.set = function (valueOrFn) {
-      if (atom._update(valueOrFn)) {
-        const subs = atom.subs;
-        if (subs !== undefined) {
-          propagate(subs);
-          shallowPropagate(subs);
-          flush();
-        }
-      }
-    };
-  }
-  atom[$$atom] = true;
-  return atom;
-}
-
-/**
- * Creates an inert atom config that can be instantiated later.
- *
- * Useful for framework hooks that need to create a stable local atom from
- * component input.
- */
-
-function createAtomConfig(initialValueOrFn, options) {
-  return {
-    createAtom(input) {
-      const initialValue = typeof initialValueOrFn === 'function' ? initialValueOrFn(input) : initialValueOrFn;
-      return createAtom(initialValue, options);
-    }
-  };
-}
-
-/** Creates an atom whose updates are handled by a reducer function. */
-function createReducerAtom(initialValue, reducer, options) {
-  const atom = createAtom(initialValue, options);
-  return {
-    [$$atom]: true,
-    get: atom.get.bind(atom),
-    subscribe: atom.subscribe.bind(atom),
-    send(event) {
-      const prevSub = activeSub;
-      activeSub = undefined;
-      let nextState;
-      try {
-        nextState = reducer(atom.get(), event);
-      } finally {
-        activeSub = prevSub;
-      }
-      atom.set(nextState);
-    }
-  };
-}
-function effect(fn) {
-  const run = () => {
-    const prevSub = activeSub;
-    activeSub = effectObj;
-    ++cycle;
-    effectObj.depsTail = undefined;
-    effectObj.flags = ReactiveFlags.Watching | ReactiveFlags.RecursedCheck;
-    try {
-      return fn();
-    } finally {
-      activeSub = prevSub;
-      effectObj.flags &= ~ReactiveFlags.RecursedCheck;
-      purgeDeps(effectObj);
-    }
-  };
-  const effectObj = {
-    deps: undefined,
-    depsTail: undefined,
-    subs: undefined,
-    subsTail: undefined,
-    flags: ReactiveFlags.Watching | ReactiveFlags.RecursedCheck,
-    notify() {
-      const flags = this.flags;
-      if (flags & ReactiveFlags.Dirty || flags & ReactiveFlags.Pending && checkDirty(this.deps, this)) {
-        run();
-      } else {
-        this.flags = ReactiveFlags.Watching;
-      }
-    },
-    stop() {
-      this.flags = ReactiveFlags.None;
-      this.depsTail = undefined;
-      purgeDeps(this);
-    }
-  };
-  run();
-  return effectObj;
-}
-
 /**
  * Creates actor logic for subscribing to lifecycle events (done/error/snapshot)
  * from another actor. Used internally by `enq.subscribeTo()`.
@@ -939,15 +313,6 @@ function createSubscriptionLogic() {
       error,
       snapshot: onSnapshot
     } = mappers;
-
-    // Atoms emit a raw value (no `status`) and have no done/error lifecycle —
-    // pass the value straight to the `snapshot` mapper.
-    if (isAtom(actor)) {
-      if (!onSnapshot) {
-        return;
-      }
-      return actor.subscribe(value => relayMappedToParent(self, system, () => onSnapshot(value)));
-    }
     return actor.subscribe({
       next: snapshot => {
         if (snapshot.status === 'done' && done) {
@@ -1048,7 +413,7 @@ function createTransitionEnqueue(actorScope, actions, internalEvents, actorSubsc
     },
     stop: actor => {
       if (actor) {
-        pushBuiltInAction(actions, builtInActions['@xstate.stopChild'], actorScope, actor);
+        pushBuiltInAction(actions, builtInActions['@xstate.stop'], actorScope, actor);
         actions.push(unregisterChild(actor));
       }
     }
@@ -1089,16 +454,65 @@ function createTransitionEnqueue(actorScope, actions, internalEvents, actorSubsc
     pushBuiltInAction(actions, action, ...args);
   });
 }
-function resolveAndExecuteActionsWithContext(currentSnapshot, event, actorScope, actions) {
+function getBuiltInActionFields(action, args) {
+  switch (action) {
+    case builtInActions['@xstate.start']:
+      {
+        const [actor] = args;
+        return {
+          actor,
+          id: actor.id,
+          logic: actor.logic,
+          src: actor.src,
+          input: actor.options?.input
+        };
+      }
+    case builtInActions['@xstate.raise']:
+      {
+        const [, event, options] = args;
+        return {
+          event,
+          id: options?.id,
+          delay: options?.delay
+        };
+      }
+    case builtInActions['@xstate.sendTo']:
+      {
+        const [, target, event, options] = args;
+        return {
+          target,
+          event,
+          id: options?.id,
+          delay: options?.delay
+        };
+      }
+    case builtInActions['@xstate.cancel']:
+      {
+        const [, id] = args;
+        return {
+          id
+        };
+      }
+    case builtInActions['@xstate.stop']:
+      {
+        const [, actor] = args;
+        return {
+          actor
+        };
+      }
+    default:
+      return undefined;
+  }
+}
+function isBuiltInExecutableAction(action) {
+  return Object.prototype.hasOwnProperty.call(builtInActions, action.type);
+}
+function resolveActionsWithContext(currentSnapshot, event, actorScope, actions) {
   let intermediateSnapshot = currentSnapshot;
+  const executableActions = [];
   for (const action of actions) {
     const isInline = typeof action === 'function';
     const resolvedAction = isInline ? action : typeof action === 'object' && 'action' in action && typeof action.action === 'function' ? action.action.bind(null, ...action.args) : false;
-    if (!resolvedAction && typeof action === 'object' && action !== null) {
-      actorScope.defer(() => {
-        actorScope.emit(action);
-      });
-    }
     const actionArgs = {
       context: intermediateSnapshot.context,
       event,
@@ -1118,7 +532,7 @@ function resolveAndExecuteActionsWithContext(currentSnapshot, event, actorScope,
       actionParams = emittedEventParams;
     }
     if (resolvedAction && '_special' in resolvedAction) {
-      actorScope.actionExecutor({
+      executableActions.push({
         type: typeof action === 'object' ? 'action' in action && typeof action.action === 'function' ? action.action.name ?? '(anonymous)' : action.type ?? '(anonymous)' : action.name || '(anonymous)',
         params: actionParams,
         args: [],
@@ -1139,16 +553,18 @@ function resolveAndExecuteActionsWithContext(currentSnapshot, event, actorScope,
       continue;
     }
     if (!resolvedAction || !('resolve' in resolvedAction)) {
-      actorScope.actionExecutor({
+      const builtInFields = typeof action === 'object' && action !== null && 'action' in action && typeof action.action === 'function' ? getBuiltInActionFields(action.action, action.args) : undefined;
+      executableActions.push({
         type: typeof action === 'object' ? 'action' in action && typeof action.action === 'function' ? action.action.name ?? '(anonymous)' : action.type : action.name || '(anonymous)',
         params: actionParams,
         args: typeof action === 'object' && 'action' in action ? action.args : [],
-        exec: resolvedAction
+        exec: resolvedAction || (typeof action === 'object' && action !== null ? () => actorScope.defer(() => actorScope.emit(action)) : undefined),
+        ...builtInFields
       });
       continue;
     }
   }
-  return intermediateSnapshot;
+  return [intermediateSnapshot, executableActions];
 }
 function createEnqueueObject$1(props, action) {
   const enqueueFn = (fn, ...args) => {
@@ -1342,22 +758,9 @@ function isInFinalState(stateNodeSet, stateNode) {
 }
 const isStateId = str => str[0] === STATE_IDENTIFIER;
 function getCandidates(stateNode, receivedEventType) {
-  const candidates = stateNode.transitions.get(receivedEventType);
-  if (candidates) {
-    return candidates;
-  }
-  const matchingDescriptors = [];
-  for (const eventDescriptor of stateNode.transitions.keys()) {
-    if (matchesEventDescriptor(receivedEventType, eventDescriptor)) {
-      matchingDescriptors.push(eventDescriptor);
-    }
-  }
-  matchingDescriptors.sort((a, b) => b.length - a.length);
-  const wildcardCandidates = [];
-  for (const descriptor of matchingDescriptors) {
-    wildcardCandidates.push(...stateNode.transitions.get(descriptor));
-  }
-  return wildcardCandidates;
+  const exactMatch = stateNode.transitions.get(receivedEventType);
+  const wildcardCandidates = [...stateNode.transitions.keys()].filter(eventDescriptor => eventDescriptor !== receivedEventType && matchesEventDescriptor(receivedEventType, eventDescriptor)).sort((a, b) => b.length - a.length).flatMap(key => stateNode.transitions.get(key));
+  return exactMatch ? [...exactMatch, ...wildcardCandidates] : wildcardCandidates;
 }
 function scheduleDelayedEvent(stateNode, event, resolveScheduledDelay) {
   const eventType = event.type;
@@ -1396,61 +799,68 @@ function getDelayedTransitions(stateNode) {
       }
     }
   }
-  const mutateEntryExitWithDelay = delay => {
-    const afterEvent = createAfterEvent(delay, stateNode.id);
-    return scheduleDelayedEvent(stateNode, afterEvent, x => resolveDelay(delay, x.delays, {
-      context: x.context,
-      event: x.event,
-      stateNode
-    }));
-  };
-  const delayedTransitions = [];
-  const addDelayedTransitions = (transitionsConfig, event, delay) => {
-    for (const transition of toTransitionConfigArray(transitionsConfig)) {
-      delayedTransitions.push({
-        ...transition,
-        event,
-        delay
-      });
-    }
-  };
+
+  // Every delayed transition — `after`, state-level `timeout`/`onTimeout`, and
+  // invoke-level `timeout`/`onTimeout` — has the same shape: an event raised on
+  // entry (and cancelled on exit) plus a transition that catches it. They
+  // differ only in the event raised, the transition(s) caught, and whether the
+  // delay resolves against the machine's `delays` map (invoke timeouts do not).
+  //
+  // `xstate.timeout.<id>` is a dedicated event so a state-level `timeout` cannot
+  // collide with an explicit `after` entry on the same state. Invoke timeouts
+  // are scheduled on the enclosing state; completion transitions cancel the
+  // timer separately, so it clears even when the parent state stays active.
+  const sources = [];
   if (afterConfig) {
-    for (const delay of Object.keys(afterConfig)) {
-      const configTransition = afterConfig[delay];
-      const parsedDelay = Number.isNaN(+delay) ? delay : +delay;
-      const eventType = mutateEntryExitWithDelay(parsedDelay);
-      const resolvedDelay = getConfiguredDelayValue(parsedDelay, stateNode.machine.implementations.delays);
-      addDelayedTransitions(configTransition, eventType, resolvedDelay);
+    for (const key of Object.keys(afterConfig)) {
+      const delay = Number.isNaN(+key) ? key : +key;
+      sources.push({
+        event: createAfterEvent(delay, stateNode.id),
+        delay,
+        transitions: afterConfig[key],
+        fromDelaysMap: true
+      });
     }
   }
-
-  // Desugar state-level `timeout` + `onTimeout` into a delayed transition.
-  // Uses a dedicated `xstate.timeout.<id>` event so it cannot collide with
-  // explicit `after` entries on the same state.
   if (timeoutConfig !== undefined && onTimeoutConfig) {
-    const timeoutEvent = createTimeoutEvent(stateNode.id);
-    const timeoutEventType = scheduleDelayedEvent(stateNode, timeoutEvent, x => resolveDelay(timeoutConfig, x.delays, {
-      context: x.context,
-      event: x.event,
-      stateNode
-    }));
-    const resolvedDelay = typeof timeoutConfig === 'function' ? timeoutConfig : getConfiguredDelayValue(timeoutConfig, stateNode.machine.implementations.delays);
-    addDelayedTransitions(onTimeoutConfig, timeoutEventType, resolvedDelay);
+    sources.push({
+      event: createTimeoutEvent(stateNode.id),
+      delay: timeoutConfig,
+      transitions: onTimeoutConfig,
+      fromDelaysMap: true
+    });
   }
-
-  // Desugar invoke-level `timeout` + `onTimeout` into a delayed transition on
-  // the enclosing state. Completion transitions cancel this timer separately,
-  // so the timeout is cleared even when the parent state stays active.
   for (const invokeDef of invokeDefs) {
-    const invokeTimeoutEvent = createInvokeTimeoutEvent(invokeDef.id);
-    const invokeTimeout = invokeDef.timeout;
-    const invokeTimeoutEventType = scheduleDelayedEvent(stateNode, invokeTimeoutEvent, x => resolveDelay(invokeTimeout, {}, {
+    sources.push({
+      event: createInvokeTimeoutEvent(invokeDef.id),
+      delay: invokeDef.timeout,
+      transitions: invokeDef.onTimeout,
+      fromDelaysMap: false
+    });
+  }
+
+  // `delay` here is the raw config value, retained only as metadata on the
+  // transition definition — the live delay is resolved at runtime in the
+  // scheduled entry action, so no eager resolution is needed.
+  const delayedTransitions = [];
+  for (const {
+    event,
+    delay,
+    transitions,
+    fromDelaysMap
+  } of sources) {
+    const eventType = scheduleDelayedEvent(stateNode, event, x => resolveDelay(delay, fromDelaysMap ? x.delays : {}, {
       context: x.context,
       event: x.event,
       stateNode
     }));
-    const invokeOnTimeout = invokeDef.onTimeout;
-    addDelayedTransitions(invokeOnTimeout, invokeTimeoutEventType, invokeTimeout);
+    for (const transition of toTransitionConfigArray(transitions)) {
+      delayedTransitions.push({
+        ...transition,
+        event: eventType,
+        delay
+      });
+    }
   }
   return delayedTransitions.map(delayedTransition => ({
     ...formatTransition(stateNode, delayedTransition.event, delayedTransition),
@@ -1515,27 +925,13 @@ function formatRouteTransitions(rootStateNode) {
         if ('$unserializable' in routeConfig) {
           throw new Error(`State "${sn.id}" has a route that is not serializable. Re-provide the route function when reviving this machine.`);
         }
-
-        // Object-form route. A `guard` (string or function) on the object is
-        // only produced by the JSON layer (createMachineFromConfig) —
-        // authoring uses the function form above.
-        const userGuard = routeConfig.guard;
+        const {
+          guard: _guard,
+          ...routeOptions
+        } = routeConfig;
         const transition = {
-          ...routeConfig,
-          guard: userGuard ? args => {
-            if (!routeMatches(args)) return false;
-            if (typeof userGuard === 'function') return userGuard(args);
-            if (typeof userGuard === 'string') {
-              const guardImpl = args.guards?.[userGuard];
-              if (!guardImpl) {
-                // A typo'd guard name must fail loudly — silently passing
-                // would allow the route and corrupt machine behavior.
-                throw new Error(`Guard '${userGuard}' is not implemented in machine '${rootStateNode.machine.id}'. Available guards: ${Object.keys(args.guards ?? {}).map(key => `'${key}'`).join(', ') || '(none)'}.` );
-              }
-              return guardImpl(args);
-            }
-            return true;
-          } : routeMatches,
+          ...routeOptions,
+          guard: routeMatches,
           target: `#${routeId}`
         };
         routeTransitions.push(formatTransition(rootStateNode, 'xstate.route', transition));
@@ -1866,16 +1262,11 @@ function initialMicrostep(root, preInitialState, actorScope, initEvent, internal
 
 /** https://www.w3.org/TR/scxml/#microstepProcedure */
 function microstep(transitions, currentSnapshot, actorScope, event, isInitial, internalQueue) {
-  const actions = [];
+  const executableActions = [];
   if (!transitions.length) {
-    return [currentSnapshot, actions];
+    return [currentSnapshot, executableActions];
   }
-  const originalExecutor = actorScope.actionExecutor;
-  actorScope.actionExecutor = action => {
-    actions.push(action);
-    originalExecutor(action);
-  };
-  try {
+  {
     const mutStateNodeSet = new Set(currentSnapshot._nodes);
     let historyValue = currentSnapshot.historyValue;
     const originalContext = currentSnapshot.context;
@@ -1948,7 +1339,9 @@ function microstep(transitions, currentSnapshot, actorScope, event, isInitial, i
             context: nextContext
           });
         }
-        nextState = resolveAndExecuteActionsWithContext(nextState, event, actorScope, exitActions);
+        const [resolvedState, resolvedActions] = resolveActionsWithContext(nextState, event, actorScope, exitActions);
+        nextState = resolvedState;
+        executableActions.push(...resolvedActions);
         for (const def of exitStateNode.invoke) {
           const childActor = nextState.children[def.id];
           if (childActor && !childActor._isExternal) {
@@ -2183,7 +1576,10 @@ function microstep(transitions, currentSnapshot, actorScope, event, isInitial, i
             }
           }
         }
-        nextState = resolveAndExecuteActionsWithContext(nextState, event, actorScope, actions);
+        const [resolvedState, resolvedActions] = resolveActionsWithContext(nextState, event, actorScope, actions);
+        nextState = resolvedState;
+        actions.length = 0;
+        executableActions.push(...resolvedActions);
         if (context) {
           nextState.context = context;
         }
@@ -2234,7 +1630,9 @@ function microstep(transitions, currentSnapshot, actorScope, event, isInitial, i
     };
 
     // Execute transition content
-    nextState = resolveAndExecuteActionsWithContext(nextState, event, actorScope, transitionActions);
+    const [resolvedTransitionState, transitionExecutableActions] = resolveActionsWithContext(nextState, event, actorScope, transitionActions);
+    nextState = resolvedTransitionState;
+    executableActions.push(...transitionExecutableActions);
     if (context && context !== currentSnapshot.context) {
       nextState = cloneMachineSnapshot(nextState, {
         context
@@ -2257,22 +1655,22 @@ function microstep(transitions, currentSnapshot, actorScope, event, isInitial, i
           }
         }
       });
-      nextState = resolveAndExecuteActionsWithContext(nextState, event, actorScope, allExitActions);
+      const [resolvedState, resolvedActions] = resolveActionsWithContext(nextState, event, actorScope, allExitActions);
+      nextState = resolvedState;
+      executableActions.push(...resolvedActions);
     }
     if (historyValue === currentSnapshot.historyValue && currentSnapshot._nodes.length === mutStateNodeSet.size && currentSnapshot._nodes.every(node => mutStateNodeSet.has(node))) {
       // If context was changed (e.g. by entry actions during self-transition),
       // clone to ensure reference inequality for eventless transition re-evaluation
       if (nextState.context !== originalContext) {
-        return [cloneMachineSnapshot(nextState), actions];
+        return [cloneMachineSnapshot(nextState), executableActions];
       }
-      return [nextState, actions];
+      return [nextState, executableActions];
     }
     return [cloneMachineSnapshot(nextState, {
       _nodes: nextStateNodes,
       historyValue
-    }), actions];
-  } finally {
-    actorScope.actionExecutor = originalExecutor;
+    }), executableActions];
   }
 }
 
@@ -2533,24 +1931,7 @@ function evaluateCandidate(candidate, event, snapshot, stateNode, self) {
       delays: stateNode.machine.implementations.delays,
       _snapshot: snapshot
     };
-    const guardConfig = candidate.guard;
-    const guardParams = typeof guardConfig?.params === 'function' ? guardConfig.params({
-      context: snapshot.context,
-      event
-    }) : guardConfig?.params;
-    let guardPassed = true;
-    if (typeof guardConfig === 'function') {
-      guardPassed = guardConfig(guardArgs, guardParams);
-    } else if (typeof guardConfig?.type === 'string') {
-      const guardImpl = stateNode.machine.implementations.guards[guardConfig.type];
-      if (!guardImpl) {
-        // A typo'd guard name must fail loudly — silently passing would
-        // take the guarded transition and corrupt machine behavior.
-        throw new Error(`Guard '${guardConfig.type}' is not implemented in machine '${stateNode.machine.id}'. Available guards: ${Object.keys(stateNode.machine.implementations.guards).map(key => `'${key}'`).join(', ') || '(none)'}.` );
-      }
-      guardPassed = guardImpl(guardArgs, guardParams);
-    }
-    if (!guardPassed) {
+    if (!candidate.guard(guardArgs)) {
       return false;
     }
   }
@@ -3375,7 +2756,7 @@ function createLogic(config) {
       Object.assign(snapshot, nextSnapshot);
       executeLogicEffects(effects, actorScope);
     },
-    getInitialSnapshot: (_, input) => {
+    initialTransition: (input, _) => {
       const context = resolveContext(config.context, input);
       const snapshot = {
         status: 'active',
@@ -3386,10 +2767,11 @@ function createLogic(config) {
       if (context !== undefined) {
         snapshot.context = context;
       }
-      return {
+      return [{
         ...snapshot
-      };
+      }, []];
     },
+    getInitialSnapshot: (actorScope, input) => logic.initialTransition(input, actorScope)[0],
     getPersistedSnapshot: snapshot => snapshot,
     restoreSnapshot: snapshot => snapshot
   };
@@ -3419,6 +2801,23 @@ const defaultOptions = {
   },
   logger: console.log.bind(console)
 };
+function isExecutableActionObject(effect) {
+  return typeof effect === 'object' && effect !== null && 'args' in effect && 'exec' in effect;
+}
+function executeExecutableEffects(effects, actorScope) {
+  if (!effects?.length) {
+    return [];
+  }
+  const logicEffects = [];
+  for (const effect of effects) {
+    if (isExecutableActionObject(effect)) {
+      actorScope.actionExecutor(effect);
+    } else {
+      logicEffects.push(effect);
+    }
+  }
+  return logicEffects;
+}
 
 /**
  * An Actor is a running process that can receive events, send events and change
@@ -3457,6 +2856,7 @@ class Actor {
     this.logger = void 0;
     /** @internal */
     this._processingStatus = ProcessingStatus.NotStarted;
+    this._forceDeferredActions = false;
     // Actor Ref
     this._parent = void 0;
     /** @internal */
@@ -3472,6 +2872,7 @@ class Actor {
     this._collectedActions = [];
     /** @internal Events relayed to other actors during the in-flight transition. */
     this._collectedSent = [];
+    this._initialEffects = void 0;
     this.systemId = void 0;
     /** The globally unique process ID for this invocation. */
     this.sessionId = void 0;
@@ -3574,7 +2975,7 @@ class Actor {
             executingCustomAction = saveExecutingCustomAction;
           }
         };
-        if (this._processingStatus === ProcessingStatus.Running) {
+        if (this._processingStatus === ProcessingStatus.Running && !this._forceDeferredActions) {
           exec();
         } else {
           this._deferred.push(exec);
@@ -3603,7 +3004,7 @@ class Actor {
       this.system._set(systemId, this);
     }
 
-    // prepare to collect initial microsteps during getInitialSnapshot
+    // prepare to collect initial microsteps during initialTransition
     this._collectedMicrosteps = [];
     let persistedState = options?.snapshot ?? options?.state;
     if (persistedState && typeof persistedState === 'object' && '_pendingEffects' in persistedState) {
@@ -3617,7 +3018,13 @@ class Actor {
       persistedState = rest;
     }
     try {
-      this._snapshot = persistedState ? this.logic.restoreSnapshot ? this.logic.restoreSnapshot(persistedState, this._actorScope) : persistedState : this.logic.getInitialSnapshot(this._actorScope, this.options?.input);
+      if (persistedState) {
+        this._snapshot = this.logic.restoreSnapshot ? this.logic.restoreSnapshot(persistedState, this._actorScope) : persistedState;
+      } else {
+        const [snapshot, effects] = this.logic.initialTransition(this.options?.input, this._actorScope);
+        this._snapshot = snapshot;
+        this._initialEffects = effects;
+      }
     } catch (err) {
       // if we get here then it means that we assign a value to this._snapshot that is not of the correct type
       // we can't get the true `TSnapshot & { status: 'error'; }`, it's impossible
@@ -3726,6 +3133,26 @@ class Actor {
     this._collectedActions = [];
     this._collectedSent = [];
   }
+  _flushInitialEffects() {
+    if (!this._initialEffects) {
+      return true;
+    }
+    this._forceDeferredActions = true;
+    try {
+      const logicEffects = executeExecutableEffects(this._initialEffects, this._actorScope);
+      executeLogicEffects(logicEffects, this._actorScope);
+      this._initialEffects = undefined;
+      return true;
+    } catch (err) {
+      this._initialEffects = undefined;
+      this._deferred.length = 0;
+      this._setErrorSnapshot(err);
+      this._error(err);
+      return false;
+    } finally {
+      this._forceDeferredActions = false;
+    }
+  }
 
   /**
    * Subscribe an observer to an actor’s snapshot values.
@@ -3852,7 +3279,7 @@ class Actor {
           complete: observer.complete
         });
       },
-      get: () => selector(this.get())
+      get: () => selector(this.getSnapshot())
     };
   }
 
@@ -3890,6 +3317,9 @@ class Actor {
       case 'done':
         // a state machine can be "done" upon initialization (it could reach a final state using initial microsteps)
         // we still need to complete observers, flush deferreds etc
+        if (!this._flushInitialEffects()) {
+          return this;
+        }
         this.update(this._snapshot, initEvent);
         // TODO: rethink cleanup of observers, mailbox, etc
         return this;
@@ -3909,6 +3339,9 @@ class Actor {
         return this;
       }
     }
+    if (!this._flushInitialEffects()) {
+      return this;
+    }
 
     // TODO: this notifies all subscribers but usually this is redundant
     // there is no real change happening here
@@ -3947,9 +3380,16 @@ class Actor {
       this._error(err);
       return;
     }
-    const [snapshot, effects] = Array.isArray(nextState) ? nextState : [nextState, undefined];
-    this.update(snapshot, event);
-    executeLogicEffects(effects, this._actorScope);
+    try {
+      const [snapshot, effects] = nextState;
+      const logicEffects = executeExecutableEffects(effects, this._actorScope);
+      this.update(snapshot, event);
+      executeLogicEffects(logicEffects, this._actorScope);
+    } catch (err) {
+      this._setErrorSnapshot(err);
+      this._error(err);
+      return;
+    }
     if (event.type === XSTATE_STOP) {
       this._stopProcedure();
       this._complete();
@@ -4141,15 +3581,9 @@ class Actor {
    * @see {@link Actor.getPersistedSnapshot} to persist the internal state of an actor (which is more than just a snapshot).
    */
   getSnapshot() {
-    return this.get();
-  }
-
-  /** Read the actor's current snapshot as an atom value. */
-  get() {
     if (!this._snapshot) {
       throw new Error(`Snapshot can't be read while the actor initializes itself`);
     }
-    onActorRead?.(this);
     return this._snapshot;
   }
 }
@@ -4588,46 +4022,45 @@ function createEventObservableLogic(lazyObservableOrConfig) {
     config: lazyObservable,
     transition: (state, event) => {
       if (state.status !== 'active') {
-        return state;
+        return [state, []];
       }
       switch (event.type) {
         case XSTATE_OBSERVABLE_ERROR:
-          return {
+          return [{
             ...state,
             status: 'error',
             error: event.data,
             input: undefined,
             _subscription: undefined
-          };
+          }, []];
         case XSTATE_OBSERVABLE_COMPLETE:
-          return {
+          return [{
             ...state,
             status: 'done',
             input: undefined,
             _subscription: undefined
-          };
+          }, []];
         case XSTATE_STOP:
           state._subscription.unsubscribe();
-          return {
+          return [{
             ...state,
             status: 'stopped',
             input: undefined,
             _subscription: undefined
-          };
+          }, []];
         default:
-          return state;
+          return [state, []];
       }
     },
-    getInitialSnapshot: (_, input) => {
-      return {
-        status: 'active',
-        output: undefined,
-        error: undefined,
-        context: undefined,
-        input,
-        _subscription: undefined
-      };
-    },
+    initialTransition: (input, _) => [{
+      status: 'active',
+      output: undefined,
+      error: undefined,
+      context: undefined,
+      input,
+      _subscription: undefined
+    }, []],
+    getInitialSnapshot: (actorScope, input) => logic.initialTransition(input, actorScope)[0],
     start: (state, {
       self,
       system,
@@ -4945,4 +4378,4 @@ function createEmptyActor() {
   return createActor(emptyLogic);
 }
 
-export { isStateId as $, Actor as A, createAsyncLogic as B, createListenerLogic as C, listenerLogic as D, createSubscriptionLogic as E, subscriptionLogic as F, resolveReferencedActor as G, mapValues as H, createInvokeId as I, getDelayedTransitions as J, evaluateCandidate as K, formatTransition as L, toTransitionConfigArray as M, NULL_EVENT as N, createInvokeTimeoutEvent as O, ProcessingStatus as P, getCandidates as Q, formatRouteTransitions as R, STATE_DELIMITER as S, TimeoutError as T, resolveStateValue as U, getAllStateNodes as V, createMachineSnapshot as W, isInFinalState as X, transitionNode as Y, resolveAndExecuteActionsWithContext as Z, toStatePath as _, macrostep as a, getStateNodeByPath as a0, getPersistedSnapshot as a1, $$ACTOR_TYPE as a2, XSTATE_INIT as a3, createInitEvent as b, createActor as c, initialMicrostep as d, createAtom as e, createAtomConfig as f, getProperAncestors as g, createAsyncAtom as h, isAtomicStateNode as i, createReducerAtom as j, isAtom as k, isMachineSnapshot as l, matchesEventDescriptor as m, getStateNodes as n, getAllOwnEventDescriptors as o, parseDelayToMilliseconds as p, matchesState as q, checkStateIn as r, pathToStateValue as s, toArray as t, toObserver as u, createEmptyActor as v, createCallbackLogic as w, createObservableLogic as x, createEventObservableLogic as y, createLogic as z };
+export { $$ACTOR_TYPE as $, Actor as A, subscriptionLogic as B, resolveReferencedActor as C, mapValues as D, createInvokeId as E, getDelayedTransitions as F, evaluateCandidate as G, formatTransition as H, toTransitionConfigArray as I, createInvokeTimeoutEvent as J, getCandidates as K, formatRouteTransitions as L, resolveStateValue as M, NULL_EVENT as N, getAllStateNodes as O, ProcessingStatus as P, createMachineSnapshot as Q, isInFinalState as R, STATE_DELIMITER as S, TimeoutError as T, transitionNode as U, resolveActionsWithContext as V, toStatePath as W, isStateId as X, getStateNodeByPath as Y, getPersistedSnapshot as Z, XSTATE_INIT as _, macrostep as a, createInitEvent as b, createActor as c, initialMicrostep as d, isMachineSnapshot as e, getStateNodes as f, getProperAncestors as g, getAllOwnEventDescriptors as h, isAtomicStateNode as i, matchesState as j, checkStateIn as k, pathToStateValue as l, matchesEventDescriptor as m, toObserver as n, isBuiltInExecutableAction as o, parseDelayToMilliseconds as p, createEmptyActor as q, createCallbackLogic as r, createObservableLogic as s, toArray as t, createEventObservableLogic as u, createLogic as v, createAsyncLogic as w, createListenerLogic as x, listenerLogic as y, createSubscriptionLogic as z };