xstate 6.0.0-alpha.58 → 6.0.0-alpha.59

package/dist/{createActor-3dc6cdb7.development.esm.js → createActor-224ece29.development.esm.js}

@@ -2669,6 +2669,7 @@ function computeExitSet(transitions, stateNodeSet, snapshot, resolveTransition)
   return [...statesToExit];
 }
 function initialMicrostep(root, preInitialState, actorScope, initEvent, internalQueue) {
+  root.machine._microstepHooks?.begin(actorScope.self);
   const initialStateNodes = [...getInitialStateNodes(root)];
   const statesForDefaultEntry = new Set();
   const collectDefaultEntryStates = stateNode => {
@@ -2697,6 +2698,10 @@ function initialMicrostep(root, preInitialState, actorScope, initEvent, internal
 /** https://www.w3.org/TR/scxml/#microstepProcedure */
 function microstep(transitions, currentSnapshot, actorScope, event, isInitial, internalQueue, selectionResults) {
   const executableActions = [];
+  const internalEvents = currentSnapshot.machine._microstepHooks?.drain(actorScope.self);
+  if (internalEvents?.length) {
+    internalQueue.push(...internalEvents);
+  }
   if (!transitions.length) {
     return [currentSnapshot, executableActions];
   }
@@ -3411,6 +3416,11 @@ function macrostep(snapshot, event, actorScope, internalQueue, initialMicrosteps
     // eventless transitions should always be selected after selecting *regular* transitions
     // by assigning `undefined` to `previousState` we ensure that `shouldSelectEventlessTransitions` gets always computed to true in such a case
     const previousState = enabledTransitions.length ? nextSnapshot : undefined;
+    // Failed eventless guards can raise events even when no transition wins.
+    const raisedEvents = nextSnapshot.machine._microstepHooks?.drain(actorScope.self);
+    if (raisedEvents?.length) {
+      internalQueue.push(...raisedEvents);
+    }
     if (!enabledTransitions.length) {
       if (!internalQueue.length) {
         break;
@@ -3525,6 +3535,7 @@ function cancelTimers(snapshot, event, actorScope) {
   return resolveActionsWithContext(snapshot, event, actorScope, actions);
 }
 function selectEventlessTransitions(snapshot, event, actorScope) {
+  snapshot.machine._microstepHooks?.begin(actorScope.self);
   const enabledTransitionSet = new Set();
   const atomicStates = snapshot.nodes.filter(isAtomicStateNode);
   for (const atomicStateNode of atomicStates) {
@@ -4066,7 +4077,17 @@ function mapValues(collection, iteratee) {
   const collectionKeys = Object.keys(collection);
   for (let i = 0; i < collectionKeys.length; i++) {
     const key = collectionKeys[i];
-    result[key] = iteratee(collection[key], key, collection, i);
+    const value = iteratee(collection[key], key, collection, i);
+    if (key === '__proto__') {
+      Object.defineProperty(result, key, {
+        value,
+        enumerable: true,
+        configurable: true,
+        writable: true
+      });
+    } else {
+      result[key] = value;
+    }
   }
   return result;
 }
@@ -4233,23 +4254,14 @@ function matchesEventDescriptor(eventType, descriptor) {
 }
 
 function getStepEffect(actor, key) {
-  return actor.getSnapshot().effects?.[key];
-}
-function waitForStep(actor, key) {
-  return new Promise((resolve, reject) => {
-    const subscription = actor.subscribe(snapshot => {
-      const effect = snapshot.effects?.[key];
-      if (effect?.status === 'done') {
-        subscription.unsubscribe();
-        resolve(effect.output);
-      } else if (effect?.status === 'error') {
-        subscription.unsubscribe();
-        reject(effect.error);
-      }
-    });
-  });
+  const effects = actor.getSnapshot().effects;
+  return effects && Object.prototype.hasOwnProperty.call(effects, key) ? effects[key] : undefined;
 }
 
+// Live promises belong to an actor incarnation, unlike its persisted journal.
+// A restored active record has no promise here and must be retried locally.
+const pendingSteps = new WeakMap();
+
 /**
  * Runs one keyed step of an async actor with the built-in journal: the
  * result is memoized in the actor's own snapshot (`effects[key]`), so a
@@ -4267,29 +4279,66 @@ async function runStep(actor, key, exec, sendSelf = event => void actor.system.s
   if (effect?.status === 'error') {
     throw effect.error;
   }
-  if (effect?.status === 'active') {
-    return waitForStep(actor, key);
+  const running = pendingSteps.get(actor)?.get(key);
+  if (running) {
+    return running;
   }
-  sendSelf({
-    type: XSTATE_LOGIC_EFFECT_START,
-    key
-  });
-  try {
-    const output = await exec();
-    sendSelf({
-      type: XSTATE_LOGIC_EFFECT_RESOLVE,
-      key,
-      output
-    });
-    return output;
-  } catch (error) {
-    sendSelf({
-      type: XSTATE_LOGIC_EFFECT_REJECT,
-      key,
-      error
-    });
-    throw error;
+  if (actor.getSnapshot().status !== 'active') {
+    throw new Error(`Actor terminated before step "${key}" completed`);
   }
+  let resolve;
+  let reject;
+  const promise = new Promise((resolvePromise, rejectPromise) => {
+    resolve = resolvePromise;
+    reject = rejectPromise;
+  });
+  let steps = pendingSteps.get(actor);
+  if (!steps) {
+    steps = new Map();
+    pendingSteps.set(actor, steps);
+  }
+  steps.set(key, promise);
+  // oxlint-disable-next-line prefer-const
+  let subscription;
+  const cleanup = () => {
+    subscription?.unsubscribe();
+    steps.delete(key);
+    if (!steps.size) {
+      pendingSteps.delete(actor);
+    }
+  };
+  void promise.then(cleanup, cleanup);
+  subscription = actor.subscribe({
+    error: reject,
+    complete: () => reject(new Error(`Actor terminated before step "${key}" completed`))
+  });
+  void (async () => {
+    try {
+      sendSelf({
+        type: XSTATE_LOGIC_EFFECT_START,
+        key
+      });
+      const output = await exec();
+      if (actor.getSnapshot().status === 'active') {
+        sendSelf({
+          type: XSTATE_LOGIC_EFFECT_RESOLVE,
+          key,
+          output
+        });
+        resolve(output);
+      }
+    } catch (error) {
+      if (actor.getSnapshot().status === 'active') {
+        sendSelf({
+          type: XSTATE_LOGIC_EFFECT_REJECT,
+          key,
+          error
+        });
+      }
+      reject(error);
+    }
+  })().catch(reject);
+  return promise;
 }
 
 /**
@@ -4931,6 +4980,8 @@ class RuntimeSystem {
     }
   }
 }
+
+/** @internal */
 function createRuntimeSystem(rootActor, options) {
   return new RuntimeSystem(rootActor, options);
 }
@@ -5283,12 +5334,12 @@ class Actor {
   }
 
   /** Recover via the logic's error event if possible; otherwise error out. */
-  _recoverOrError(err, snapshot) {
+  _recoverOrError(err, snapshot, previousSnapshot) {
     if (this._tryHandleExecutionError(err, snapshot)) {
       return true;
     }
     this._setErrorSnapshot(err);
-    this._error(err);
+    this._error(err, previousSnapshot);
     return false;
   }
   _tryHandleExecutionError(err, snapshot = this._snapshot) {
@@ -5621,6 +5672,7 @@ class Actor {
     return this;
   }
   _process(event) {
+    const previousSnapshot = this._snapshot;
     let nextState;
     let caughtError;
     try {
@@ -5651,7 +5703,7 @@ class Actor {
       executeExecutableEffects(effects, this._actorScope);
       this.update(snapshot, event);
     } catch (err) {
-      if (!this._recoverOrError(err, snapshot)) {
+      if (!this._recoverOrError(err, snapshot, previousSnapshot)) {
         this._inspectTransition(this._snapshot, event);
       }
       return;
@@ -5737,8 +5789,39 @@ class Actor {
       }
     });
   }
-  _error(err) {
+  _error(err, previousSnapshot) {
     this._stopProcedure();
+    // Transition calculation or effect execution may fail before child stop
+    // effects run. Keep the previous snapshot's children when calculation has
+    // already removed them, and include children owned by non-machine logic
+    // from the runtime registry.
+    const children = new Set();
+    for (const snapshot of [this._snapshot, previousSnapshot]) {
+      const snapshotChildren = snapshot?.children;
+      for (const child of Object.values(snapshotChildren ?? {})) {
+        if (child?._parent === this && typeof child.getSnapshot === 'function') {
+          children.add(child);
+        }
+      }
+    }
+    for (const child of this.system._peekChildren?.()?.values() ?? []) {
+      if (child._parent === this) {
+        children.add(child);
+      }
+    }
+    for (const child of children) {
+      try {
+        if (child.getSnapshot().status !== 'active') {
+          continue;
+        }
+        const result = this.system.stopActor(child);
+        if (result) {
+          void Promise.resolve(result).catch(reportUnhandledError);
+        }
+      } catch (error) {
+        reportUnhandledError(error);
+      }
+    }
     if (!this.observers?.size) {
       if (!this._parent) {
         this._reportUnlessObserved(err);
@@ -5765,11 +5848,6 @@ class Actor {
       this.system._relay(this, this._parent, createErrorActorEvent(this.id, err, this.sessionId));
     }
   }
-  // TODO: atm children don't belong entirely to the actor so
-  // in a way - it's not even super aware of them
-  // so we can't stop them from here but we really should!
-  // right now, they are being stopped within the machine's transition
-  // but that could throw and leave us with "orphaned" active actors
   _stopProcedure() {
     if (this._processingStatus !== ProcessingStatus.Running) {
       // Actor already stopped; do nothing

package/dist/{createActor-c7c704c2.esm.js → createActor-5236aa33.esm.js}

@@ -2651,6 +2651,7 @@ function computeExitSet(transitions, stateNodeSet, snapshot, resolveTransition)
   return [...statesToExit];
 }
 function initialMicrostep(root, preInitialState, actorScope, initEvent, internalQueue) {
+  root.machine._microstepHooks?.begin(actorScope.self);
   const initialStateNodes = [...getInitialStateNodes(root)];
   const statesForDefaultEntry = new Set();
   const collectDefaultEntryStates = stateNode => {
@@ -2679,6 +2680,10 @@ function initialMicrostep(root, preInitialState, actorScope, initEvent, internal
 /** https://www.w3.org/TR/scxml/#microstepProcedure */
 function microstep(transitions, currentSnapshot, actorScope, event, isInitial, internalQueue, selectionResults) {
   const executableActions = [];
+  const internalEvents = currentSnapshot.machine._microstepHooks?.drain(actorScope.self);
+  if (internalEvents?.length) {
+    internalQueue.push(...internalEvents);
+  }
   if (!transitions.length) {
     return [currentSnapshot, executableActions];
   }
@@ -3393,6 +3398,11 @@ function macrostep(snapshot, event, actorScope, internalQueue, initialMicrosteps
     // eventless transitions should always be selected after selecting *regular* transitions
     // by assigning `undefined` to `previousState` we ensure that `shouldSelectEventlessTransitions` gets always computed to true in such a case
     const previousState = enabledTransitions.length ? nextSnapshot : undefined;
+    // Failed eventless guards can raise events even when no transition wins.
+    const raisedEvents = nextSnapshot.machine._microstepHooks?.drain(actorScope.self);
+    if (raisedEvents?.length) {
+      internalQueue.push(...raisedEvents);
+    }
     if (!enabledTransitions.length) {
       if (!internalQueue.length) {
         break;
@@ -3507,6 +3517,7 @@ function cancelTimers(snapshot, event, actorScope) {
   return resolveActionsWithContext(snapshot, event, actorScope, actions);
 }
 function selectEventlessTransitions(snapshot, event, actorScope) {
+  snapshot.machine._microstepHooks?.begin(actorScope.self);
   const enabledTransitionSet = new Set();
   const atomicStates = snapshot.nodes.filter(isAtomicStateNode);
   for (const atomicStateNode of atomicStates) {
@@ -4045,7 +4056,17 @@ function mapValues(collection, iteratee) {
   const collectionKeys = Object.keys(collection);
   for (let i = 0; i < collectionKeys.length; i++) {
     const key = collectionKeys[i];
-    result[key] = iteratee(collection[key], key, collection, i);
+    const value = iteratee(collection[key], key, collection, i);
+    if (key === '__proto__') {
+      Object.defineProperty(result, key, {
+        value,
+        enumerable: true,
+        configurable: true,
+        writable: true
+      });
+    } else {
+      result[key] = value;
+    }
   }
   return result;
 }
@@ -4203,23 +4224,14 @@ function matchesEventDescriptor(eventType, descriptor) {
 }
 
 function getStepEffect(actor, key) {
-  return actor.getSnapshot().effects?.[key];
-}
-function waitForStep(actor, key) {
-  return new Promise((resolve, reject) => {
-    const subscription = actor.subscribe(snapshot => {
-      const effect = snapshot.effects?.[key];
-      if (effect?.status === 'done') {
-        subscription.unsubscribe();
-        resolve(effect.output);
-      } else if (effect?.status === 'error') {
-        subscription.unsubscribe();
-        reject(effect.error);
-      }
-    });
-  });
+  const effects = actor.getSnapshot().effects;
+  return effects && Object.prototype.hasOwnProperty.call(effects, key) ? effects[key] : undefined;
 }
 
+// Live promises belong to an actor incarnation, unlike its persisted journal.
+// A restored active record has no promise here and must be retried locally.
+const pendingSteps = new WeakMap();
+
 /**
  * Runs one keyed step of an async actor with the built-in journal: the
  * result is memoized in the actor's own snapshot (`effects[key]`), so a
@@ -4237,29 +4249,66 @@ async function runStep(actor, key, exec, sendSelf = event => void actor.system.s
   if (effect?.status === 'error') {
     throw effect.error;
   }
-  if (effect?.status === 'active') {
-    return waitForStep(actor, key);
+  const running = pendingSteps.get(actor)?.get(key);
+  if (running) {
+    return running;
   }
-  sendSelf({
-    type: XSTATE_LOGIC_EFFECT_START,
-    key
-  });
-  try {
-    const output = await exec();
-    sendSelf({
-      type: XSTATE_LOGIC_EFFECT_RESOLVE,
-      key,
-      output
-    });
-    return output;
-  } catch (error) {
-    sendSelf({
-      type: XSTATE_LOGIC_EFFECT_REJECT,
-      key,
-      error
-    });
-    throw error;
+  if (actor.getSnapshot().status !== 'active') {
+    throw new Error(`Actor terminated before step "${key}" completed`);
   }
+  let resolve;
+  let reject;
+  const promise = new Promise((resolvePromise, rejectPromise) => {
+    resolve = resolvePromise;
+    reject = rejectPromise;
+  });
+  let steps = pendingSteps.get(actor);
+  if (!steps) {
+    steps = new Map();
+    pendingSteps.set(actor, steps);
+  }
+  steps.set(key, promise);
+  // oxlint-disable-next-line prefer-const
+  let subscription;
+  const cleanup = () => {
+    subscription?.unsubscribe();
+    steps.delete(key);
+    if (!steps.size) {
+      pendingSteps.delete(actor);
+    }
+  };
+  void promise.then(cleanup, cleanup);
+  subscription = actor.subscribe({
+    error: reject,
+    complete: () => reject(new Error(`Actor terminated before step "${key}" completed`))
+  });
+  void (async () => {
+    try {
+      sendSelf({
+        type: XSTATE_LOGIC_EFFECT_START,
+        key
+      });
+      const output = await exec();
+      if (actor.getSnapshot().status === 'active') {
+        sendSelf({
+          type: XSTATE_LOGIC_EFFECT_RESOLVE,
+          key,
+          output
+        });
+        resolve(output);
+      }
+    } catch (error) {
+      if (actor.getSnapshot().status === 'active') {
+        sendSelf({
+          type: XSTATE_LOGIC_EFFECT_REJECT,
+          key,
+          error
+        });
+      }
+      reject(error);
+    }
+  })().catch(reject);
+  return promise;
 }
 
 /**
@@ -4898,6 +4947,8 @@ class RuntimeSystem {
     }
   }
 }
+
+/** @internal */
 function createRuntimeSystem(rootActor, options) {
   return new RuntimeSystem(rootActor, options);
 }
@@ -5250,12 +5301,12 @@ class Actor {
   }
 
   /** Recover via the logic's error event if possible; otherwise error out. */
-  _recoverOrError(err, snapshot) {
+  _recoverOrError(err, snapshot, previousSnapshot) {
     if (this._tryHandleExecutionError(err, snapshot)) {
       return true;
     }
     this._setErrorSnapshot(err);
-    this._error(err);
+    this._error(err, previousSnapshot);
     return false;
   }
   _tryHandleExecutionError(err, snapshot = this._snapshot) {
@@ -5588,6 +5639,7 @@ class Actor {
     return this;
   }
   _process(event) {
+    const previousSnapshot = this._snapshot;
     let nextState;
     let caughtError;
     try {
@@ -5618,7 +5670,7 @@ class Actor {
       executeExecutableEffects(effects, this._actorScope);
       this.update(snapshot, event);
     } catch (err) {
-      if (!this._recoverOrError(err, snapshot)) {
+      if (!this._recoverOrError(err, snapshot, previousSnapshot)) {
         this._inspectTransition(this._snapshot, event);
       }
       return;
@@ -5704,8 +5756,39 @@ class Actor {
       }
     });
   }
-  _error(err) {
+  _error(err, previousSnapshot) {
     this._stopProcedure();
+    // Transition calculation or effect execution may fail before child stop
+    // effects run. Keep the previous snapshot's children when calculation has
+    // already removed them, and include children owned by non-machine logic
+    // from the runtime registry.
+    const children = new Set();
+    for (const snapshot of [this._snapshot, previousSnapshot]) {
+      const snapshotChildren = snapshot?.children;
+      for (const child of Object.values(snapshotChildren ?? {})) {
+        if (child?._parent === this && typeof child.getSnapshot === 'function') {
+          children.add(child);
+        }
+      }
+    }
+    for (const child of this.system._peekChildren?.()?.values() ?? []) {
+      if (child._parent === this) {
+        children.add(child);
+      }
+    }
+    for (const child of children) {
+      try {
+        if (child.getSnapshot().status !== 'active') {
+          continue;
+        }
+        const result = this.system.stopActor(child);
+        if (result) {
+          void Promise.resolve(result).catch(reportUnhandledError);
+        }
+      } catch (error) {
+        reportUnhandledError(error);
+      }
+    }
     if (!this.observers?.size) {
       if (!this._parent) {
         this._reportUnlessObserved(err);
@@ -5732,11 +5815,6 @@ class Actor {
       this.system._relay(this, this._parent, createErrorActorEvent(this.id, err, this.sessionId));
     }
   }
-  // TODO: atm children don't belong entirely to the actor so
-  // in a way - it's not even super aware of them
-  // so we can't stop them from here but we really should!
-  // right now, they are being stopped within the machine's transition
-  // but that could throw and leave us with "orphaned" active actors
   _stopProcedure() {
     if (this._processingStatus !== ProcessingStatus.Running) {
       // Actor already stopped; do nothing