xstate 6.0.0-alpha.33 → 6.0.0-alpha.34

package/dist/{StateMachine-ff580dd5.cjs.js → StateMachine-204661ea.cjs.js}

@@ -1,6 +1,6 @@
 'use strict';
 
-var dist_xstateActors = require('./index-9939f02a.cjs.js');
+var dist_xstateActors = require('./index-b440472d.cjs.js');
 
 function createSpawner(actorScope, actors, spawnedChildren) {
   return (src, options) => {
@@ -18,111 +18,6 @@ function createSpawner(actorScope, actors, spawnedChildren) {
   };
 }
 
-/** @internal */
-function setInertActorScopeSnapshot(actorScope, snapshot, attachActorRef = true) {
-  actorScope.self._snapshot = snapshot;
-  if (attachActorRef && snapshot && typeof snapshot === 'object') {
-    dist_xstateActors.setSnapshotActorRef(snapshot, actorScope.self);
-  }
-  return snapshot;
-}
-
-/** @internal */
-function isInertActorScope(actorScope) {
-  return !!actorScope.self.options?._inert;
-}
-
-/** @internal */
-function attachSnapshotActorRef(actorLogic, actorScope, snapshot) {
-  const snapshotScope = createInertActorScope(actorLogic, snapshot, actorScope.self);
-  return setInertActorScopeSnapshot(snapshotScope, snapshot);
-}
-
-/** @internal */
-function createInertActorScope(actorLogic, snapshot, sourceSelf) {
-  const snapshotRef = snapshot ? dist_xstateActors.getSnapshotActorRef(snapshot) : undefined;
-  const previousSelf = sourceSelf ?? snapshotRef?.actor;
-  const baseSystem = previousSelf?.system;
-  const system = previousSelf && baseSystem ? dist_xstateActors.createSnapshotSystem(baseSystem, dist_xstateActors.isMachineSnapshot(snapshot) ? snapshot.children : {}, sourceSelf ? undefined : snapshotRef?.systemState) : undefined;
-  const self = dist_xstateActors.createActor(actorLogic, {
-    _inert: true,
-    ...(previousSelf ? {
-      id: previousSelf.id,
-      _sessionId: previousSelf.sessionId
-    } : {}),
-    ...(system ? {
-      _systemRef: {
-        current: system
-      }
-    } : {})
-  });
-  if (previousSelf?._parent) {
-    self._parent = previousSelf._parent;
-  }
-  if (snapshot) {
-    self._snapshot = snapshot;
-  }
-  const actorScope = {
-    self: self,
-    defer: () => {},
-    id: self.id,
-    logger: self.system._logger,
-    sessionId: self.sessionId,
-    stopChild: child => child._stop(),
-    system: self.system,
-    emit: event => self.system.emitEvent(self, event),
-    actionExecutor: () => {}
-  };
-  return actorScope;
-}
-
-/** @deprecated Use `initialTransition(…)` instead. */
-function getInitialSnapshot(actorLogic, ...[input]) {
-  const actorScope = createInertActorScope(actorLogic);
-  return actorLogic.initialTransition(input, actorScope)[0];
-}
-
-/**
- * Determines the next snapshot for the given `actorLogic` based on the given
- * `snapshot` and `event`.
- *
- * If the `snapshot` is `undefined`, the initial snapshot of the `actorLogic` is
- * used.
- *
- * @deprecated Use `transition(…)` instead.
- * @example
- *
- * ```ts
- * import { getNextSnapshot } from 'xstate';
- * import { trafficLightMachine } from './trafficLightMachine.ts';
- *
- * const nextSnapshot = getNextSnapshot(
- *   trafficLightMachine, // actor logic
- *   undefined, // snapshot (or initial state if undefined)
- *   { type: 'TIMER' }
- * ); // event object
- *
- * console.log(nextSnapshot.value);
- * // => 'yellow'
- *
- * const nextSnapshot2 = getNextSnapshot(
- *   trafficLightMachine, // actor logic
- *   nextSnapshot, // snapshot
- *   { type: 'TIMER' }
- * ); // event object
- *
- * console.log(nextSnapshot2.value);
- * // =>'red'
- * ```
- */
-function getNextSnapshot(actorLogic, snapshot, event) {
-  const actorScope = createInertActorScope(actorLogic, snapshot);
-  const transitionResult = actorLogic.transition(snapshot, event, actorScope);
-  const nextSnapshot = Array.isArray(transitionResult) ? transitionResult[0] : transitionResult;
-  setInertActorScopeSnapshot(actorScope, nextSnapshot, false);
-  return nextSnapshot === snapshot ? nextSnapshot : attachSnapshotActorRef(actorLogic, actorScope, nextSnapshot);
-}
-
 const cache = new WeakMap();
 function memo(object, key, fn) {
   let memoizedData = cache.get(object);
@@ -305,7 +200,7 @@ class StateNode {
   }
 
   /** @internal */
-  next(snapshot, event, self, selectionResults) {
+  next(snapshot, event, actorScope, selectionResults) {
     const descriptorKey = dist_xstateActors.getEventDescriptorKey(event);
     let candidates = this._candidateCache?.get(descriptorKey);
     if (!candidates) {
@@ -313,7 +208,7 @@ class StateNode {
       (this._candidateCache ??= new Map()).set(descriptorKey, candidates);
     }
     for (const candidate of candidates) {
-      const guardPassed = dist_xstateActors.evaluateCandidate(candidate, event, snapshot, this, self, selectionResults);
+      const guardPassed = dist_xstateActors.evaluateCandidate(candidate, event, snapshot, this, actorScope, selectionResults);
       if (guardPassed) {
         return [candidate];
       }
@@ -657,7 +552,7 @@ class StateMachine {
    */
   transition(snapshot, event, actorScope) {
     const usesInertScope = !actorScope;
-    const resolvedActorScope = actorScope ?? createInertActorScope(this, snapshot);
+    const resolvedActorScope = actorScope ?? dist_xstateActors.createInertActorScope(this, snapshot);
     if (this.validator) {
       dist_xstateActors.assertValid(this.validator, {
         kind: 'event',
@@ -667,14 +562,14 @@ class StateMachine {
       });
     }
     if (usesInertScope) {
-      setInertActorScopeSnapshot(resolvedActorScope, snapshot, false);
+      dist_xstateActors.setInertActorScopeSnapshot(resolvedActorScope, snapshot, false);
     }
     const fastSnapshot = this._transitionFast(snapshot, event, resolvedActorScope);
     if (fastSnapshot) {
       if (usesInertScope) {
-        setInertActorScopeSnapshot(resolvedActorScope, fastSnapshot, false);
+        dist_xstateActors.setInertActorScopeSnapshot(resolvedActorScope, fastSnapshot, false);
       }
-      const returnedSnapshot = usesInertScope && fastSnapshot !== snapshot ? attachSnapshotActorRef(this, resolvedActorScope, fastSnapshot) : this._attachPureActorRef(fastSnapshot, resolvedActorScope);
+      const returnedSnapshot = usesInertScope && fastSnapshot !== snapshot ? dist_xstateActors.attachSnapshotActorRef(resolvedActorScope, fastSnapshot) : this._attachPureActorRef(fastSnapshot, resolvedActorScope);
       if (this.validator) {
         dist_xstateActors.assertValid(this.validator, {
           kind: 'result',
@@ -690,9 +585,9 @@ class StateMachine {
       microsteps
     } = dist_xstateActors.macrostep(snapshot, event, resolvedActorScope, []);
     if (usesInertScope) {
-      setInertActorScopeSnapshot(resolvedActorScope, nextSnapshot, false);
+      dist_xstateActors.setInertActorScopeSnapshot(resolvedActorScope, nextSnapshot, false);
     }
-    const returnedSnapshot = usesInertScope ? nextSnapshot === snapshot ? nextSnapshot : attachSnapshotActorRef(this, resolvedActorScope, nextSnapshot) : this._attachPureActorRef(nextSnapshot, resolvedActorScope);
+    const returnedSnapshot = usesInertScope ? nextSnapshot === snapshot ? nextSnapshot : dist_xstateActors.attachSnapshotActorRef(resolvedActorScope, nextSnapshot) : this._attachPureActorRef(nextSnapshot, resolvedActorScope);
     const effects = this._collectEffects(microsteps);
     if (this.validator) {
       dist_xstateActors.assertValid(this.validator, {
@@ -708,7 +603,7 @@ class StateMachine {
     return microsteps.flatMap(([, actions]) => actions);
   }
   _attachPureActorRef(snapshot, actorScope) {
-    if (isInertActorScope(actorScope)) {
+    if (dist_xstateActors.isInertActorScope(actorScope)) {
       return snapshot;
     }
     dist_xstateActors.setSnapshotActorRef(snapshot, actorScope.self, actorScope.system);
@@ -739,9 +634,11 @@ class StateMachine {
       ...snapshot.context,
       ...selected.context
     } : snapshot.context;
-    const collectedMicrosteps = actorScope.self._collectedMicrosteps || [];
-    collectedMicrosteps.push(selected);
-    actorScope.self._collectedMicrosteps = collectedMicrosteps;
+    if (!dist_xstateActors.isInertActorScope(actorScope) && (actorScope.system._hasInspectionObservers?.() ?? true)) {
+      const collectedMicrosteps = actorScope.self._collectedMicrosteps || [];
+      collectedMicrosteps.push(selected);
+      actorScope.self._collectedMicrosteps = collectedMicrosteps;
+    }
     return dist_xstateActors.cloneMachineSnapshot(snapshot, {
       ...(context !== snapshot.context ? {
         context
@@ -769,8 +666,8 @@ class StateMachine {
     }
     return snapshots;
   }
-  getTransitionData(snapshot, event, self, selectionResults) {
-    return dist_xstateActors.transitionNode(this.root, snapshot.value, snapshot, event, self, selectionResults) || [];
+  getTransitionData(snapshot, event, actorScope, selectionResults) {
+    return dist_xstateActors.transitionNode(this.root, snapshot.value, snapshot, event, actorScope, selectionResults) || [];
   }
   isInternalEventType(eventType) {
     if (eventType === dist_xstateActors.XSTATE_TIMER) {
@@ -792,9 +689,8 @@ class StateMachine {
    * @internal
    */
   _canTransition(snapshot, event) {
-    const emptyActor = getEmptyCanActor();
     const emptyActorScope = getEmptyCanActorScope();
-    const transitionData = this.getTransitionData(snapshot, event, emptyActor);
+    const transitionData = this.getTransitionData(snapshot, event, emptyActorScope);
     if (!transitionData?.length) {
       return false;
     }
@@ -807,7 +703,7 @@ class StateMachine {
       const res = dist_xstateActors.getTransitionResult(transition, snapshot, event, emptyActorScope, {
         resolveActions: false
       });
-      if (res.targets?.length || res.context || dist_xstateActors.hasEffect(transition, snapshot.context, event, snapshot, emptyActor)) {
+      if (res.targets?.length || res.context || dist_xstateActors.hasEffect(transition, snapshot.context, event, snapshot, emptyActorScope)) {
         return true;
       }
     }
@@ -846,12 +742,11 @@ class StateMachine {
     if (typeof context === 'function') {
       const children = {};
       const spawn = createSpawner(actorScope, this.sources.actors, children);
-      const resolvedContext = context({
+      const resolvedContext = context(dist_xstateActors.withActorSelf({
         spawn,
         input: initEvent.input,
-        self: actorScope.self,
         actors: this.sources.actors
-      });
+      }, actorScope));
       const [nextState] = dist_xstateActors.resolveActionsWithContext(preInitial, initEvent, actorScope, []);
       if (resolvedContext) {
         nextState.context = resolvedContext;
@@ -883,16 +778,16 @@ class StateMachine {
       });
     }
     const usesInertScope = !actorScope;
-    const resolvedActorScope = actorScope ?? createInertActorScope(this);
+    const resolvedActorScope = actorScope ?? dist_xstateActors.createInertActorScope(this);
     const initEvent = dist_xstateActors.createInitEvent(input); // TODO: fix;
     const internalQueue = [];
     const preInitialState = this._getPreInitialState(resolvedActorScope, initEvent);
     const contextSpawnEffects = Object.values(preInitialState.children).filter(Boolean).map(actor => dist_xstateActors.createSpawnEffect(actor));
     const finalizeInitialResult = (macroState, microsteps) => {
       if (usesInertScope) {
-        setInertActorScopeSnapshot(resolvedActorScope, macroState, false);
+        dist_xstateActors.setInertActorScopeSnapshot(resolvedActorScope, macroState, false);
       }
-      const returnedSnapshot = usesInertScope ? attachSnapshotActorRef(this, resolvedActorScope, macroState) : this._attachPureActorRef(macroState, resolvedActorScope);
+      const returnedSnapshot = usesInertScope ? dist_xstateActors.attachSnapshotActorRef(resolvedActorScope, macroState) : this._attachPureActorRef(macroState, resolvedActorScope);
       const effects = this._collectEffects(microsteps);
       if (this.validator) {
         dist_xstateActors.assertValid(this.validator, {
@@ -948,7 +843,7 @@ class StateMachine {
   }
   restoreSnapshot(snapshot, actorScope) {
     const usesInertScope = !actorScope;
-    const resolvedActorScope = actorScope ?? createInertActorScope(this);
+    const resolvedActorScope = actorScope ?? dist_xstateActors.createInertActorScope(this);
     const persistedMachine = snapshot.machine;
     const legacyPersistedVersion = snapshot.version;
     const persistedVersion = typeof persistedMachine?.version === 'string' ? persistedMachine.version : legacyPersistedVersion;
@@ -1072,8 +967,8 @@ class StateMachine {
     }
     reviveContext(restoredSnapshot.context);
     if (usesInertScope) {
-      setInertActorScopeSnapshot(resolvedActorScope, restoredSnapshot, false);
-      return attachSnapshotActorRef(this, resolvedActorScope, restoredSnapshot);
+      dist_xstateActors.setInertActorScopeSnapshot(resolvedActorScope, restoredSnapshot, false);
+      return dist_xstateActors.attachSnapshotActorRef(resolvedActorScope, restoredSnapshot);
     }
     return this._attachPureActorRef(restoredSnapshot, resolvedActorScope);
   }
@@ -1081,8 +976,3 @@ class StateMachine {
 
 exports.StateMachine = StateMachine;
 exports.StateNode = StateNode;
-exports.attachSnapshotActorRef = attachSnapshotActorRef;
-exports.createInertActorScope = createInertActorScope;
-exports.getInitialSnapshot = getInitialSnapshot;
-exports.getNextSnapshot = getNextSnapshot;
-exports.setInertActorScopeSnapshot = setInertActorScopeSnapshot;

package/dist/{StateMachine-d073209c.esm.js → StateMachine-269b22a3.esm.js}

@@ -1,4 +1,4 @@
-import { M as setSnapshotActorRef, N as getSnapshotActorRef, O as createSnapshotSystem, q as isMachineSnapshot, h as createActor, S as STATE_DELIMITER, P as mapValues, t as toArray, Q as createInvokeId, R as getDelayedTransitions, U as getEventDescriptorKey, V as getCandidates, W as evaluateCandidate, Y as formatTransition, Z as NULL_EVENT, _ as toTransitionConfigArray, $ as createInvokeTimeoutEventId, a0 as matchesActorSession, a1 as formatRouteTransitions, a2 as resolveStateValue, a3 as getAllStateNodes, s as getStateNodes, a4 as createMachineSnapshot, a5 as isInFinalState, a6 as assertValid, j as macrostep, a7 as cloneMachineSnapshot, a8 as transitionNode, e as XSTATE_TIMER, m as matchesEventDescriptor, a9 as getTransitionResult, aa as hasEffect, ab as createErrorPlatformEvent, r as resolveActionsWithContext, k as createInitEvent, l as createSpawnEffect, n as initialMicrostep, ac as toStatePath, ad as isStateId, ae as getStateNodeByPath, af as getPersistedSnapshot, ag as resolveReferencedActor, ah as createInvokeTimeoutEvent, ai as $$ACTOR_TYPE } from './index-ab93831d.esm.js';
+import { 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, B as getStateNodes, a8 as createMachineSnapshot, a9 as isInFinalState, k as createInertActorScope, aa as assertValid, s as setInertActorScopeSnapshot, l as attachSnapshotActorRef, n as macrostep, ab as isInertActorScope, ac as setSnapshotActorRef, ad as cloneMachineSnapshot, ae as transitionNode, e as XSTATE_TIMER, m as matchesEventDescriptor, af as getTransitionResult, ag as hasEffect, ah as createErrorPlatformEvent, ai as withActorSelf, r as resolveActionsWithContext, o as createInitEvent, q as createSpawnEffect, u as initialMicrostep, aj as toStatePath, ak as isStateId, al as getStateNodeByPath, am as getPersistedSnapshot, an as resolveReferencedActor, ao as createInvokeTimeoutEvent, ap as $$ACTOR_TYPE, j as createActor } from './index-16832816.esm.js';
 
 function createSpawner(actorScope, actors, spawnedChildren) {
   return (src, options) => {
@@ -16,111 +16,6 @@ function createSpawner(actorScope, actors, spawnedChildren) {
   };
 }
 
-/** @internal */
-function setInertActorScopeSnapshot(actorScope, snapshot, attachActorRef = true) {
-  actorScope.self._snapshot = snapshot;
-  if (attachActorRef && snapshot && typeof snapshot === 'object') {
-    setSnapshotActorRef(snapshot, actorScope.self);
-  }
-  return snapshot;
-}
-
-/** @internal */
-function isInertActorScope(actorScope) {
-  return !!actorScope.self.options?._inert;
-}
-
-/** @internal */
-function attachSnapshotActorRef(actorLogic, actorScope, snapshot) {
-  const snapshotScope = createInertActorScope(actorLogic, snapshot, actorScope.self);
-  return setInertActorScopeSnapshot(snapshotScope, snapshot);
-}
-
-/** @internal */
-function createInertActorScope(actorLogic, snapshot, sourceSelf) {
-  const snapshotRef = snapshot ? getSnapshotActorRef(snapshot) : undefined;
-  const previousSelf = sourceSelf ?? snapshotRef?.actor;
-  const baseSystem = previousSelf?.system;
-  const system = previousSelf && baseSystem ? createSnapshotSystem(baseSystem, isMachineSnapshot(snapshot) ? snapshot.children : {}, sourceSelf ? undefined : snapshotRef?.systemState) : undefined;
-  const self = createActor(actorLogic, {
-    _inert: true,
-    ...(previousSelf ? {
-      id: previousSelf.id,
-      _sessionId: previousSelf.sessionId
-    } : {}),
-    ...(system ? {
-      _systemRef: {
-        current: system
-      }
-    } : {})
-  });
-  if (previousSelf?._parent) {
-    self._parent = previousSelf._parent;
-  }
-  if (snapshot) {
-    self._snapshot = snapshot;
-  }
-  const actorScope = {
-    self: self,
-    defer: () => {},
-    id: self.id,
-    logger: self.system._logger,
-    sessionId: self.sessionId,
-    stopChild: child => child._stop(),
-    system: self.system,
-    emit: event => self.system.emitEvent(self, event),
-    actionExecutor: () => {}
-  };
-  return actorScope;
-}
-
-/** @deprecated Use `initialTransition(…)` instead. */
-function getInitialSnapshot(actorLogic, ...[input]) {
-  const actorScope = createInertActorScope(actorLogic);
-  return actorLogic.initialTransition(input, actorScope)[0];
-}
-
-/**
- * Determines the next snapshot for the given `actorLogic` based on the given
- * `snapshot` and `event`.
- *
- * If the `snapshot` is `undefined`, the initial snapshot of the `actorLogic` is
- * used.
- *
- * @deprecated Use `transition(…)` instead.
- * @example
- *
- * ```ts
- * import { getNextSnapshot } from 'xstate';
- * import { trafficLightMachine } from './trafficLightMachine.ts';
- *
- * const nextSnapshot = getNextSnapshot(
- *   trafficLightMachine, // actor logic
- *   undefined, // snapshot (or initial state if undefined)
- *   { type: 'TIMER' }
- * ); // event object
- *
- * console.log(nextSnapshot.value);
- * // => 'yellow'
- *
- * const nextSnapshot2 = getNextSnapshot(
- *   trafficLightMachine, // actor logic
- *   nextSnapshot, // snapshot
- *   { type: 'TIMER' }
- * ); // event object
- *
- * console.log(nextSnapshot2.value);
- * // =>'red'
- * ```
- */
-function getNextSnapshot(actorLogic, snapshot, event) {
-  const actorScope = createInertActorScope(actorLogic, snapshot);
-  const transitionResult = actorLogic.transition(snapshot, event, actorScope);
-  const nextSnapshot = Array.isArray(transitionResult) ? transitionResult[0] : transitionResult;
-  setInertActorScopeSnapshot(actorScope, nextSnapshot, false);
-  return nextSnapshot === snapshot ? nextSnapshot : attachSnapshotActorRef(actorLogic, actorScope, nextSnapshot);
-}
-
 const cache = new WeakMap();
 function memo(object, key, fn) {
   let memoizedData = cache.get(object);
@@ -303,7 +198,7 @@ class StateNode {
   }
 
   /** @internal */
-  next(snapshot, event, self, selectionResults) {
+  next(snapshot, event, actorScope, selectionResults) {
     const descriptorKey = getEventDescriptorKey(event);
     let candidates = this._candidateCache?.get(descriptorKey);
     if (!candidates) {
@@ -311,7 +206,7 @@ class StateNode {
       (this._candidateCache ??= new Map()).set(descriptorKey, candidates);
     }
     for (const candidate of candidates) {
-      const guardPassed = evaluateCandidate(candidate, event, snapshot, this, self, selectionResults);
+      const guardPassed = evaluateCandidate(candidate, event, snapshot, this, actorScope, selectionResults);
       if (guardPassed) {
         return [candidate];
       }
@@ -672,7 +567,7 @@ class StateMachine {
       if (usesInertScope) {
         setInertActorScopeSnapshot(resolvedActorScope, fastSnapshot, false);
       }
-      const returnedSnapshot = usesInertScope && fastSnapshot !== snapshot ? attachSnapshotActorRef(this, resolvedActorScope, fastSnapshot) : this._attachPureActorRef(fastSnapshot, resolvedActorScope);
+      const returnedSnapshot = usesInertScope && fastSnapshot !== snapshot ? attachSnapshotActorRef(resolvedActorScope, fastSnapshot) : this._attachPureActorRef(fastSnapshot, resolvedActorScope);
       if (this.validator) {
         assertValid(this.validator, {
           kind: 'result',
@@ -690,7 +585,7 @@ class StateMachine {
     if (usesInertScope) {
       setInertActorScopeSnapshot(resolvedActorScope, nextSnapshot, false);
     }
-    const returnedSnapshot = usesInertScope ? nextSnapshot === snapshot ? nextSnapshot : attachSnapshotActorRef(this, resolvedActorScope, nextSnapshot) : this._attachPureActorRef(nextSnapshot, resolvedActorScope);
+    const returnedSnapshot = usesInertScope ? nextSnapshot === snapshot ? nextSnapshot : attachSnapshotActorRef(resolvedActorScope, nextSnapshot) : this._attachPureActorRef(nextSnapshot, resolvedActorScope);
     const effects = this._collectEffects(microsteps);
     if (this.validator) {
       assertValid(this.validator, {
@@ -737,9 +632,11 @@ class StateMachine {
       ...snapshot.context,
       ...selected.context
     } : snapshot.context;
-    const collectedMicrosteps = actorScope.self._collectedMicrosteps || [];
-    collectedMicrosteps.push(selected);
-    actorScope.self._collectedMicrosteps = collectedMicrosteps;
+    if (!isInertActorScope(actorScope) && (actorScope.system._hasInspectionObservers?.() ?? true)) {
+      const collectedMicrosteps = actorScope.self._collectedMicrosteps || [];
+      collectedMicrosteps.push(selected);
+      actorScope.self._collectedMicrosteps = collectedMicrosteps;
+    }
     return cloneMachineSnapshot(snapshot, {
       ...(context !== snapshot.context ? {
         context
@@ -767,8 +664,8 @@ class StateMachine {
     }
     return snapshots;
   }
-  getTransitionData(snapshot, event, self, selectionResults) {
-    return transitionNode(this.root, snapshot.value, snapshot, event, self, selectionResults) || [];
+  getTransitionData(snapshot, event, actorScope, selectionResults) {
+    return transitionNode(this.root, snapshot.value, snapshot, event, actorScope, selectionResults) || [];
   }
   isInternalEventType(eventType) {
     if (eventType === XSTATE_TIMER) {
@@ -790,9 +687,8 @@ class StateMachine {
    * @internal
    */
   _canTransition(snapshot, event) {
-    const emptyActor = getEmptyCanActor();
     const emptyActorScope = getEmptyCanActorScope();
-    const transitionData = this.getTransitionData(snapshot, event, emptyActor);
+    const transitionData = this.getTransitionData(snapshot, event, emptyActorScope);
     if (!transitionData?.length) {
       return false;
     }
@@ -805,7 +701,7 @@ class StateMachine {
       const res = getTransitionResult(transition, snapshot, event, emptyActorScope, {
         resolveActions: false
       });
-      if (res.targets?.length || res.context || hasEffect(transition, snapshot.context, event, snapshot, emptyActor)) {
+      if (res.targets?.length || res.context || hasEffect(transition, snapshot.context, event, snapshot, emptyActorScope)) {
         return true;
       }
     }
@@ -844,12 +740,11 @@ class StateMachine {
     if (typeof context === 'function') {
       const children = {};
       const spawn = createSpawner(actorScope, this.sources.actors, children);
-      const resolvedContext = context({
+      const resolvedContext = context(withActorSelf({
         spawn,
         input: initEvent.input,
-        self: actorScope.self,
         actors: this.sources.actors
-      });
+      }, actorScope));
       const [nextState] = resolveActionsWithContext(preInitial, initEvent, actorScope, []);
       if (resolvedContext) {
         nextState.context = resolvedContext;
@@ -890,7 +785,7 @@ class StateMachine {
       if (usesInertScope) {
         setInertActorScopeSnapshot(resolvedActorScope, macroState, false);
       }
-      const returnedSnapshot = usesInertScope ? attachSnapshotActorRef(this, resolvedActorScope, macroState) : this._attachPureActorRef(macroState, resolvedActorScope);
+      const returnedSnapshot = usesInertScope ? attachSnapshotActorRef(resolvedActorScope, macroState) : this._attachPureActorRef(macroState, resolvedActorScope);
       const effects = this._collectEffects(microsteps);
       if (this.validator) {
         assertValid(this.validator, {
@@ -1071,10 +966,10 @@ class StateMachine {
     reviveContext(restoredSnapshot.context);
     if (usesInertScope) {
       setInertActorScopeSnapshot(resolvedActorScope, restoredSnapshot, false);
-      return attachSnapshotActorRef(this, resolvedActorScope, restoredSnapshot);
+      return attachSnapshotActorRef(resolvedActorScope, restoredSnapshot);
     }
     return this._attachPureActorRef(restoredSnapshot, resolvedActorScope);
   }
 }
 
-export { StateMachine as S, attachSnapshotActorRef as a, getNextSnapshot as b, createInertActorScope as c, StateNode as d, getInitialSnapshot as g, setInertActorScopeSnapshot as s };
+export { StateMachine as S, StateNode as a };