xstate 6.0.0-beta.1 → 6.0.0-beta.3

package/README.md

@@ -171,8 +171,8 @@ import { createFSM } from 'xstate/fsm';
 const machine = createFSM({
   initial: 'inactive',
   states: {
-    inactive: { on: { toggle: 'active' } },
-    active: { on: { toggle: 'inactive' } }
+    inactive: { on: { toggle: { target: 'active' } } },
+    active: { on: { toggle: { target: 'inactive' } } }
   }
 });
 
@@ -180,6 +180,8 @@ let state = machine.initialState;
 [state] = machine.transition(state, { type: 'toggle' });
 ```
 
+States can declare eventless `always` transitions. The machine follows them
+during initialization and after handled events until it reaches a stable state.
 The FSM is also actor logic, so `createActor(machine)` from `xstate` runs it.
 
 For typed context, event payloads, or state-specific context snapshots, use

package/dist/{createActor-cbe3abac.esm.js → createActor-49ea55ba.esm.js}

@@ -164,11 +164,11 @@ function isRemoteActorRef(actorRef) {
  * JSON (`actor.toJSON()`): plain data carrying an address, not an actor.
  */
 function isSerializedActorRef(target) {
-  if (typeof target !== 'object' || target === null || Array.isArray(target) || typeof target.$actor !== 'string') {
+  if (typeof target !== 'object' || target === null || Array.isArray(target) || typeof target['@actor'] !== 'string') {
     return false;
   }
   for (const key in target) {
-    if (key !== '$actor' && key !== 'incarnation') {
+    if (key !== '@actor' && key !== 'incarnation') {
       return false;
     }
   }
@@ -184,7 +184,7 @@ function getAddressId(address) {
 
 /** @internal The error reported when no live actor has a serialized address. */
 function createMissingAddressError(target) {
-  return new Error(xstateError(50, ...(target.incarnation === undefined ? [target.$actor] : [target.$actor, target.incarnation])) );
+  return new Error(xstateError(50, ...(target.incarnation === undefined ? [target['@actor']] : [target['@actor'], target.incarnation])) );
 }
 
 /**
@@ -193,7 +193,7 @@ function createMissingAddressError(target) {
  * without one follows whichever actor is live at the address.
  */
 function resolveSerializedActorRef(system, target) {
-  const live = system._getByAddress?.(target.$actor);
+  const live = system._getByAddress?.(target['@actor']);
   return live && (target.incarnation === undefined || live.sessionId === target.incarnation) ? live : undefined;
 }
 
@@ -246,7 +246,7 @@ function createInertActorRef(options) {
         throw new Error(xstateError(51, id));
       }
       return {
-        $actor: address
+        '@actor': address
       };
     }
   };
@@ -332,7 +332,7 @@ function createRemoteActorRef(system, options) {
     // one actor-reference shape whether a child is co-located or remote.
     toJSON() {
       return {
-        $actor: options.address
+        '@actor': options.address
       };
     }
   };
@@ -452,7 +452,7 @@ function deliverEvent(source, target, event) {
         throw error;
       }
       void system.deadLetter(source, undefined, event, 'missingTarget', {
-        targetId: getAddressId(serialized.$actor),
+        targetId: getAddressId(serialized['@actor']),
         error
       });
       return;
@@ -905,6 +905,7 @@ function resolveRegisteredActorSource(actors, logic) {
 const systemLogicMetadata = Symbol('xstate.systemLogicMetadata');
 
 const subscriptions = /* #__PURE__ */new WeakMap();
+const XSTATE_ATTACHED_FORWARD = 'xstate.attached.forward';
 
 /**
  * Internal factory for actor logic that attaches to another actor on start
@@ -967,9 +968,11 @@ id) {
         unsubscribe: teardown
       });
     },
-    transition: (state, event, {
-      self
-    }) => {
+    transition: (state, event, scope) => {
+      const self = scope.self;
+      if (event.type === XSTATE_ATTACHED_FORWARD) {
+        return [state, state.status === 'active' && self._parent ? [createSendToEffect(scope, self._parent, event.event)] : []];
+      }
       if (event.type === XSTATE_STOP) {
         subscriptions.get(self)?.unsubscribe();
         subscriptions.delete(self);
@@ -984,7 +987,8 @@ id) {
     initialTransition,
     getInitialSnapshot: (actorScope, input) => initialTransition(input)[0],
     getPersistedSnapshot: snapshot => snapshot,
-    restoreSnapshot: snapshot => snapshot
+    restoreSnapshot: snapshot => snapshot,
+    isInternalEventType: eventType => eventType === XSTATE_ATTACHED_FORWARD
   };
   Object.defineProperty(logic, systemLogicMetadata, {
     value: {
@@ -1002,7 +1006,10 @@ function relayMappedToParent(self, system, getEvent) {
   if (self.getSnapshot().status === 'stopped' || !self._parent) {
     return;
   }
-  system._relay(self, self._parent, getEvent());
+  system._relay(self, self, {
+    type: XSTATE_ATTACHED_FORWARD,
+    event: getEvent()
+  });
 }
 
 /** @public */
@@ -2112,6 +2119,18 @@ function withSystemInspector(inspect, fn) {
 
 /** Snapshot-scoped actor identity and system view. @internal */
 
+// Each view's execution system and whether it forwards inspection. Views
+// never chain: they all inherit from the execution system directly.
+const snapshotSystemViews = new WeakMap();
+// Facilities owned by the execution rather than by one snapshot's view. A view
+// reads and writes them on the execution system, so timers, listeners and the
+// runtime installed through any snapshot are visible through every other.
+const executionFacilities = ['runtime', '_timerMap', '_rejectionListeners', '_inspectionObservers', '_emissionListeners'];
+// The durable execution that owns each execution system.
+/** A durable execution, as the owner of the views its transitions create. @internal */
+
+const executionOwners = new WeakMap();
+let ambientExecutionOwner;
 const snapshotActorRefs = new WeakMap();
 const lazySnapshotActorRefs = new WeakMap();
 const emptyKeyedActors = new Map();
@@ -2171,12 +2190,22 @@ function getSnapshotChildren(snapshot) {
  *
  * @internal
  */
-function createSnapshotSystem(baseSystem, children, baseState) {
-  const forwardInspection = hasAmbientInspector();
+function createSnapshotSystem(baseSystem, children, baseState, owner) {
+  const baseView = snapshotSystemViews.get(baseSystem);
+  const baseExecutionSystem = baseView?.executionSystem ?? baseSystem;
+  // The runtime system under every view. A view runs its methods against the
+  // execution system's facilities.
+  const rootSystem = baseView?.rootSystem ?? baseSystem;
+  const forks = owner !== undefined && executionOwners.get(baseExecutionSystem) !== owner;
+  // A view an execution owns reports to that execution's inspector.
+  const forwardInspection = owner ? !!owner.inspect : hasAmbientInspector() && (baseView?.forwardInspection ?? true);
   const registeredActors = copyRegisteredActors(baseSystem, baseState);
   const keyedActors = new Map(baseState?.keyedActors ?? getKeyedActors(baseSystem));
   const reverseKeyedActors = new WeakMap();
-  const system = Object.assign(Object.create(baseSystem), {
+  // The view's execution system; adoption can make the view its own.
+  const execution = () => snapshotSystemViews.get(system).executionSystem;
+  const forwards = () => snapshotSystemViews.get(system).forwardInspection;
+  const system = Object.assign(Object.create(baseExecutionSystem), {
     children: registeredActors,
     keyedActors,
     reverseKeyedActors,
@@ -2211,15 +2240,38 @@ function createSnapshotSystem(baseSystem, children, baseState) {
     },
     get: registryKey => keyedActors.get(registryKey),
     getAll: () => Object.fromEntries(keyedActors),
-    onEmitted: listener => baseSystem.onEmitted(listener),
-    _notifyEmitted: (actorRef, event) => baseSystem._notifyEmitted(actorRef, event),
+    onEmitted: listener => rootSystem.onEmitted.call(execution(), listener),
+    _notifyEmitted: (actorRef, event) => rootSystem._notifyEmitted.call(execution(), actorRef, event),
     // Pure transition resolution must not leak topology inspection events
     // into a live runtime system — planning branches stay silent. The one
     // exception is a durable execution's own transitions (marked by the
     // ambient inspector at creation time): there the pure path IS the
-    // execution, so inspection forwards to the base system's observers.
-    _hasInspectionObservers: forwardInspection ? () => baseSystem._hasInspectionObservers?.() ?? false : () => false,
-    _sendInspectionEvent: forwardInspection ? event => baseSystem._sendInspectionEvent(event) : () => {}
+    // execution, so inspection forwards to the execution system's observers.
+    _hasInspectionObservers: () => forwards() && (rootSystem._hasInspectionObservers?.call(execution()) ?? false),
+    _sendInspectionEvent: event => {
+      if (forwards()) {
+        rootSystem._sendInspectionEvent.call(execution(), event);
+      }
+    }
+  });
+  const executionSystem = forks ? system : baseExecutionSystem;
+  if (forks) {
+    forkFacilities(system, baseExecutionSystem, owner);
+  } else {
+    for (const key of executionFacilities) {
+      Object.defineProperty(system, key, {
+        configurable: true,
+        get: () => execution()[key],
+        set: value => {
+          execution()[key] = value;
+        }
+      });
+    }
+  }
+  snapshotSystemViews.set(system, {
+    executionSystem,
+    rootSystem,
+    forwardInspection
   });
   for (const [registryKey, actor] of keyedActors) {
     if (!actor) {
@@ -2243,6 +2295,83 @@ function createSnapshotSystem(baseSystem, children, baseState) {
   return system;
 }
 
+/**
+ * Makes `system` the execution system of `owner`, a new incarnation: it gets
+ * the owner's runtime and the pending timers it saw, and starts with no
+ * listeners or inspectors, so nothing registered on another execution
+ * observes it.
+ */
+function forkFacilities(system, from, owner) {
+  const timers = from._timerMap;
+  for (const key of executionFacilities) {
+    Object.defineProperty(system, key, {
+      configurable: true,
+      writable: true,
+      value: key === 'runtime' ? owner.runtime : key === '_timerMap' && timers ? {
+        ...timers
+      } : undefined
+    });
+  }
+  executionOwners.set(system, owner);
+  if (owner.inspect) {
+    system.inspect(owner.inspect);
+  }
+}
+
+/**
+ * Makes `owner` own `system` before it installs its runtime there, and
+ * returns whether it does. An unowned view forks in place, so the install
+ * never reaches the system it was derived from. A system another execution
+ * owns is left alone.
+ *
+ * @internal
+ */
+function adoptSystem(system, owner) {
+  const view = snapshotSystemViews.get(system);
+  const current = executionOwners.get(view?.executionSystem ?? system);
+  if (current === owner) {
+    if (view) {
+      view.forwardInspection = !!owner.inspect;
+    }
+    return true;
+  }
+  // A system another execution owns stays with it.
+  if (current) {
+    return false;
+  }
+  if (!view) {
+    executionOwners.set(system, owner);
+    return true;
+  }
+  forkFacilities(system, view.executionSystem, owner);
+  view.executionSystem = system;
+  view.forwardInspection = !!owner.inspect;
+  return true;
+}
+
+/**
+ * Runs `fn` as a transition of `owner`. A view it derives from a system the
+ * owner does not own forks into the owner's own execution system.
+ *
+ * @internal
+ */
+function withExecutionOwner(owner, fn) {
+  const previous = ambientExecutionOwner;
+  ambientExecutionOwner = owner;
+  try {
+    return fn();
+  } finally {
+    ambientExecutionOwner = previous;
+  }
+}
+
+/** Hands the ambient owner to the first scope that asks for it. @internal */
+function takeExecutionOwner() {
+  const owner = ambientExecutionOwner;
+  ambientExecutionOwner = undefined;
+  return owner;
+}
+
 /** Returns the actor identity associated with a transition snapshot. @internal */
 function getSnapshotActorRef(snapshot) {
   const existing = snapshotActorRefs.get(snapshot);
@@ -2436,8 +2565,9 @@ function setInertActorScopeSnapshot(actorScope, snapshot, attachActorRef = true)
   const lazyState = getLazyInertActorState(actorScope);
   if (lazyState) {
     lazyState.snapshot = snapshot;
-    if (lazyState.materialized) {
-      lazyState.materialized.self._snapshot = snapshot;
+    const scope = lazyState.materialized ?? lazyState.identityScope;
+    if (scope) {
+      scope.self._snapshot = snapshot;
     }
   } else {
     actorScope.self._snapshot = snapshot;
@@ -2472,6 +2602,15 @@ function attachSnapshotActorRef(actorScope, snapshot) {
   setLazySnapshotActorRef(snapshot, create);
   return snapshot;
 }
+/** Records the materialized scope and releases its consumed source. */
+function commitMaterialization(state, scope) {
+  // Dropping the consumed source keeps this scope from retaining earlier snapshots.
+  state.sourceRef = undefined;
+  state.sourceChildren = {};
+  state.materialized = scope;
+  state.materialize = () => scope;
+  return scope;
+}
 const lazyInertActorState = Symbol();
 const snapshotActorScopes = new WeakMap();
 let inertActorMaterializationObserver;
@@ -2516,12 +2655,14 @@ const lazyInertActorScopePrototype = {
     return materializeInertActorScope(this).actionExecutor;
   }
 };
-function createMaterializedInertActorScope(actorLogic, sourceRef, sourceChildren, currentSnapshot, sourceSelf) {
+
+/** Creates a transactional planning scope backed by an inert actor. */
+function createMaterializedInertActorScope(actorLogic, sourceRef, sourceChildren, currentSnapshot, sourceSelf, owner) {
   inertActorMaterializationObserver?.();
   const snapshotRef = sourceRef?.();
   const previousSelf = sourceSelf ?? snapshotRef?.actor;
   const baseSystem = previousSelf?.system;
-  const system = previousSelf && baseSystem ? createSnapshotSystem(baseSystem, sourceChildren, sourceSelf ? undefined : snapshotRef?.systemState) : undefined;
+  const system = previousSelf && baseSystem ? createSnapshotSystem(baseSystem, sourceChildren, sourceSelf ? undefined : snapshotRef?.systemState, owner) : undefined;
   const self = createActor(actorLogic, {
     _inert: true,
     ...(previousSelf ? {
@@ -2541,12 +2682,8 @@ function createMaterializedInertActorScope(actorLogic, sourceRef, sourceChildren
     // a future construction-time read cannot pin a root-shaped address.
     self._address = undefined;
   }
-  if (currentSnapshot) {
-    self._snapshot = currentSnapshot;
-  }
-
   // Reuse the branch actor's scope while keeping planning transactional.
-  return Object.create(self._actorScope, {
+  const scope = Object.create(self._actorScope, {
     defer: {
       value: () => {}
     },
@@ -2555,8 +2692,20 @@ function createMaterializedInertActorScope(actorLogic, sourceRef, sourceChildren
     },
     actionExecutor: {
       value: () => {}
+    },
+    _snapshot: {
+      enumerable: true,
+      configurable: true,
+      get: () => self._snapshot,
+      set: snapshot => {
+        self._snapshot = snapshot;
+      }
     }
   });
+  if (currentSnapshot) {
+    scope._snapshot = currentSnapshot;
+  }
+  return scope;
 }
 
 /** @internal */
@@ -2571,22 +2720,34 @@ function createInertActorScope(actorLogic, snapshot, sourceSelf, sourceActorScop
     sourceChildren: isMachineSnapshot(snapshot) ? snapshot.children : {},
     identityProvider: sourceState?.identityProvider ?? sourceRef,
     parent: sourceSelf?._parent ?? sourceState?.parent ?? eagerSourceRef?.actor._parent,
+    // Only the outermost scope of an owned transition belongs to the owner;
+    // scopes for its intermediate snapshots inherit it, and nested pure
+    // transitions run unowned.
+    owner: sourceActorScope ? sourceState?.owner : takeExecutionOwner(),
     parentKnown: !!sourceSelf || !!sourceState?.parentKnown || !!eagerSourceRef || !snapshot
   };
-  state.materialize = () => state.materialized ??= createMaterializedInertActorScope(actorLogic, state.sourceRef, state.sourceChildren, state.snapshot, sourceSelf);
+  state.materialize = () => {
+    const scope = createMaterializedInertActorScope(actorLogic, state.sourceRef, state.sourceChildren, state.snapshot, sourceSelf, state.owner);
+    return commitMaterialization(state, scope);
+  };
   if (!state.identityProvider && !snapshot) {
     const identitySnapshot = {};
-    const identitySourceRef = state.sourceRef;
-    const identitySourceChildren = state.sourceChildren;
-    let identityScope;
     let identityRef;
-    const getIdentityScope = () => identityScope ??= createMaterializedInertActorScope(actorLogic, identitySourceRef, identitySourceChildren, undefined, sourceSelf);
+    const getIdentityScope = () => {
+      if (!state.identityScope) {
+        state.identityScope = createMaterializedInertActorScope(actorLogic, state.sourceRef, state.sourceChildren, undefined, sourceSelf, state.owner);
+        if (state.snapshot !== undefined) {
+          state.identityScope.self._snapshot = state.snapshot;
+        }
+      }
+      return state.identityScope;
+    };
     state.materialize = () => {
       const scope = getIdentityScope();
       if (state.snapshot !== undefined) {
         scope.self._snapshot = state.snapshot;
       }
-      return state.materialized = scope;
+      return commitMaterialization(state, scope);
     };
     state.identityProvider = () => {
       if (identityRef) {
@@ -3714,7 +3875,7 @@ function microstep(transitions, currentSnapshot, actorScope, event, isInitial, i
           }
           addAncestorStatesToEnter(ancestors, !transition.source.parent && reenter ? undefined : domain);
         }
-        if (reenter && domain === transition.source) {
+        if (targets?.length && reenter && domain === transition.source) {
           // A reentering transition whose domain is its own source exits and
           // reenters the source, so the source must be entered explicitly —
           // it has no ancestor inside the domain to add it.
@@ -4263,7 +4424,9 @@ function macrostep(snapshot, event, actorScope, internalQueue, initialMicrosteps
   if (!internalQueue.length && snapshot.machine._hasEventlessTransitions === false) {
     return completeMacrostep();
   }
-  let shouldSelectEventlessTransitions = true;
+
+  // A timer notification must not run eventless transitions before delivery.
+  let shouldSelectEventlessTransitions = event.type !== XSTATE_TIMER;
   const maxIterations = snapshot.machine.options?.maxIterations ?? Infinity;
   let iterationCount = 0;
   // The last few state values visited, for the infinite-loop error.
@@ -4559,6 +4722,8 @@ const machineSnapshotToJSON = function toJSON() {
   const {
     nodes,
     _stateInputs,
+    _nextTimerId,
+    _nextActorIds,
     tags,
     machine,
     getMeta,
@@ -4677,6 +4842,8 @@ function getPersistedSnapshot(snapshot, options) {
   const {
     nodes,
     _stateInputs,
+    _nextTimerId,
+    _nextActorIds,
     tags,
     machine,
     children,
@@ -4803,6 +4970,11 @@ function getPersistedSnapshot(snapshot, options) {
   if (_stateInputs && Object.keys(_stateInputs).length > 0) {
     persisted.stateInputs = _stateInputs;
   }
+  // Stores such as Convex reject `_`-prefixed field names.
+  persisted.nextTimerId = _nextTimerId;
+  if (_nextActorIds && Object.keys(_nextActorIds).length > 0) {
+    persisted.nextActorIds = _nextActorIds;
+  }
   if (machine.version !== undefined) {
     persisted.machine = {
       id: machine.id,
@@ -4825,7 +4997,7 @@ function persistContext(contextPart, getActorId, path = 'context', ancestors = [
         };
         // The address lets refs to non-children still route after restore.
         copy[key] = {
-          $actor: value.address
+          '@actor': value.address
         };
       } else {
         const valuePath = Array.isArray(contextPart) ? `${path}[${key}]` : `${path}.${key}`;
@@ -5458,11 +5630,18 @@ class RuntimeSystem {
   // 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.
+  // A send made with no transition in flight (a callback's `sendBack`, a value
+  // an observable relays to its parent) is not recorded: no transition reports
+  // it, so it would be held until the source's next transition, or for as long
+  // as the source lives if it never makes one.
   _recordSent(source, target, event, delay, id) {
     if (!this._inspectionObservers?.size || !source) {
       return;
     }
     const inspectionSource = source;
+    if (!inspectionSource._inTransition) {
+      return;
+    }
     const collected = inspectionSource._collectedSent ??= [];
     collected.push({
       targetRef: target,
@@ -5699,9 +5878,9 @@ class RuntimeSystem {
       } else if (
       // A live actor of another incarnation is stale locally; an
       // address this system cannot see may belong to a host runtime.
-      this._getByAddress(target.$actor) || !this.runtime?.sendEvent) {
+      this._getByAddress(target['@actor']) || !this.runtime?.sendEvent) {
         return this.deadLetter(source, undefined, event, 'missingTarget', {
-          targetId: getAddressId(target.$actor),
+          targetId: getAddressId(target['@actor']),
           error: createMissingAddressError(target)
         });
       }
@@ -5985,6 +6164,12 @@ class Actor {
     this._collectedActions = void 0;
     /** @internal Events relayed to other actors during the in-flight transition. */
     this._collectedSent = void 0;
+    /**
+     * @internal Whether a transition is in flight: while the actor starts,
+     * processes an event, or recovers from an execution error. Sends are recorded
+     * for `sent[]` only then.
+     */
+    this._inTransition = false;
     this._initialEffects = void 0;
     this.registryKey = void 0;
     /** The globally unique process ID for this invocation. */
@@ -6057,9 +6242,14 @@ class Actor {
         // transition functions; computing an initial snapshot here would run
         // init-time side effects (context factories, entry) a second time.
       } else {
-        const [snapshot, effects] = finalizeTransitionResult(this._actorScope, undefined, this.logic.initialTransition(this.options?.input, this._actorScope));
-        this._setSnapshot(snapshot);
-        this._initialEffects = effects.length ? effects : undefined;
+        this._inTransition = true;
+        try {
+          const [snapshot, effects] = finalizeTransitionResult(this._actorScope, undefined, this.logic.initialTransition(this.options?.input, this._actorScope));
+          this._setSnapshot(snapshot);
+          this._initialEffects = effects.length ? effects : undefined;
+        } finally {
+          this._inTransition = false;
+        }
       }
     } catch (err) {
       // Restored logic may keep its snapshot shape on restore failures (e.g.
@@ -6212,6 +6402,8 @@ class Actor {
     if (!errorEvent) {
       return false;
     }
+    const inTransition = this._inTransition;
+    this._inTransition = true;
     try {
       const [nextSnapshot, effects] = finalizeTransitionResult(this._actorScope, snapshot, this.logic.transition(snapshot, errorEvent, this._actorScope));
       this._setSnapshot(nextSnapshot);
@@ -6220,6 +6412,8 @@ class Actor {
       return true;
     } catch {
       return false;
+    } finally {
+      this._inTransition = inTransition;
     }
   }
   _next(snapshot) {
@@ -6431,6 +6625,15 @@ class Actor {
 
   /** Starts the Actor from the initial state */
   start() {
+    const inTransition = this._inTransition;
+    this._inTransition = true;
+    try {
+      return this._start();
+    } finally {
+      this._inTransition = inTransition;
+    }
+  }
+  _start() {
     if (this._processingStatus === ProcessingStatus.Running) {
       // Do not restart the service if it is already started
       return this;
@@ -6546,7 +6749,16 @@ class Actor {
     this.mailbox?.start();
     return this;
   }
-  _process({
+  _process(item) {
+    const inTransition = this._inTransition;
+    this._inTransition = true;
+    try {
+      this._processEvent(item);
+    } finally {
+      this._inTransition = inTransition;
+    }
+  }
+  _processEvent({
     event,
     sourceRef
   }) {
@@ -6783,12 +6995,12 @@ class Actor {
   }
 
   /**
-   * Returns the actor's serializable logical identity: `{ $actor: address }`.
+   * Returns the actor's serializable logical identity: `{ "@actor": address }`.
    * The result can be used as an `enq.sendTo(...)` target.
    */
   toJSON() {
     return {
-      $actor: this.address
+      '@actor': this.address
     };
   }
 
@@ -6899,4 +7111,4 @@ function createActor(logic, ...[options]) {
   return new Actor(logic, options);
 }
 
-export { resolveRegisteredActorSource as $, isMachineSnapshot as A, listenerLogic as B, subscriptionLogic as C, createListenerLogic as D, createSubscriptionLogic as E, Actor as F, matchesState as G, toObserver as H, InfiniteTransitionError as I, executeEffects as J, isBuiltInExecutableEffect as K, deliverEvent as L, runStep as M, stopActor as N, terminateActor as O, ProcessingStatus as P, createInitEvent as Q, createDeadLetterEffect as R, createCustomEffect as S, XSTATE_LOGIC_EFFECT_START as T, XSTATE_LOGIC_EFFECT_RESOLVE as U, XSTATE_LOGIC_EFFECT_REJECT as V, createEmitEffect as W, XSTATE_STOP_EFFECT as X, createSendToEffect as Y, XSTATE_INIT as Z, publishEmittedEvent as _, assertUnreservedSourceName as a, allocateChildId as a0, assertChildIdFree as a1, reserveChildId as a2, hasUnescapedDot as a3, STATE_DELIMITER as a4, mapValues as a5, createInvokeId as a6, getDelayedTransitions as a7, getCandidates as a8, evaluateCandidate as a9, initialMicrostep as aA, createStartEffect as aB, isStateId as aC, getPersistedSnapshot as aD, detachedScopes as aE, hasAmbientInspector as aF, getProperAncestors as aG, isRemoteActorRef as aH, getAllOwnEvents as aI, matchesEvent as aJ, getRootActorId as aK, RUNTIME_OPERATIONS as aL, withSystemInspector as aM, createTimerEffect as aN, getSnapshotActorRef as aO, withExecutionIdentity as aP, getTimerStart as aQ, recordTimerStart as aR, diagnoseActorOptions as aS, createRemoteActorRef as aT, createInvokeTimeoutEvent as aU, parseGeneratedActorId as aV, formatTransition as aa, NULL_EVENT as ab, toTransitionConfigArray as ac, matchesActorSession as ad, describeMachine as ae, formatRouteTransitions as af, resolveStateValue as ag, isInFinalState as ah, createInertActorScope as ai, setInertActorScopeSnapshot as aj, beginSpawnAllocation as ak, attachSnapshotActorRef as al, macrostep as am, isInertActorScope as an, setSnapshotActorRef as ao, cloneMachineSnapshot as ap, transitionNode as aq, XSTATE_TIMER as ar, getTransitionResult as as, hasEffect as at, createErrorPlatformEvent as au, withActorSelf as av, resolveActionsWithContext as aw, takeSpawnAllocationCounters as ax, mergeActorIdCounters as ay, createSpawnEffect as az, getStateNodes as b, isActorRefLike as c, diagnoseAuthorConfig as d, createMachineSnapshot as e, diagnoseSetupConfig as f, getAllStateNodes as g, createActor as h, isAtomicStateNode as i, encodeAddressSegment as j, getActorIdPrefix as k, finalizeTransitionResult as l, matchesEventDescriptor as m, getTimerKey as n, isSerializedActorRef as o, parseDelayToMilliseconds as p, readTimerKey as q, resolveInvokedActorLogic as r, systemLogicMetadata as s, toArray as t, XSTATE_STOP as u, createDoneActorEvent as v, createErrorActorEvent as w, xstateError as x, serializeTimerKey as y, matchesTimerKey as z };
+export { publishEmittedEvent as $, matchesTimerKey as A, isMachineSnapshot as B, listenerLogic as C, subscriptionLogic as D, createListenerLogic as E, createSubscriptionLogic as F, Actor as G, matchesState as H, InfiniteTransitionError as I, toObserver as J, executeEffects as K, isBuiltInExecutableEffect as L, deliverEvent as M, runStep as N, stopActor as O, ProcessingStatus as P, terminateActor as Q, createInitEvent as R, createDeadLetterEffect as S, createCustomEffect as T, XSTATE_LOGIC_EFFECT_START as U, XSTATE_LOGIC_EFFECT_RESOLVE as V, XSTATE_LOGIC_EFFECT_REJECT as W, XSTATE_ATTACHED_FORWARD as X, createEmitEffect as Y, createSendToEffect as Z, XSTATE_INIT as _, assertUnreservedSourceName as a, resolveRegisteredActorSource as a0, allocateChildId as a1, assertChildIdFree as a2, reserveChildId as a3, hasUnescapedDot as a4, STATE_DELIMITER as a5, mapValues as a6, createInvokeId as a7, getDelayedTransitions as a8, getCandidates as a9, createSpawnEffect as aA, initialMicrostep as aB, createStartEffect as aC, isStateId as aD, getPersistedSnapshot as aE, detachedScopes as aF, hasAmbientInspector as aG, getProperAncestors as aH, isRemoteActorRef as aI, getAllOwnEvents as aJ, matchesEvent as aK, getRootActorId as aL, RUNTIME_OPERATIONS as aM, createTimerEffect as aN, getSnapshotActorRef as aO, withExecutionOwner as aP, getTimerStart as aQ, recordTimerStart as aR, withSystemInspector as aS, adoptSystem as aT, withExecutionIdentity as aU, diagnoseActorOptions as aV, createRemoteActorRef as aW, createInvokeTimeoutEvent as aX, parseGeneratedActorId as aY, evaluateCandidate as aa, formatTransition as ab, NULL_EVENT as ac, toTransitionConfigArray as ad, matchesActorSession as ae, describeMachine as af, formatRouteTransitions as ag, resolveStateValue as ah, isInFinalState as ai, createInertActorScope as aj, setInertActorScopeSnapshot as ak, beginSpawnAllocation as al, attachSnapshotActorRef as am, macrostep as an, isInertActorScope as ao, setSnapshotActorRef as ap, cloneMachineSnapshot as aq, transitionNode as ar, XSTATE_TIMER as as, getTransitionResult as at, hasEffect as au, createErrorPlatformEvent as av, withActorSelf as aw, resolveActionsWithContext as ax, takeSpawnAllocationCounters as ay, mergeActorIdCounters as az, getStateNodes as b, isActorRefLike as c, diagnoseAuthorConfig as d, createMachineSnapshot as e, diagnoseSetupConfig as f, getAllStateNodes as g, createActor as h, isAtomicStateNode as i, encodeAddressSegment as j, getActorIdPrefix as k, finalizeTransitionResult as l, matchesEventDescriptor as m, getTimerKey as n, isSerializedActorRef as o, parseDelayToMilliseconds as p, readTimerKey as q, resolveInvokedActorLogic as r, systemLogicMetadata as s, toArray as t, XSTATE_STOP_EFFECT as u, XSTATE_STOP as v, createDoneActorEvent as w, xstateError as x, createErrorActorEvent as y, serializeTimerKey as z };