xstate 6.0.0-alpha.44 → 6.0.0-alpha.46

package/dist/{StateMachine-fcc48e11.cjs.js → StateMachine-756e1335.cjs.js}

@@ -1,11 +1,11 @@
 'use strict';
 
-var createActor = require('./createActor-9538c7f8.cjs.js');
-var dist_xstateActors = require('./index-ba7170ba.cjs.js');
+var createActor = require('./createActor-0816a84b.cjs.js');
+var dist_xstateActors = require('./index-7b9c4f77.cjs.js');
 
 function createSpawner(actorScope, actors, spawnedChildren) {
   return (src, options) => {
-    const referencedSrc = Object.entries(actors).find(([, logic]) => logic === src)?.[0];
+    const referencedSrc = createActor.resolveRegisteredActorSource(actors, src);
     // Generated ids come from the same transaction allocator as `enq.spawn`,
     // so context-factory allocations persist with the snapshot and never
     // collide with later spawns.

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

@@ -1,9 +1,9 @@
-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 resolveRegisteredActorSource, R as allocateChildId, S as assertChildIdFree, T as reserveChildId, U as STATE_DELIMITER, V as mapValues, t as toArray, W as createInvokeId, Y as getDelayedTransitions, Z as getEventDescriptorKey, _ as getCandidates, $ as evaluateCandidate, a0 as formatTransition, a1 as NULL_EVENT, a2 as toTransitionConfigArray, a3 as createInvokeTimeoutEventId, a4 as matchesActorSession, a5 as formatRouteTransitions, a6 as resolveStateValue, a7 as getAllStateNodes, x as getStateNodes, a8 as createMachineSnapshot, a9 as isInFinalState, aa as createInertActorScope, ab as setInertActorScopeSnapshot, a as beginSpawnAllocation, ac as attachSnapshotActorRef, ad as macrostep, ae as isInertActorScope, af as setSnapshotActorRef, ag as cloneMachineSnapshot, ah as transitionNode, g as XSTATE_TIMER, m as matchesEventDescriptor, ai as getTransitionResult, aj as hasEffect, ak as createErrorPlatformEvent, al as withActorSelf, r as resolveActionsWithContext, am as takeSpawnAllocationCounters, an as mergeActorIdCounters, K as createInitEvent, ao as createSpawnEffect, ap as initialMicrostep, aq as toStatePath, ar as isStateId, as as getStateNodeByPath, at as getPersistedSnapshot, au as createRemoteActorRef, av as resolveReferencedActor, aw as createInvokeTimeoutEvent, ax as parseGeneratedActorId, ay as ACTOR_REF_TYPE, k as createActor } from './createActor-9523f716.esm.js';
+import { g as assertValid } from './index-c7431a16.esm.js';
 
 function createSpawner(actorScope, actors, spawnedChildren) {
   return (src, options) => {
-    const referencedSrc = Object.entries(actors).find(([, logic]) => logic === src)?.[0];
+    const referencedSrc = resolveRegisteredActorSource(actors, src);
     // Generated ids come from the same transaction allocator as `enq.spawn`,
     // so context-factory allocations persist with the snapshot and never
     // collide with later spawns.

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

@@ -1,9 +1,9 @@
-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 resolveRegisteredActorSource, R as allocateChildId, S as assertChildIdFree, T as reserveChildId, U as STATE_DELIMITER, V as mapValues, t as toArray, W as createInvokeId, Y as getDelayedTransitions, Z as getEventDescriptorKey, _ as getCandidates, $ as evaluateCandidate, a0 as formatTransition, a1 as NULL_EVENT, a2 as toTransitionConfigArray, a3 as createInvokeTimeoutEventId, a4 as matchesActorSession, a5 as formatRouteTransitions, a6 as resolveStateValue, a7 as getAllStateNodes, x as getStateNodes, a8 as createMachineSnapshot, a9 as isInFinalState, aa as createInertActorScope, ab as setInertActorScopeSnapshot, a as beginSpawnAllocation, ac as attachSnapshotActorRef, ad as macrostep, ae as isInertActorScope, af as setSnapshotActorRef, ag as cloneMachineSnapshot, ah as transitionNode, g as XSTATE_TIMER, m as matchesEventDescriptor, ai as getTransitionResult, aj as hasEffect, ak as createErrorPlatformEvent, al as withActorSelf, r as resolveActionsWithContext, am as takeSpawnAllocationCounters, an as mergeActorIdCounters, K as createInitEvent, ao as createSpawnEffect, ap as initialMicrostep, aq as toStatePath, ar as isStateId, as as getStateNodeByPath, at as getPersistedSnapshot, au as createRemoteActorRef, av as resolveReferencedActor, aw as createInvokeTimeoutEvent, ax as parseGeneratedActorId, ay as ACTOR_REF_TYPE, k as createActor } from './createActor-f5277b31.development.esm.js';
+import { g as assertValid } from './index-3907b7aa.development.esm.js';
 
 function createSpawner(actorScope, actors, spawnedChildren) {
   return (src, options) => {
-    const referencedSrc = Object.entries(actors).find(([, logic]) => logic === src)?.[0];
+    const referencedSrc = resolveRegisteredActorSource(actors, src);
     // Generated ids come from the same transaction allocator as `enq.spawn`,
     // so context-factory allocations persist with the snapshot and never
     // collide with later spawns.

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

@@ -1,11 +1,11 @@
 'use strict';
 
-var createActor = require('./createActor-1a3a1d14.development.cjs.js');
-var dist_xstateActors = require('./index-e0ba4813.development.cjs.js');
+var createActor = require('./createActor-f6e6146f.development.cjs.js');
+var dist_xstateActors = require('./index-1e1e1cba.development.cjs.js');
 
 function createSpawner(actorScope, actors, spawnedChildren) {
   return (src, options) => {
-    const referencedSrc = Object.entries(actors).find(([, logic]) => logic === src)?.[0];
+    const referencedSrc = createActor.resolveRegisteredActorSource(actors, src);
     // Generated ids come from the same transaction allocator as `enq.spawn`,
     // so context-factory allocations persist with the snapshot and never
     // collide with later spawns.

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

@@ -219,6 +219,27 @@ const builtInActions = {
   }
 };
 
+const sourceKeyCaches = new WeakMap();
+
+/** @internal */
+function resolveRegisteredActorSource(actors, logic) {
+  let cache = sourceKeyCaches.get(actors);
+  if (!cache) {
+    cache = new Map();
+    for (const key of Object.keys(actors)) {
+      const registeredLogic = actors[key];
+      // Several source keys may intentionally share one implementation. The
+      // first key is its canonical persistence identity when spawning by the
+      // raw logic value, which cannot retain which alias was used to access it.
+      if (!cache.has(registeredLogic)) {
+        cache.set(registeredLogic, key);
+      }
+    }
+    sourceKeyCaches.set(actors, cache);
+  }
+  return cache.get(logic);
+}
+
 const subscriptions = /* #__PURE__ */new WeakMap();
 
 /**
@@ -666,21 +687,31 @@ function beginSpawnAllocation(actorScope) {
 function getWorkingSnapshotOf(actorScope) {
   return actorScope.self._snapshot;
 }
-const srcKeyCaches = new WeakMap();
-function getRegisteredSrcKey(actorScope, logic) {
-  const registeredActors = actorScope.self.logic?.sources?.actors;
-  if (!registeredActors) {
-    return undefined;
-  }
-  let cache = srcKeyCaches.get(registeredActors);
-  if (!cache) {
-    cache = new Map();
-    for (const key of Object.keys(registeredActors)) {
-      cache.set(registeredActors[key], key);
+function getRegisteredActors(actorScope) {
+  return actorScope.self.logic?.sources?.actors;
+}
+function resolveTransitionSpawnSource(actorScope, source) {
+  const registeredActors = getRegisteredActors(actorScope);
+  if (typeof source === 'string') {
+    const logic = registeredActors?.[source];
+    if (!logic) {
+      throw new Error(`Actor source '${source}' is not provided`);
     }
-    srcKeyCaches.set(registeredActors, cache);
+    return {
+      logic,
+      src: source
+    };
   }
-  return cache.get(logic);
+  if (!registeredActors) {
+    return {
+      logic: source,
+      src: undefined
+    };
+  }
+  return {
+    logic: source,
+    src: resolveRegisteredActorSource(registeredActors, source)
+  };
 }
 
 /**
@@ -821,17 +852,17 @@ function createTransitionEnqueue(actorScope, actions, internalEvents, actorSubsc
         internalEvents.push(raisedEvent);
       }
     },
-    spawn: (logic, options) => {
+    spawn: (source, options) => {
+      const {
+        logic,
+        src
+      } = resolveTransitionSpawnSource(actorScope, source);
       if (!createActors) {
         // TODO: replace this speculative placeholder with a typed inert actor ref.
         return {
-          id: options?.id ?? options?.registryKey ?? logic.id
+          id: options?.id ?? options?.registryKey ?? src ?? logic.id
         };
       }
-      // Recover the registered source key for setup-provided logic so the
-      // spawned child persists (and gets a deterministic id prefix) by key
-      // instead of by inline logic reference.
-      const src = getRegisteredSrcKey(actorScope, logic);
       // Generated ids allocate from the parent snapshot's own counters
       // through the transition's allocation transaction; explicit
       // generated-shaped ids reserve their numbering the same way.
@@ -1266,6 +1297,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 +1398,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 +1437,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) {
@@ -3656,6 +3730,9 @@ function getPersistedSnapshot(snapshot, options) {
   const embedChildren = options?.embedChildren !== false;
   for (const id in children) {
     const child = children[id];
+    if (typeof child.src !== 'string' && (!options || !('__unsafeAllowInlineActors' in options))) {
+      throw new Error('An inline child actor cannot be persisted.');
+    }
     // Children are referenced by their logical address. Embedding the child
     // state is the co-locating runtime's whole-tree checkpoint capability;
     // remote handles never embed — their state lives with another runtime.
@@ -4372,6 +4449,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 +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({
@@ -5672,6 +5756,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;
@@ -5696,6 +5781,7 @@ exports.pathToStateValue = pathToStateValue;
 exports.reserveChildId = reserveChildId;
 exports.resolveActionsWithContext = resolveActionsWithContext;
 exports.resolveReferencedActor = resolveReferencedActor;
+exports.resolveRegisteredActorSource = resolveRegisteredActorSource;
 exports.resolveStateValue = resolveStateValue;
 exports.runStep = runStep;
 exports.setInertActorScopeSnapshot = setInertActorScopeSnapshot;
@@ -5712,3 +5798,4 @@ exports.transitionNode = transitionNode;
 exports.withActorScope = withActorScope;
 exports.withActorSelf = withActorSelf;
 exports.withExecutionIdentity = withExecutionIdentity;
+exports.withSystemInspector = withSystemInspector;

package/dist/{createActor-973c72ad.esm.js → createActor-9523f716.esm.js}

@@ -217,6 +217,27 @@ const builtInActions = {
   }
 };
 
+const sourceKeyCaches = new WeakMap();
+
+/** @internal */
+function resolveRegisteredActorSource(actors, logic) {
+  let cache = sourceKeyCaches.get(actors);
+  if (!cache) {
+    cache = new Map();
+    for (const key of Object.keys(actors)) {
+      const registeredLogic = actors[key];
+      // Several source keys may intentionally share one implementation. The
+      // first key is its canonical persistence identity when spawning by the
+      // raw logic value, which cannot retain which alias was used to access it.
+      if (!cache.has(registeredLogic)) {
+        cache.set(registeredLogic, key);
+      }
+    }
+    sourceKeyCaches.set(actors, cache);
+  }
+  return cache.get(logic);
+}
+
 const subscriptions = /* #__PURE__ */new WeakMap();
 
 /**
@@ -664,21 +685,31 @@ function beginSpawnAllocation(actorScope) {
 function getWorkingSnapshotOf(actorScope) {
   return actorScope.self._snapshot;
 }
-const srcKeyCaches = new WeakMap();
-function getRegisteredSrcKey(actorScope, logic) {
-  const registeredActors = actorScope.self.logic?.sources?.actors;
-  if (!registeredActors) {
-    return undefined;
-  }
-  let cache = srcKeyCaches.get(registeredActors);
-  if (!cache) {
-    cache = new Map();
-    for (const key of Object.keys(registeredActors)) {
-      cache.set(registeredActors[key], key);
+function getRegisteredActors(actorScope) {
+  return actorScope.self.logic?.sources?.actors;
+}
+function resolveTransitionSpawnSource(actorScope, source) {
+  const registeredActors = getRegisteredActors(actorScope);
+  if (typeof source === 'string') {
+    const logic = registeredActors?.[source];
+    if (!logic) {
+      throw new Error(`Actor source '${source}' is not provided`);
     }
-    srcKeyCaches.set(registeredActors, cache);
+    return {
+      logic,
+      src: source
+    };
   }
-  return cache.get(logic);
+  if (!registeredActors) {
+    return {
+      logic: source,
+      src: undefined
+    };
+  }
+  return {
+    logic: source,
+    src: resolveRegisteredActorSource(registeredActors, source)
+  };
 }
 
 /**
@@ -819,17 +850,17 @@ function createTransitionEnqueue(actorScope, actions, internalEvents, actorSubsc
         internalEvents.push(raisedEvent);
       }
     },
-    spawn: (logic, options) => {
+    spawn: (source, options) => {
+      const {
+        logic,
+        src
+      } = resolveTransitionSpawnSource(actorScope, source);
       if (!createActors) {
         // TODO: replace this speculative placeholder with a typed inert actor ref.
         return {
-          id: options?.id ?? options?.registryKey ?? logic.id
+          id: options?.id ?? options?.registryKey ?? src ?? logic.id
         };
       }
-      // Recover the registered source key for setup-provided logic so the
-      // spawned child persists (and gets a deterministic id prefix) by key
-      // instead of by inline logic reference.
-      const src = getRegisteredSrcKey(actorScope, logic);
       // Generated ids allocate from the parent snapshot's own counters
       // through the transition's allocation transaction; explicit
       // generated-shaped ids reserve their numbering the same way.
@@ -1264,6 +1295,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 +1396,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 +1435,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) {
@@ -3654,6 +3728,9 @@ function getPersistedSnapshot(snapshot, options) {
   const embedChildren = options?.embedChildren !== false;
   for (const id in children) {
     const child = children[id];
+    if (typeof child.src !== 'string' && (!options || !('__unsafeAllowInlineActors' in options))) {
+      throw new Error('An inline child actor cannot be persisted.');
+    }
     // Children are referenced by their logical address. Embedding the child
     // state is the co-locating runtime's whole-tree checkpoint capability;
     // remote handles never embed — their state lives with another runtime.
@@ -4370,6 +4447,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 +5151,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 +5696,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 { evaluateCandidate 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, resolveRegisteredActorSource as Q, allocateChildId as R, assertChildIdFree as S, reserveChildId as T, STATE_DELIMITER as U, mapValues as V, createInvokeId as W, XSTATE_INIT as X, getDelayedTransitions as Y, getEventDescriptorKey as Z, getCandidates as _, beginSpawnAllocation as a, formatTransition as a0, NULL_EVENT as a1, toTransitionConfigArray as a2, createInvokeTimeoutEventId as a3, matchesActorSession as a4, formatRouteTransitions as a5, resolveStateValue as a6, getAllStateNodes as a7, createMachineSnapshot as a8, isInFinalState as a9, getProperAncestors as aA, isRemoteActorRef as aB, getActorIdPrefix as aC, getAllOwnEvents as aD, matchesEvent as aE, encodeAddressSegment as aF, getRootActorId as aG, RUNTIME_OPERATIONS as aH, withSystemInspector as aI, getSnapshotActorRef as aJ, withExecutionIdentity as aK, createInertActorScope as aa, setInertActorScopeSnapshot as ab, attachSnapshotActorRef as ac, macrostep as ad, isInertActorScope as ae, setSnapshotActorRef as af, cloneMachineSnapshot as ag, transitionNode as ah, getTransitionResult as ai, hasEffect as aj, createErrorPlatformEvent as ak, withActorSelf as al, takeSpawnAllocationCounters as am, mergeActorIdCounters as an, createSpawnEffect as ao, initialMicrostep as ap, toStatePath as aq, isStateId as ar, getStateNodeByPath as as, getPersistedSnapshot as at, createRemoteActorRef as au, resolveReferencedActor as av, createInvokeTimeoutEvent as aw, parseGeneratedActorId as ax, ACTOR_REF_TYPE as ay, hasAmbientInspector 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 };