xstate 6.0.0-alpha.43 → 6.0.0-alpha.45

package/dist/{StateMachine-fcc48e11.cjs.js → StateMachine-2eecedfe.cjs.js}

@@ -1,7 +1,7 @@
 'use strict';
 
-var createActor = require('./createActor-9538c7f8.cjs.js');
-var dist_xstateActors = require('./index-ba7170ba.cjs.js');
+var createActor = require('./createActor-48401456.cjs.js');
+var dist_xstateActors = require('./index-fce4ea5c.cjs.js');
 
 function createSpawner(actorScope, actors, spawnedChildren) {
   return (src, options) => {

package/dist/{StateMachine-1ea29688.development.esm.js → StateMachine-4bf86161.development.esm.js}

@@ -1,5 +1,5 @@
-import { Q as allocateChildId, R as assertChildIdFree, S as reserveChildId, T as STATE_DELIMITER, U as mapValues, t as toArray, V as createInvokeId, W as getDelayedTransitions, Y as getEventDescriptorKey, Z as getCandidates, _ as evaluateCandidate, $ as formatTransition, a0 as NULL_EVENT, a1 as toTransitionConfigArray, a2 as createInvokeTimeoutEventId, a3 as matchesActorSession, a4 as formatRouteTransitions, a5 as resolveStateValue, a6 as getAllStateNodes, x as getStateNodes, a7 as createMachineSnapshot, a8 as isInFinalState, a9 as createInertActorScope, aa as setInertActorScopeSnapshot, a as beginSpawnAllocation, ab as attachSnapshotActorRef, ac as macrostep, ad as isInertActorScope, ae as setSnapshotActorRef, af as cloneMachineSnapshot, ag as transitionNode, g as XSTATE_TIMER, m as matchesEventDescriptor, ah as getTransitionResult, ai as hasEffect, aj as createErrorPlatformEvent, ak as withActorSelf, r as resolveActionsWithContext, al as takeSpawnAllocationCounters, am as mergeActorIdCounters, K as createInitEvent, an as createSpawnEffect, ao as initialMicrostep, ap as toStatePath, aq as isStateId, ar as getStateNodeByPath, as as getPersistedSnapshot, at as createRemoteActorRef, au as resolveReferencedActor, av as createInvokeTimeoutEvent, aw as parseGeneratedActorId, ax as ACTOR_REF_TYPE, k as createActor } from './createActor-f9cc6590.development.esm.js';
-import { g as assertValid } from './index-f284cc7b.development.esm.js';
+import { Q as allocateChildId, R as assertChildIdFree, S as reserveChildId, T as STATE_DELIMITER, U as mapValues, t as toArray, V as createInvokeId, W as getDelayedTransitions, Y as getEventDescriptorKey, Z as getCandidates, _ as evaluateCandidate, $ as formatTransition, a0 as NULL_EVENT, a1 as toTransitionConfigArray, a2 as createInvokeTimeoutEventId, a3 as matchesActorSession, a4 as formatRouteTransitions, a5 as resolveStateValue, a6 as getAllStateNodes, x as getStateNodes, a7 as createMachineSnapshot, a8 as isInFinalState, a9 as createInertActorScope, aa as setInertActorScopeSnapshot, a as beginSpawnAllocation, ab as attachSnapshotActorRef, ac as macrostep, ad as isInertActorScope, ae as setSnapshotActorRef, af as cloneMachineSnapshot, ag as transitionNode, g as XSTATE_TIMER, m as matchesEventDescriptor, ah as getTransitionResult, ai as hasEffect, aj as createErrorPlatformEvent, ak as withActorSelf, r as resolveActionsWithContext, al as takeSpawnAllocationCounters, am as mergeActorIdCounters, K as createInitEvent, an as createSpawnEffect, ao as initialMicrostep, ap as toStatePath, aq as isStateId, ar as getStateNodeByPath, as as getPersistedSnapshot, at as createRemoteActorRef, au as resolveReferencedActor, av as createInvokeTimeoutEvent, aw as parseGeneratedActorId, ax as ACTOR_REF_TYPE, k as createActor } from './createActor-60ee6b5b.development.esm.js';
+import { g as assertValid } from './index-158e7c37.development.esm.js';
 
 function createSpawner(actorScope, actors, spawnedChildren) {
   return (src, options) => {

package/dist/{StateMachine-16d7ee93.development.cjs.js → StateMachine-5b915fb1.development.cjs.js}

@@ -1,7 +1,7 @@
 'use strict';
 
-var createActor = require('./createActor-1a3a1d14.development.cjs.js');
-var dist_xstateActors = require('./index-e0ba4813.development.cjs.js');
+var createActor = require('./createActor-5c9fa117.development.cjs.js');
+var dist_xstateActors = require('./index-662114ff.development.cjs.js');
 
 function createSpawner(actorScope, actors, spawnedChildren) {
   return (src, options) => {

package/dist/{StateMachine-b13b4b09.esm.js → StateMachine-d2fcf2e8.esm.js}

@@ -1,5 +1,5 @@
-import { Q as allocateChildId, R as assertChildIdFree, S as reserveChildId, T as STATE_DELIMITER, U as mapValues, t as toArray, V as createInvokeId, W as getDelayedTransitions, Y as getEventDescriptorKey, Z as getCandidates, _ as evaluateCandidate, $ as formatTransition, a0 as NULL_EVENT, a1 as toTransitionConfigArray, a2 as createInvokeTimeoutEventId, a3 as matchesActorSession, a4 as formatRouteTransitions, a5 as resolveStateValue, a6 as getAllStateNodes, x as getStateNodes, a7 as createMachineSnapshot, a8 as isInFinalState, a9 as createInertActorScope, aa as setInertActorScopeSnapshot, a as beginSpawnAllocation, ab as attachSnapshotActorRef, ac as macrostep, ad as isInertActorScope, ae as setSnapshotActorRef, af as cloneMachineSnapshot, ag as transitionNode, g as XSTATE_TIMER, m as matchesEventDescriptor, ah as getTransitionResult, ai as hasEffect, aj as createErrorPlatformEvent, ak as withActorSelf, r as resolveActionsWithContext, al as takeSpawnAllocationCounters, am as mergeActorIdCounters, K as createInitEvent, an as createSpawnEffect, ao as initialMicrostep, ap as toStatePath, aq as isStateId, ar as getStateNodeByPath, as as getPersistedSnapshot, at as createRemoteActorRef, au as resolveReferencedActor, av as createInvokeTimeoutEvent, aw as parseGeneratedActorId, ax as ACTOR_REF_TYPE, k as createActor } from './createActor-973c72ad.esm.js';
-import { g as assertValid } from './index-b478f443.esm.js';
+import { Q as allocateChildId, R as assertChildIdFree, S as reserveChildId, T as STATE_DELIMITER, U as mapValues, t as toArray, V as createInvokeId, W as getDelayedTransitions, Y as getEventDescriptorKey, Z as getCandidates, _ as evaluateCandidate, $ as formatTransition, a0 as NULL_EVENT, a1 as toTransitionConfigArray, a2 as createInvokeTimeoutEventId, a3 as matchesActorSession, a4 as formatRouteTransitions, a5 as resolveStateValue, a6 as getAllStateNodes, x as getStateNodes, a7 as createMachineSnapshot, a8 as isInFinalState, a9 as createInertActorScope, aa as setInertActorScopeSnapshot, a as beginSpawnAllocation, ab as attachSnapshotActorRef, ac as macrostep, ad as isInertActorScope, ae as setSnapshotActorRef, af as cloneMachineSnapshot, ag as transitionNode, g as XSTATE_TIMER, m as matchesEventDescriptor, ah as getTransitionResult, ai as hasEffect, aj as createErrorPlatformEvent, ak as withActorSelf, r as resolveActionsWithContext, al as takeSpawnAllocationCounters, am as mergeActorIdCounters, K as createInitEvent, an as createSpawnEffect, ao as initialMicrostep, ap as toStatePath, aq as isStateId, ar as getStateNodeByPath, as as getPersistedSnapshot, at as createRemoteActorRef, au as resolveReferencedActor, av as createInvokeTimeoutEvent, aw as parseGeneratedActorId, ax as ACTOR_REF_TYPE, k as createActor } from './createActor-641ab5f7.esm.js';
+import { g as assertValid } from './index-8f19f242.esm.js';
 
 function createSpawner(actorScope, actors, spawnedChildren) {
   return (src, options) => {

package/dist/{createActor-9538c7f8.cjs.js → createActor-48401456.cjs.js}

@@ -1266,6 +1266,45 @@ function parseDelayToMilliseconds(delay) {
   return parseDurationToMilliseconds(delay);
 }
 
+/**
+ * The ambiently installed system inspector. Set for the duration of a durable
+ * execution's transitions (`createDurable(..., { inspect })`), it makes the
+ * pure-transition machinery observable: freshly constructed runtime systems
+ * attach it, and snapshot systems created while it is set forward inspection
+ * to their base system instead of stubbing it out.
+ */
+let ambientInspector;
+
+/** @internal */
+function hasAmbientInspector() {
+  return ambientInspector !== undefined;
+}
+
+/** @internal */
+function getAmbientInspector() {
+  return ambientInspector;
+}
+
+/**
+ * Runs `fn` with systems it creates wired to `inspect` from construction, so
+ * creation-time inspection events (the root actor's own registration, actors
+ * spawned during the first transition) are observed too.
+ *
+ * @internal
+ */
+function withSystemInspector(inspect, fn) {
+  if (!inspect) {
+    return fn();
+  }
+  const previous = ambientInspector;
+  ambientInspector = inspect;
+  try {
+    return fn();
+  } finally {
+    ambientInspector = previous;
+  }
+}
+
 /** Snapshot-scoped actor identity and system view. @internal */
 
 const snapshotActorRefs = new WeakMap();
@@ -1328,6 +1367,7 @@ function getSnapshotChildren(snapshot) {
  * @internal
  */
 function createSnapshotSystem(baseSystem, children, baseState) {
+  const forwardInspection = hasAmbientInspector();
   const registeredActors = copyRegisteredActors(baseSystem, baseState);
   const keyedActors = new Map(baseState?.keyedActors ?? getKeyedActors(baseSystem));
   const reverseKeyedActors = new WeakMap();
@@ -1366,10 +1406,13 @@ function createSnapshotSystem(baseSystem, children, baseState) {
     },
     get: registryKey => keyedActors.get(registryKey),
     getAll: () => Object.fromEntries(keyedActors),
-    // Pure transition resolution must not leak topology inspection events into
-    // a live runtime system.
-    _hasInspectionObservers: () => false,
-    _sendInspectionEvent: () => {}
+    // 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) : () => {}
   });
   for (const [registryKey, actor] of keyedActors) {
     if (!actor) {
@@ -4372,6 +4415,10 @@ class RuntimeSystem {
     this._clock = options.clock;
     this._logger = options.logger;
     this.createActorRef = options.createActorRef;
+    const ambientInspector = getAmbientInspector();
+    if (ambientInspector) {
+      this.inspect(ambientInspector);
+    }
     this._snapshot = {
       _scheduledTimers: restoredSnapshot?.scheduler ?? emptyScheduledTimers,
       // System-level counters are process-local backstops; per-actor
@@ -5072,6 +5119,9 @@ class Actor {
     }
     this._inspectTransition(this._snapshot, event);
   }
+
+  /** @internal Emits the transition inspection event; used by the pure
+   * `transition()` path for snapshots driven outside a live actor. */
   _inspectTransition(snapshot, event) {
     if (this.system._hasInspectionObservers?.() ?? true) {
       this.system._sendInspectionEvent({
@@ -5672,6 +5722,7 @@ exports.getSnapshotActorRef = getSnapshotActorRef;
 exports.getStateNodeByPath = getStateNodeByPath;
 exports.getStateNodes = getStateNodes;
 exports.getTransitionResult = getTransitionResult;
+exports.hasAmbientInspector = hasAmbientInspector;
 exports.hasEffect = hasEffect;
 exports.initialMicrostep = initialMicrostep;
 exports.isAtomicStateNode = isAtomicStateNode;
@@ -5712,3 +5763,4 @@ exports.transitionNode = transitionNode;
 exports.withActorScope = withActorScope;
 exports.withActorSelf = withActorSelf;
 exports.withExecutionIdentity = withExecutionIdentity;
+exports.withSystemInspector = withSystemInspector;

package/dist/{createActor-1a3a1d14.development.cjs.js → createActor-5c9fa117.development.cjs.js}

@@ -1274,6 +1274,45 @@ function parseDelayToMilliseconds(delay) {
   return parseDurationToMilliseconds(delay);
 }
 
+/**
+ * The ambiently installed system inspector. Set for the duration of a durable
+ * execution's transitions (`createDurable(..., { inspect })`), it makes the
+ * pure-transition machinery observable: freshly constructed runtime systems
+ * attach it, and snapshot systems created while it is set forward inspection
+ * to their base system instead of stubbing it out.
+ */
+let ambientInspector;
+
+/** @internal */
+function hasAmbientInspector() {
+  return ambientInspector !== undefined;
+}
+
+/** @internal */
+function getAmbientInspector() {
+  return ambientInspector;
+}
+
+/**
+ * Runs `fn` with systems it creates wired to `inspect` from construction, so
+ * creation-time inspection events (the root actor's own registration, actors
+ * spawned during the first transition) are observed too.
+ *
+ * @internal
+ */
+function withSystemInspector(inspect, fn) {
+  if (!inspect) {
+    return fn();
+  }
+  const previous = ambientInspector;
+  ambientInspector = inspect;
+  try {
+    return fn();
+  } finally {
+    ambientInspector = previous;
+  }
+}
+
 /** Snapshot-scoped actor identity and system view. @internal */
 
 const snapshotActorRefs = new WeakMap();
@@ -1336,6 +1375,7 @@ function getSnapshotChildren(snapshot) {
  * @internal
  */
 function createSnapshotSystem(baseSystem, children, baseState) {
+  const forwardInspection = hasAmbientInspector();
   const registeredActors = copyRegisteredActors(baseSystem, baseState);
   const keyedActors = new Map(baseState?.keyedActors ?? getKeyedActors(baseSystem));
   const reverseKeyedActors = new WeakMap();
@@ -1374,10 +1414,13 @@ function createSnapshotSystem(baseSystem, children, baseState) {
     },
     get: registryKey => keyedActors.get(registryKey),
     getAll: () => Object.fromEntries(keyedActors),
-    // Pure transition resolution must not leak topology inspection events into
-    // a live runtime system.
-    _hasInspectionObservers: () => false,
-    _sendInspectionEvent: () => {}
+    // 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) : () => {}
   });
   for (const [registryKey, actor] of keyedActors) {
     if (!actor) {
@@ -4405,6 +4448,10 @@ class RuntimeSystem {
     this._clock = options.clock;
     this._logger = options.logger;
     this.createActorRef = options.createActorRef;
+    const ambientInspector = getAmbientInspector();
+    if (ambientInspector) {
+      this.inspect(ambientInspector);
+    }
     this._snapshot = {
       _scheduledTimers: restoredSnapshot?.scheduler ?? emptyScheduledTimers,
       // System-level counters are process-local backstops; per-actor
@@ -5108,6 +5155,9 @@ class Actor {
     }
     this._inspectTransition(this._snapshot, event);
   }
+
+  /** @internal Emits the transition inspection event; used by the pure
+   * `transition()` path for snapshots driven outside a live actor. */
   _inspectTransition(snapshot, event) {
     if (this.system._hasInspectionObservers?.() ?? true) {
       this.system._sendInspectionEvent({
@@ -5714,6 +5764,7 @@ exports.getSnapshotActorRef = getSnapshotActorRef;
 exports.getStateNodeByPath = getStateNodeByPath;
 exports.getStateNodes = getStateNodes;
 exports.getTransitionResult = getTransitionResult;
+exports.hasAmbientInspector = hasAmbientInspector;
 exports.hasEffect = hasEffect;
 exports.initialMicrostep = initialMicrostep;
 exports.isAtomicStateNode = isAtomicStateNode;
@@ -5754,3 +5805,4 @@ exports.transitionNode = transitionNode;
 exports.withActorScope = withActorScope;
 exports.withActorSelf = withActorSelf;
 exports.withExecutionIdentity = withExecutionIdentity;
+exports.withSystemInspector = withSystemInspector;

package/dist/{createActor-f9cc6590.development.esm.js → createActor-60ee6b5b.development.esm.js}

@@ -1272,6 +1272,45 @@ function parseDelayToMilliseconds(delay) {
   return parseDurationToMilliseconds(delay);
 }
 
+/**
+ * The ambiently installed system inspector. Set for the duration of a durable
+ * execution's transitions (`createDurable(..., { inspect })`), it makes the
+ * pure-transition machinery observable: freshly constructed runtime systems
+ * attach it, and snapshot systems created while it is set forward inspection
+ * to their base system instead of stubbing it out.
+ */
+let ambientInspector;
+
+/** @internal */
+function hasAmbientInspector() {
+  return ambientInspector !== undefined;
+}
+
+/** @internal */
+function getAmbientInspector() {
+  return ambientInspector;
+}
+
+/**
+ * Runs `fn` with systems it creates wired to `inspect` from construction, so
+ * creation-time inspection events (the root actor's own registration, actors
+ * spawned during the first transition) are observed too.
+ *
+ * @internal
+ */
+function withSystemInspector(inspect, fn) {
+  if (!inspect) {
+    return fn();
+  }
+  const previous = ambientInspector;
+  ambientInspector = inspect;
+  try {
+    return fn();
+  } finally {
+    ambientInspector = previous;
+  }
+}
+
 /** Snapshot-scoped actor identity and system view. @internal */
 
 const snapshotActorRefs = new WeakMap();
@@ -1334,6 +1373,7 @@ function getSnapshotChildren(snapshot) {
  * @internal
  */
 function createSnapshotSystem(baseSystem, children, baseState) {
+  const forwardInspection = hasAmbientInspector();
   const registeredActors = copyRegisteredActors(baseSystem, baseState);
   const keyedActors = new Map(baseState?.keyedActors ?? getKeyedActors(baseSystem));
   const reverseKeyedActors = new WeakMap();
@@ -1372,10 +1412,13 @@ function createSnapshotSystem(baseSystem, children, baseState) {
     },
     get: registryKey => keyedActors.get(registryKey),
     getAll: () => Object.fromEntries(keyedActors),
-    // Pure transition resolution must not leak topology inspection events into
-    // a live runtime system.
-    _hasInspectionObservers: () => false,
-    _sendInspectionEvent: () => {}
+    // 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) : () => {}
   });
   for (const [registryKey, actor] of keyedActors) {
     if (!actor) {
@@ -4403,6 +4446,10 @@ class RuntimeSystem {
     this._clock = options.clock;
     this._logger = options.logger;
     this.createActorRef = options.createActorRef;
+    const ambientInspector = getAmbientInspector();
+    if (ambientInspector) {
+      this.inspect(ambientInspector);
+    }
     this._snapshot = {
       _scheduledTimers: restoredSnapshot?.scheduler ?? emptyScheduledTimers,
       // System-level counters are process-local backstops; per-actor
@@ -5106,6 +5153,9 @@ class Actor {
     }
     this._inspectTransition(this._snapshot, event);
   }
+
+  /** @internal Emits the transition inspection event; used by the pure
+   * `transition()` path for snapshots driven outside a live actor. */
   _inspectTransition(snapshot, event) {
     if (this.system._hasInspectionObservers?.() ?? true) {
       this.system._sendInspectionEvent({
@@ -5654,4 +5704,4 @@ function createActor(logic, options) {
   return new Actor(logic, options);
 }
 
-export { formatTransition as $, Actor as A, checkStateIn as B, pathToStateValue as C, toObserver as D, executeEffects as E, isBuiltInExecutableAction as F, deliverEvent as G, runStep as H, stopActor as I, terminateActor as J, createInitEvent as K, createCustomEffect as L, XSTATE_LOGIC_EFFECT_START as M, XSTATE_LOGIC_EFFECT_RESOLVE as N, XSTATE_LOGIC_EFFECT_REJECT as O, createEmitEffect as P, allocateChildId as Q, assertChildIdFree as R, reserveChildId as S, STATE_DELIMITER as T, mapValues as U, createInvokeId as V, getDelayedTransitions as W, XSTATE_INIT as X, getEventDescriptorKey as Y, getCandidates as Z, evaluateCandidate as _, beginSpawnAllocation as a, NULL_EVENT as a0, toTransitionConfigArray as a1, createInvokeTimeoutEventId as a2, matchesActorSession as a3, formatRouteTransitions as a4, resolveStateValue as a5, getAllStateNodes as a6, createMachineSnapshot as a7, isInFinalState as a8, createInertActorScope as a9, getActorIdPrefix as aA, getAllOwnEvents as aB, matchesEvent as aC, encodeAddressSegment as aD, getRootActorId as aE, RUNTIME_OPERATIONS as aF, withExecutionIdentity as aG, getSnapshotActorRef as aH, setInertActorScopeSnapshot as aa, attachSnapshotActorRef as ab, macrostep as ac, isInertActorScope as ad, setSnapshotActorRef as ae, cloneMachineSnapshot as af, transitionNode as ag, getTransitionResult as ah, hasEffect as ai, createErrorPlatformEvent as aj, withActorSelf as ak, takeSpawnAllocationCounters as al, mergeActorIdCounters as am, createSpawnEffect as an, initialMicrostep as ao, toStatePath as ap, isStateId as aq, getStateNodeByPath as ar, getPersistedSnapshot as as, createRemoteActorRef as at, resolveReferencedActor as au, createInvokeTimeoutEvent as av, parseGeneratedActorId as aw, ACTOR_REF_TYPE as ax, getProperAncestors as ay, isRemoteActorRef as az, builtInActions as b, createTransitionEnqueue as c, deriveDeferredStarts as d, XSTATE_STOP as e, finalizeTransitionResult as f, XSTATE_TIMER as g, createSendToEffect as h, isLazyActorScope as i, isAtomicStateNode as j, createActor as k, createListenerLogic as l, matchesEventDescriptor as m, createSubscriptionLogic as n, listenerLogic as o, parseDelayToMilliseconds as p, getInitialSnapshot as q, resolveActionsWithContext as r, subscriptionLogic as s, toArray as t, getNextSnapshot as u, isMachineSnapshot as v, withActorScope as w, getStateNodes as x, getAllOwnEventDescriptors as y, matchesState as z };
+export { formatTransition as $, Actor as A, checkStateIn as B, pathToStateValue as C, toObserver as D, executeEffects as E, isBuiltInExecutableAction as F, deliverEvent as G, runStep as H, stopActor as I, terminateActor as J, createInitEvent as K, createCustomEffect as L, XSTATE_LOGIC_EFFECT_START as M, XSTATE_LOGIC_EFFECT_RESOLVE as N, XSTATE_LOGIC_EFFECT_REJECT as O, createEmitEffect as P, allocateChildId as Q, assertChildIdFree as R, reserveChildId as S, STATE_DELIMITER as T, mapValues as U, createInvokeId as V, getDelayedTransitions as W, XSTATE_INIT as X, getEventDescriptorKey as Y, getCandidates as Z, evaluateCandidate as _, beginSpawnAllocation as a, NULL_EVENT as a0, toTransitionConfigArray as a1, createInvokeTimeoutEventId as a2, matchesActorSession as a3, formatRouteTransitions as a4, resolveStateValue as a5, getAllStateNodes as a6, createMachineSnapshot as a7, isInFinalState as a8, createInertActorScope as a9, isRemoteActorRef as aA, getActorIdPrefix as aB, getAllOwnEvents as aC, matchesEvent as aD, encodeAddressSegment as aE, getRootActorId as aF, RUNTIME_OPERATIONS as aG, withSystemInspector as aH, getSnapshotActorRef as aI, withExecutionIdentity as aJ, setInertActorScopeSnapshot as aa, attachSnapshotActorRef as ab, macrostep as ac, isInertActorScope as ad, setSnapshotActorRef as ae, cloneMachineSnapshot as af, transitionNode as ag, getTransitionResult as ah, hasEffect as ai, createErrorPlatformEvent as aj, withActorSelf as ak, takeSpawnAllocationCounters as al, mergeActorIdCounters as am, createSpawnEffect as an, initialMicrostep as ao, toStatePath as ap, isStateId as aq, getStateNodeByPath as ar, getPersistedSnapshot as as, createRemoteActorRef as at, resolveReferencedActor as au, createInvokeTimeoutEvent as av, parseGeneratedActorId as aw, ACTOR_REF_TYPE as ax, hasAmbientInspector as ay, getProperAncestors as az, builtInActions as b, createTransitionEnqueue as c, deriveDeferredStarts as d, XSTATE_STOP as e, finalizeTransitionResult as f, XSTATE_TIMER as g, createSendToEffect as h, isLazyActorScope as i, isAtomicStateNode as j, createActor as k, createListenerLogic as l, matchesEventDescriptor as m, createSubscriptionLogic as n, listenerLogic as o, parseDelayToMilliseconds as p, getInitialSnapshot as q, resolveActionsWithContext as r, subscriptionLogic as s, toArray as t, getNextSnapshot as u, isMachineSnapshot as v, withActorScope as w, getStateNodes as x, getAllOwnEventDescriptors as y, matchesState as z };

package/dist/{createActor-973c72ad.esm.js → createActor-641ab5f7.esm.js}

@@ -1264,6 +1264,45 @@ function parseDelayToMilliseconds(delay) {
   return parseDurationToMilliseconds(delay);
 }
 
+/**
+ * The ambiently installed system inspector. Set for the duration of a durable
+ * execution's transitions (`createDurable(..., { inspect })`), it makes the
+ * pure-transition machinery observable: freshly constructed runtime systems
+ * attach it, and snapshot systems created while it is set forward inspection
+ * to their base system instead of stubbing it out.
+ */
+let ambientInspector;
+
+/** @internal */
+function hasAmbientInspector() {
+  return ambientInspector !== undefined;
+}
+
+/** @internal */
+function getAmbientInspector() {
+  return ambientInspector;
+}
+
+/**
+ * Runs `fn` with systems it creates wired to `inspect` from construction, so
+ * creation-time inspection events (the root actor's own registration, actors
+ * spawned during the first transition) are observed too.
+ *
+ * @internal
+ */
+function withSystemInspector(inspect, fn) {
+  if (!inspect) {
+    return fn();
+  }
+  const previous = ambientInspector;
+  ambientInspector = inspect;
+  try {
+    return fn();
+  } finally {
+    ambientInspector = previous;
+  }
+}
+
 /** Snapshot-scoped actor identity and system view. @internal */
 
 const snapshotActorRefs = new WeakMap();
@@ -1326,6 +1365,7 @@ function getSnapshotChildren(snapshot) {
  * @internal
  */
 function createSnapshotSystem(baseSystem, children, baseState) {
+  const forwardInspection = hasAmbientInspector();
   const registeredActors = copyRegisteredActors(baseSystem, baseState);
   const keyedActors = new Map(baseState?.keyedActors ?? getKeyedActors(baseSystem));
   const reverseKeyedActors = new WeakMap();
@@ -1364,10 +1404,13 @@ function createSnapshotSystem(baseSystem, children, baseState) {
     },
     get: registryKey => keyedActors.get(registryKey),
     getAll: () => Object.fromEntries(keyedActors),
-    // Pure transition resolution must not leak topology inspection events into
-    // a live runtime system.
-    _hasInspectionObservers: () => false,
-    _sendInspectionEvent: () => {}
+    // 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) : () => {}
   });
   for (const [registryKey, actor] of keyedActors) {
     if (!actor) {
@@ -4370,6 +4413,10 @@ class RuntimeSystem {
     this._clock = options.clock;
     this._logger = options.logger;
     this.createActorRef = options.createActorRef;
+    const ambientInspector = getAmbientInspector();
+    if (ambientInspector) {
+      this.inspect(ambientInspector);
+    }
     this._snapshot = {
       _scheduledTimers: restoredSnapshot?.scheduler ?? emptyScheduledTimers,
       // System-level counters are process-local backstops; per-actor
@@ -5070,6 +5117,9 @@ class Actor {
     }
     this._inspectTransition(this._snapshot, event);
   }
+
+  /** @internal Emits the transition inspection event; used by the pure
+   * `transition()` path for snapshots driven outside a live actor. */
   _inspectTransition(snapshot, event) {
     if (this.system._hasInspectionObservers?.() ?? true) {
       this.system._sendInspectionEvent({
@@ -5612,4 +5662,4 @@ function createActor(logic, options) {
   return new Actor(logic, options);
 }
 
-export { formatTransition as $, Actor as A, checkStateIn as B, pathToStateValue as C, toObserver as D, executeEffects as E, isBuiltInExecutableAction as F, deliverEvent as G, runStep as H, stopActor as I, terminateActor as J, createInitEvent as K, createCustomEffect as L, XSTATE_LOGIC_EFFECT_START as M, XSTATE_LOGIC_EFFECT_RESOLVE as N, XSTATE_LOGIC_EFFECT_REJECT as O, createEmitEffect as P, allocateChildId as Q, assertChildIdFree as R, reserveChildId as S, STATE_DELIMITER as T, mapValues as U, createInvokeId as V, getDelayedTransitions as W, XSTATE_INIT as X, getEventDescriptorKey as Y, getCandidates as Z, evaluateCandidate as _, beginSpawnAllocation as a, NULL_EVENT as a0, toTransitionConfigArray as a1, createInvokeTimeoutEventId as a2, matchesActorSession as a3, formatRouteTransitions as a4, resolveStateValue as a5, getAllStateNodes as a6, createMachineSnapshot as a7, isInFinalState as a8, createInertActorScope as a9, getActorIdPrefix as aA, getAllOwnEvents as aB, matchesEvent as aC, encodeAddressSegment as aD, getRootActorId as aE, RUNTIME_OPERATIONS as aF, withExecutionIdentity as aG, getSnapshotActorRef as aH, setInertActorScopeSnapshot as aa, attachSnapshotActorRef as ab, macrostep as ac, isInertActorScope as ad, setSnapshotActorRef as ae, cloneMachineSnapshot as af, transitionNode as ag, getTransitionResult as ah, hasEffect as ai, createErrorPlatformEvent as aj, withActorSelf as ak, takeSpawnAllocationCounters as al, mergeActorIdCounters as am, createSpawnEffect as an, initialMicrostep as ao, toStatePath as ap, isStateId as aq, getStateNodeByPath as ar, getPersistedSnapshot as as, createRemoteActorRef as at, resolveReferencedActor as au, createInvokeTimeoutEvent as av, parseGeneratedActorId as aw, ACTOR_REF_TYPE as ax, getProperAncestors as ay, isRemoteActorRef as az, builtInActions as b, createTransitionEnqueue as c, deriveDeferredStarts as d, XSTATE_STOP as e, finalizeTransitionResult as f, XSTATE_TIMER as g, createSendToEffect as h, isLazyActorScope as i, isAtomicStateNode as j, createActor as k, createListenerLogic as l, matchesEventDescriptor as m, createSubscriptionLogic as n, listenerLogic as o, parseDelayToMilliseconds as p, getInitialSnapshot as q, resolveActionsWithContext as r, subscriptionLogic as s, toArray as t, getNextSnapshot as u, isMachineSnapshot as v, withActorScope as w, getStateNodes as x, getAllOwnEventDescriptors as y, matchesState as z };
+export { formatTransition as $, Actor as A, checkStateIn as B, pathToStateValue as C, toObserver as D, executeEffects as E, isBuiltInExecutableAction as F, deliverEvent as G, runStep as H, stopActor as I, terminateActor as J, createInitEvent as K, createCustomEffect as L, XSTATE_LOGIC_EFFECT_START as M, XSTATE_LOGIC_EFFECT_RESOLVE as N, XSTATE_LOGIC_EFFECT_REJECT as O, createEmitEffect as P, allocateChildId as Q, assertChildIdFree as R, reserveChildId as S, STATE_DELIMITER as T, mapValues as U, createInvokeId as V, getDelayedTransitions as W, XSTATE_INIT as X, getEventDescriptorKey as Y, getCandidates as Z, evaluateCandidate as _, beginSpawnAllocation as a, NULL_EVENT as a0, toTransitionConfigArray as a1, createInvokeTimeoutEventId as a2, matchesActorSession as a3, formatRouteTransitions as a4, resolveStateValue as a5, getAllStateNodes as a6, createMachineSnapshot as a7, isInFinalState as a8, createInertActorScope as a9, isRemoteActorRef as aA, getActorIdPrefix as aB, getAllOwnEvents as aC, matchesEvent as aD, encodeAddressSegment as aE, getRootActorId as aF, RUNTIME_OPERATIONS as aG, withSystemInspector as aH, getSnapshotActorRef as aI, withExecutionIdentity as aJ, setInertActorScopeSnapshot as aa, attachSnapshotActorRef as ab, macrostep as ac, isInertActorScope as ad, setSnapshotActorRef as ae, cloneMachineSnapshot as af, transitionNode as ag, getTransitionResult as ah, hasEffect as ai, createErrorPlatformEvent as aj, withActorSelf as ak, takeSpawnAllocationCounters as al, mergeActorIdCounters as am, createSpawnEffect as an, initialMicrostep as ao, toStatePath as ap, isStateId as aq, getStateNodeByPath as ar, getPersistedSnapshot as as, createRemoteActorRef as at, resolveReferencedActor as au, createInvokeTimeoutEvent as av, parseGeneratedActorId as aw, ACTOR_REF_TYPE as ax, hasAmbientInspector as ay, getProperAncestors as az, builtInActions as b, createTransitionEnqueue as c, deriveDeferredStarts as d, XSTATE_STOP as e, finalizeTransitionResult as f, XSTATE_TIMER as g, createSendToEffect as h, isLazyActorScope as i, isAtomicStateNode as j, createActor as k, createListenerLogic as l, matchesEventDescriptor as m, createSubscriptionLogic as n, listenerLogic as o, parseDelayToMilliseconds as p, getInitialSnapshot as q, resolveActionsWithContext as r, subscriptionLogic as s, toArray as t, getNextSnapshot as u, isMachineSnapshot as v, withActorScope as w, getStateNodes as x, getAllOwnEventDescriptors as y, matchesState as z };

package/dist/declarations/src/createActor.d.ts

@@ -89,7 +89,6 @@ export declare class Actor<TLogic extends AnyActorLogic> implements ActorInstanc
     private _tryHandleExecutionError;
     private _next;
     private update;
-    private _inspectTransition;
     private _flushInitialEffects;
     /**
      * Subscribe an observer to an actor’s snapshot values.

package/dist/declarations/src/createMachine.d.ts

@@ -1,7 +1,7 @@
 import { StandardSchemaV1 } from "./schema.types.js";
 import { StateMachine } from "./StateMachine.js";
 import { AnyActorRef, EventObject, AnyEventObject, Cast, MachineContext, ProvidedActor, StateValueFromStateSchema, ToChildren, MetaObject, StateSchema, DoNotInfer, RoutableStateId, Compute } from "./types.js";
-import { Sources, DelayMapFromNames, InferChildren, InferOutput, InferEvents, InferInternalEvents, Next_MachineConfig, Next_StateNodeConfig, ValidateDelayReferences, ValidateHistoryDefaults, ValidateStateTargets, ValidateTopLevelFinalOutputs, WidenLiterals, WithDefault } from "./types.v6.js";
+import { Sources, DelayMapFromNames, InferChildren, InferOutput, SchemaOrConfigOutput, InferEvents, InferInternalEvents, Next_MachineConfig, Next_StateNodeConfig, ValidateDelayReferences, ValidateHistoryDefaults, ValidateStateTargets, ValidateTopLevelFinalOutputs, WidenLiterals, WithDefault } from "./types.v6.js";
 type MergeChildren<TChildren extends Record<string, AnyActorRef | undefined>, TActor extends ProvidedActor> = [keyof TChildren] extends [never] ? Compute<ToChildren<TActor>> : Compute<TChildren>;
 type MachineIdentity<TConfig> = {
     readonly id: TConfig extends {
@@ -61,7 +61,7 @@ export declare function createMachine<TContextSchema extends StandardSchemaV1, c
 } & ValidateTopLevelFinalOutputs<TSS, InferOutput<TContextSchema, MachineContext>, InferEvents<TEventSchemaMap> | InferInternalEvents<TInternalEventSchemaMap>>): StateMachine<InferOutput<TContextSchema, MachineContext>, (InferEvents<TEventSchemaMap> | InferInternalEvents<TInternalEventSchemaMap>) | ([RoutableStateId<TSS>] extends [never] ? never : {
     type: 'xstate.route';
     to: RoutableStateId<TSS>;
-}), Cast<MergeChildren<InferChildren<TChildrenSchemaMap>, TActor>, Record<string, AnyActorRef | undefined>>, StateValueFromStateSchema<TSS>, TTag & string, TInput, InferOutput<TOutputSchema, unknown>, WithDefault<InferEvents<TEmittedSchemaMap>, AnyEventObject>, InferOutput<TMetaSchema, MetaObject>, // TMeta
+}), Cast<MergeChildren<InferChildren<TChildrenSchemaMap>, TActor>, Record<string, AnyActorRef | undefined>>, StateValueFromStateSchema<TSS>, TTag & string, TInput, SchemaOrConfigOutput<TOutputSchema, TSS>, WithDefault<InferEvents<TEmittedSchemaMap>, AnyEventObject>, InferOutput<TMetaSchema, MetaObject>, // TMeta
 TSS, // TStateSchema
 TActionMap, TActorMap, TGuardMap, DelayMapFromNames<TDelays, TDelayMap>, InferInternalEvents<TInternalEventSchemaMap>> & {
     states: TSS;
@@ -79,7 +79,7 @@ export declare function createMachine<TContext extends MachineContext = never, c
 } & ValidateTopLevelFinalOutputs<TSS, WidenLiterals<TContext>, InferEvents<TEventSchemaMap> | InferInternalEvents<TInternalEventSchemaMap>>): StateMachine<WidenLiterals<TContext>, (InferEvents<TEventSchemaMap> | InferInternalEvents<TInternalEventSchemaMap>) | ([RoutableStateId<TSS>] extends [never] ? never : {
     type: 'xstate.route';
     to: RoutableStateId<TSS>;
-}), Cast<MergeChildren<InferChildren<TChildrenSchemaMap>, TActor>, Record<string, AnyActorRef | undefined>>, StateValueFromStateSchema<TSS>, TTag & string, TInput, InferOutput<TOutputSchema, unknown>, WithDefault<InferEvents<TEmittedSchemaMap>, AnyEventObject>, InferOutput<TMetaSchema, MetaObject>, // TMeta
+}), Cast<MergeChildren<InferChildren<TChildrenSchemaMap>, TActor>, Record<string, AnyActorRef | undefined>>, StateValueFromStateSchema<TSS>, TTag & string, TInput, SchemaOrConfigOutput<TOutputSchema, TSS>, WithDefault<InferEvents<TEmittedSchemaMap>, AnyEventObject>, InferOutput<TMetaSchema, MetaObject>, // TMeta
 TSS, // TStateSchema
 TActionMap, TActorMap, TGuardMap, DelayMapFromNames<TDelays, TDelayMap>, InferInternalEvents<TInternalEventSchemaMap>> & {
     states: TSS;

package/dist/declarations/src/durable/index.d.ts

@@ -1,6 +1,7 @@
 import { type EffectDescriptor } from "../effectDescriptor.js";
 import { type ActorSystemRuntime } from "../system.js";
-import type { AnyActor, AnyActorLogic, CustomExecutableActionObject, EventFromLogic, ExecutableActionObjectFromLogic, InputFrom, OutputFrom, SnapshotFrom } from "../types.js";
+import type { InspectionEvent } from "../inspection.js";
+import type { AnyActor, AnyActorLogic, AnyEventObject, CustomExecutableActionObject, EventFromLogic, ExecutableActionObjectFromLogic, InputFrom, OutputFrom, Snapshot, SnapshotFrom } from "../types.js";
 export interface DurableEffectMetadata {
     /** Stable within one durable execution. */
     id: string;
@@ -42,10 +43,11 @@ export interface DurableEffect<TEffect> extends DurableEffectMetadata {
  * operations keep their default local behavior.
  *
  * Events addressed to this execution's root actor do not reach `sendEvent`
- * during `executeEffects`: the execution captures them and resolves them
- * from that call for the durable loop to process before suspending. While
- * the loop is parked, a root-addressed event reaches `sendEvent` like any
- * other target, so the host enqueues it in its own mailbox.
+ * during `executeEffects`: the execution captures and retains them, and the
+ * execution's `waitForEvent()` hands them out before deferring to this
+ * adapter. While the loop is parked, a root-addressed event reaches
+ * `sendEvent` like any other target, so the host enqueues it in its own
+ * mailbox.
  */
 export interface DurableExecutionAdapter<TLogic extends AnyActorLogic> extends Partial<ActorSystemRuntime> {
     /**
@@ -62,8 +64,14 @@ export interface DurableExecutionAdapter<TLogic extends AnyActorLogic> extends P
      * source, input, event or target data beyond the runtime method arguments.
      */
     runtime?(metadata: DurableEffectMetadata, effect: ExecutableActionObjectFromLogic<TLogic>): Partial<ActorSystemRuntime>;
-    /** Waits durably for the next event addressed to this execution. */
-    waitForEvent(metadata: DurableWaitMetadata): EventFromLogic<TLogic> | PromiseLike<EventFromLogic<TLogic>>;
+    /**
+     * Waits durably for the next event addressed to this execution. Typed to
+     * also accept plain event objects: an adapter written against
+     * `AnyActorLogic` (a generic host library) cannot produce
+     * `EventFromLogic<TLogic>`, and the events a host relays are runtime data
+     * anyway — the execution narrows at its own boundary.
+     */
+    waitForEvent(metadata: DurableWaitMetadata): EventFromLogic<TLogic> | AnyEventObject | PromiseLike<EventFromLogic<TLogic> | AnyEventObject>;
     /** Index assigned to the first transition. Defaults to `0`. */
     transitionIndex?: number;
     /**
@@ -83,6 +91,13 @@ export declare class DurableExecutionCancelledError extends Error {
 export declare class DurableExecutionResumeError extends Error {
     constructor();
 }
+/**
+ * The snapshot type a durable execution hands back: the logic's own snapshot,
+ * intersected with the base `Snapshot` union so the `status`/`output`/`error`
+ * discriminant stays visible even when `TLogic` is an unresolved type
+ * parameter (a generic host library), where `SnapshotFrom` alone is opaque.
+ */
+export type DurableSnapshot<TLogic extends AnyActorLogic> = SnapshotFrom<TLogic> & Snapshot<OutputFrom<TLogic>>;
 export interface DurableExecution<TLogic extends AnyActorLogic> {
     /**
      * The logical address of this execution's root actor: the logic's own name,
@@ -101,11 +116,11 @@ export interface DurableExecution<TLogic extends AnyActorLogic> {
     /** Index assigned to the next transition. Persist this with checkpoints. */
     readonly nextTransitionIndex: number;
     initialTransition(...[input]: undefined extends InputFrom<TLogic> ? [input?: InputFrom<TLogic>] : [input: InputFrom<TLogic>]): [
-        snapshot: SnapshotFrom<TLogic>,
+        snapshot: DurableSnapshot<TLogic>,
         effects: DurableEffect<ExecutableActionObjectFromLogic<TLogic>>[]
     ];
     transition(snapshot: SnapshotFrom<TLogic>, event: EventFromLogic<TLogic>): [
-        snapshot: SnapshotFrom<TLogic>,
+        snapshot: DurableSnapshot<TLogic>,
         effects: DurableEffect<ExecutableActionObjectFromLogic<TLogic>>[]
     ];
     /**
@@ -113,8 +128,13 @@ export interface DurableExecution<TLogic extends AnyActorLogic> {
      * for addressing and inspection. `undefined` for snapshots this execution
      * has not seen (for example a freshly deserialized checkpoint that has not
      * been passed through `transition()` yet).
+     *
+     * With an `address`, returns the live actor at that logical address in the
+     * snapshot's actor tree instead — the root itself, one of its transitive
+     * children, or `undefined` when no live actor has that address (for
+     * example a timer firing for an actor that already completed).
      */
-    getActorRef(snapshot: SnapshotFrom<TLogic>): AnyActor | undefined;
+    getActorRef(snapshot: SnapshotFrom<TLogic>, address?: string): AnyActor | undefined;
     /**
      * Executes effects and resolves only when every runtime operation they
      * transitively initiated — including operations from live child actors
@@ -122,12 +142,18 @@ export interface DurableExecution<TLogic extends AnyActorLogic> {
      * failed operation rejects it. Operations are handed to the runtime one at
      * a time, in initiation order.
      *
-     * Resolves with the events addressed to this execution's root actor that
-     * were produced along the way, in order. Feed them back through
-     * `transition()` (and execute their effects) before durably waiting for an
-     * external event; `run()` does this automatically.
+     * Events addressed to this execution's root actor that were produced along
+     * the way are retained, in order, and handed out by `waitForEvent()`
+     * before it defers to the adapter — so the drive loop is just
+     * `transition(snapshot, await waitForEvent())` + `executeEffects`.
+     */
+    executeEffects(effects: readonly DurableEffect<ExecutableActionObjectFromLogic<TLogic>>[]): Promise<void>;
+    /**
+     * Resolves with the next event addressed to this execution's root actor:
+     * an event a prior `executeEffects` batch captured (an invoked actor
+     * completing, a child reporting up), or — once none are queued — whatever
+     * the adapter's durable wait produces.
      */
-    executeEffects(effects: readonly DurableEffect<ExecutableActionObjectFromLogic<TLogic>>[]): Promise<DurableRootEvent<EventFromLogic<TLogic>>[]>;
     waitForEvent(): Promise<EventFromLogic<TLogic>>;
     run(...[input]: undefined extends InputFrom<TLogic> ? [input?: InputFrom<TLogic>] : [input: InputFrom<TLogic>]): Promise<OutputFrom<TLogic>>;
 }
@@ -140,4 +166,13 @@ export interface DurableExecution<TLogic extends AnyActorLogic> {
  *
  * @experimental
  */
-export declare function createDurable<TLogic extends AnyActorLogic>(logic: TLogic, adapter: DurableExecutionAdapter<TLogic>): DurableExecution<TLogic>;
+export interface DurableExecutionOptions {
+    /**
+     * Observes the execution's inspection events — actor lifecycle, event
+     * routing, transitions — across the whole live actor tree. The host-side
+     * home for operation logs and instrumentation, so adapters stay pure
+     * physics.
+     */
+    inspect?: (inspectionEvent: InspectionEvent) => void;
+}
+export declare function createDurable<TLogic extends AnyActorLogic>(logic: TLogic, adapter: DurableExecutionAdapter<TLogic>, options?: DurableExecutionOptions): DurableExecution<TLogic>;

package/dist/declarations/src/inspectionAmbient.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/declarations/src/schema.types.d.ts

@@ -7,6 +7,8 @@ export interface StandardSchemaV1<Input = unknown, Output = Input> {
 export type SetupStateSchemas = {
     context?: StandardSchemaV1;
     input?: StandardSchemaV1;
+    /** The output emitted when this state node completes. */
+    output?: StandardSchemaV1;
 };
 /** A type-only Standard Schema produced by {@link types}. */
 export interface TypeSchema<T> extends StandardSchemaV1<T, T> {