xstate 6.0.0-alpha.15 → 6.0.0-alpha.17

package/bin/xstate.js

@@ -0,0 +1,36 @@
+#!/usr/bin/env node
+// Lightweight `xstate` CLI. Heavy commands are delegated to dedicated
+// packages fetched on demand so the core package stays dependency-free.
+const { spawnSync } = require('child_process');
+
+const [command, ...rest] = process.argv.slice(2);
+
+switch (command) {
+  case 'migrate': {
+    // Delegates to @xstate/codemod (ts-morph based v5 → v6 codemods).
+    const result = spawnSync(
+      process.platform === 'win32' ? 'npx.cmd' : 'npx',
+      ['-y', '@xstate/codemod', 'migrate', ...rest],
+      { stdio: 'inherit' }
+    );
+    process.exit(result.status ?? 1);
+    break;
+  }
+  case '--help':
+  case 'help':
+  case undefined:
+    console.log(
+      [
+        'Usage: xstate <command>',
+        '',
+        'Commands:',
+        '  migrate [globs...] [--dry]   Migrate source files to the current XState version',
+        '                               (delegates to @xstate/codemod)'
+      ].join('\n')
+    );
+    process.exit(command ? 0 : 1);
+    break;
+  default:
+    console.error(`Unknown command: ${command}`);
+    process.exit(1);
+}

package/dist/{StateMachine-0fa9c094.development.esm.js → StateMachine-114b1598.development.esm.js}

@@ -1,4 +1,4 @@
-import { P as ProcessingStatus, G as resolveReferencedActor, d as createActor, S as STATE_DELIMITER, H as mapValues, t as toArray, I as createInvokeId, J as getDelayedTransitions, K as evaluateCandidate, L as formatTransition, N as NULL_EVENT, M as toTransitionConfigArray, O as createInvokeTimeoutEvent, Q as getCandidates, R as formatRouteTransitions, U as resolveStateValue, V as getAllStateNodes, k as getStateNodes, W as createMachineSnapshot, Y as isInFinalState, e as macrostep, Z as cloneMachineSnapshot, _ as transitionNode, m as matchesEventDescriptor, r as resolveActionsWithContext, f as createInitEvent, g as initialMicrostep, $ as toStatePath, a0 as isStateId, a1 as getStateNodeByPath, a2 as getPersistedSnapshot, a3 as $$ACTOR_TYPE } from './index-362125ce.development.esm.js';
+import { P as ProcessingStatus, G as resolveReferencedActor, d as createActor, S as STATE_DELIMITER, H as mapValues, t as toArray, I as createInvokeId, J as getDelayedTransitions, K as evaluateCandidate, L as formatTransition, N as NULL_EVENT, M as toTransitionConfigArray, O as createInvokeTimeoutEvent, Q as getCandidates, R as formatRouteTransitions, U as resolveStateValue, V as getAllStateNodes, k as getStateNodes, W as createMachineSnapshot, Y as isInFinalState, e as macrostep, Z as cloneMachineSnapshot, _ as transitionNode, m as matchesEventDescriptor, $ as getTransitionResult, a0 as hasEffect, a1 as createErrorPlatformEvent, r as resolveActionsWithContext, f as createInitEvent, g as initialMicrostep, a2 as toStatePath, a3 as isStateId, a4 as getStateNodeByPath, a5 as getPersistedSnapshot, a6 as $$ACTOR_TYPE } from './index-31e8ad34.development.esm.js';
 
 function createSpawner(actorScope, {
   machine,
@@ -250,11 +250,13 @@ function validateStateNodeConfig(stateNode) {
     return;
   }
   if (typeof config.choice !== 'function') {
-    throw new Error(`Choice state "${stateNode.id}" must declare a \`choice\` function.`);
+    throw new Error(`Choice state "${stateNode.id}" must declare a \`choice\` function.` );
   }
-  for (const key of CHOICE_CONFIG_KEYS) {
-    if (config[key] !== undefined) {
-      throw new Error(`Choice state "${stateNode.id}" cannot declare \`${key}\`.`);
+  {
+    for (const key of CHOICE_CONFIG_KEYS) {
+      if (config[key] !== undefined) {
+        throw new Error(`Choice state "${stateNode.id}" cannot declare \`${key}\`.`);
+      }
     }
   }
 }
@@ -262,11 +264,13 @@ function formatChoiceTransitions(stateNode) {
   const choice = stateNode.config.choice;
   const validateChoiceResult = result => {
     if (!result || result.target === undefined) {
-      throw new Error(`Choice state "${stateNode.id}" must resolve to a target.`);
+      throw new Error(`Choice state "${stateNode.id}" must resolve to a target.` );
     }
-    for (const key of ['actions', 'to']) {
-      if (result[key] !== undefined) {
-        throw new Error(`Choice state "${stateNode.id}" cannot declare \`${key}\` on a choice.`);
+    {
+      for (const key of ['actions', 'to']) {
+        if (result[key] !== undefined) {
+          throw new Error(`Choice state "${stateNode.id}" cannot declare \`${key}\` on a choice.`);
+        }
       }
     }
     return result;
@@ -288,7 +292,7 @@ function formatTransitions(stateNode) {
   if (stateNode.config.on) {
     for (const descriptor of Object.keys(stateNode.config.on)) {
       if (descriptor === NULL_EVENT) {
-        throw new Error('Null events ("") cannot be specified as a transition key. Use `always: { ... }` instead.');
+        throw new Error('Null events ("") cannot be specified as a transition key. Use `always: { ... }` instead.' );
       }
       const transitionsConfig = stateNode.config.on[descriptor];
       transitions.set(descriptor, mapTransitionConfigs(transitionsConfig, transition => formatTransition(stateNode, descriptor, transition)));
@@ -298,6 +302,10 @@ function formatTransitions(stateNode) {
     const descriptor = `xstate.done.state.${stateNode.id}`;
     transitions.set(descriptor, mapTransitionConfigs(stateNode.config.onDone, transition => formatTransition(stateNode, descriptor, transition)));
   }
+  if (stateNode.config.onError) {
+    const descriptor = 'xstate.error.*';
+    transitions.set(descriptor, mapTransitionConfigs(stateNode.config.onError, transition => formatTransition(stateNode, descriptor, transition)));
+  }
   const createCancelInvokeTimeoutTransition = (descriptor, timeoutEventType) => formatTransition(stateNode, descriptor, {
     to: (_args, enq) => {
       enq.cancel(timeoutEventType);
@@ -384,7 +392,7 @@ function formatInitialTransition(stateNode, _target) {
   const input = typeof _target === 'object' && _target !== null ? _target.input : undefined;
   const resolvedTarget = typeof targetString === 'string' ? stateNode.states[targetString] : undefined;
   if (!resolvedTarget && targetString) {
-    throw new Error(`Initial state node "${targetString}" not found on parent state node #${stateNode.id}`);
+    throw new Error(`Initial state node "${targetString}" not found on parent state node #${stateNode.id}` );
   }
   const transition = {
     source: stateNode,
@@ -395,6 +403,45 @@ function formatInitialTransition(stateNode, _target) {
 }
 
 const STATE_IDENTIFIER = '#';
+let emptyCanActor;
+let emptyCanActorScope;
+function getEmptyCanActor() {
+  // A minimal inert actor used purely as the `self`/`parent` argument when
+  // dry-running transitions for `snapshot.can(...)`. Intentionally not built
+  // on `createLogic` so `can()` does not pull that machinery into bundles.
+  return emptyCanActor ??= createActor({
+    transition: snapshot => [snapshot, []],
+    initialTransition: () => [{
+      status: 'active',
+      output: undefined,
+      error: undefined
+    }, []],
+    getInitialSnapshot: () => ({
+      status: 'active',
+      output: undefined,
+      error: undefined
+    }),
+    getPersistedSnapshot: snapshot => snapshot
+  });
+}
+function getEmptyCanActorScope() {
+  if (emptyCanActorScope) {
+    return emptyCanActorScope;
+  }
+  const actor = getEmptyCanActor();
+  emptyCanActorScope = {
+    self: actor,
+    logger: () => {},
+    id: '',
+    sessionId: '',
+    defer: () => {},
+    system: actor.system,
+    stopChild: () => {},
+    emit: () => {},
+    actionExecutor: () => {}
+  };
+  return emptyCanActorScope;
+}
 class StateMachine {
   constructor(/** The raw config used to create the machine. */
   config, implementations) {
@@ -461,9 +508,6 @@ class StateMachine {
     this.root._refreshEventMetadata();
     this.states = this.root.states; // TODO: remove!
     this.events = this.root.events;
-    if (!('output' in this.root) && Object.values(this.states).some(state => state.type === 'final' && 'output' in state)) {
-      console.warn('Missing `machine.output` declaration (top-level final state with output detected)');
-    }
   }
 
   /**
@@ -603,6 +647,49 @@ class StateMachine {
     return false;
   }
 
+  /**
+   * Determines whether sending the `event` to the given snapshot would select a
+   * non-forbidden transition. Backs `snapshot.can(...)`; lives here so that
+   * non-machine bundles don't pay for the transition-resolution machinery.
+   *
+   * @internal
+   */
+  _canTransition(snapshot, event) {
+    const emptyActor = getEmptyCanActor();
+    const emptyActorScope = getEmptyCanActorScope();
+    const transitionData = this.getTransitionData(snapshot, event, emptyActor);
+    if (!transitionData?.length) {
+      return false;
+    }
+
+    // Check that at least one transition is not forbidden
+    for (const transition of transitionData) {
+      if (transition.target !== undefined) {
+        return true;
+      }
+      const res = getTransitionResult(transition, snapshot, event, emptyActorScope, {
+        resolveActions: false
+      });
+      if (res.targets?.length || res.context || hasEffect(transition, snapshot.context, event, snapshot, emptyActor)) {
+        return true;
+      }
+    }
+    return false;
+  }
+
+  /**
+   * Returns the error event that the actor should transition with to recover
+   * from an execution error, if any active state node declares `onError`.
+   *
+   * @internal
+   */
+  getExecutionErrorEvent(snapshot, error) {
+    if (snapshot?.status !== 'active' || !snapshot._nodes?.some(stateNode => stateNode.config.onError)) {
+      return undefined;
+    }
+    return createErrorPlatformEvent('execution', error);
+  }
+
   /**
    * The initial state _before_ evaluating any microsteps. This "pre-initial"
    * state is provided to initial actions executed in the initial state.
@@ -654,11 +741,26 @@ class StateMachine {
     const initEvent = createInitEvent(input); // TODO: fix;
     const internalQueue = [];
     const preInitialState = this._getPreInitialState(actorScope, initEvent);
-    const [nextState, initialActions] = initialMicrostep(this.root, preInitialState, actorScope, initEvent, internalQueue);
-    const {
-      snapshot: macroState,
-      microsteps
-    } = macrostep(nextState, initEvent, actorScope, internalQueue);
+    let nextState;
+    let initialActions = [];
+    let microsteps = [];
+    let macroState;
+    try {
+      [nextState, initialActions] = initialMicrostep(this.root, preInitialState, actorScope, initEvent, internalQueue);
+      ({
+        snapshot: macroState,
+        microsteps
+      } = macrostep(nextState, initEvent, actorScope, internalQueue));
+    } catch (err) {
+      if (!this.root.config.onError) {
+        throw err;
+      }
+      const errorEvent = createErrorPlatformEvent('execution', err);
+      const errorMacrostep = macrostep(preInitialState, errorEvent, actorScope, []);
+      macroState = errorMacrostep.snapshot;
+      microsteps = errorMacrostep.microsteps;
+      initialActions = [];
+    }
     return [macroState, [...initialActions, ...microsteps.flatMap(([, actions]) => actions)]];
   }
   start(snapshot) {

package/dist/{StateMachine-98411dc5.development.cjs.js → StateMachine-4d17c47e.development.cjs.js}

@@ -1,6 +1,6 @@
 'use strict';
 
-var dist_xstateActors = require('./index-07b19ed0.development.cjs.js');
+var dist_xstateActors = require('./index-415cdd3a.development.cjs.js');
 
 function createSpawner(actorScope, {
   machine,
@@ -252,11 +252,13 @@ function validateStateNodeConfig(stateNode) {
     return;
   }
   if (typeof config.choice !== 'function') {
-    throw new Error(`Choice state "${stateNode.id}" must declare a \`choice\` function.`);
+    throw new Error(`Choice state "${stateNode.id}" must declare a \`choice\` function.` );
   }
-  for (const key of CHOICE_CONFIG_KEYS) {
-    if (config[key] !== undefined) {
-      throw new Error(`Choice state "${stateNode.id}" cannot declare \`${key}\`.`);
+  {
+    for (const key of CHOICE_CONFIG_KEYS) {
+      if (config[key] !== undefined) {
+        throw new Error(`Choice state "${stateNode.id}" cannot declare \`${key}\`.`);
+      }
     }
   }
 }
@@ -264,11 +266,13 @@ function formatChoiceTransitions(stateNode) {
   const choice = stateNode.config.choice;
   const validateChoiceResult = result => {
     if (!result || result.target === undefined) {
-      throw new Error(`Choice state "${stateNode.id}" must resolve to a target.`);
+      throw new Error(`Choice state "${stateNode.id}" must resolve to a target.` );
     }
-    for (const key of ['actions', 'to']) {
-      if (result[key] !== undefined) {
-        throw new Error(`Choice state "${stateNode.id}" cannot declare \`${key}\` on a choice.`);
+    {
+      for (const key of ['actions', 'to']) {
+        if (result[key] !== undefined) {
+          throw new Error(`Choice state "${stateNode.id}" cannot declare \`${key}\` on a choice.`);
+        }
       }
     }
     return result;
@@ -290,7 +294,7 @@ function formatTransitions(stateNode) {
   if (stateNode.config.on) {
     for (const descriptor of Object.keys(stateNode.config.on)) {
       if (descriptor === dist_xstateActors.NULL_EVENT) {
-        throw new Error('Null events ("") cannot be specified as a transition key. Use `always: { ... }` instead.');
+        throw new Error('Null events ("") cannot be specified as a transition key. Use `always: { ... }` instead.' );
       }
       const transitionsConfig = stateNode.config.on[descriptor];
       transitions.set(descriptor, mapTransitionConfigs(transitionsConfig, transition => dist_xstateActors.formatTransition(stateNode, descriptor, transition)));
@@ -300,6 +304,10 @@ function formatTransitions(stateNode) {
     const descriptor = `xstate.done.state.${stateNode.id}`;
     transitions.set(descriptor, mapTransitionConfigs(stateNode.config.onDone, transition => dist_xstateActors.formatTransition(stateNode, descriptor, transition)));
   }
+  if (stateNode.config.onError) {
+    const descriptor = 'xstate.error.*';
+    transitions.set(descriptor, mapTransitionConfigs(stateNode.config.onError, transition => dist_xstateActors.formatTransition(stateNode, descriptor, transition)));
+  }
   const createCancelInvokeTimeoutTransition = (descriptor, timeoutEventType) => dist_xstateActors.formatTransition(stateNode, descriptor, {
     to: (_args, enq) => {
       enq.cancel(timeoutEventType);
@@ -386,7 +394,7 @@ function formatInitialTransition(stateNode, _target) {
   const input = typeof _target === 'object' && _target !== null ? _target.input : undefined;
   const resolvedTarget = typeof targetString === 'string' ? stateNode.states[targetString] : undefined;
   if (!resolvedTarget && targetString) {
-    throw new Error(`Initial state node "${targetString}" not found on parent state node #${stateNode.id}`);
+    throw new Error(`Initial state node "${targetString}" not found on parent state node #${stateNode.id}` );
   }
   const transition = {
     source: stateNode,
@@ -397,6 +405,45 @@ function formatInitialTransition(stateNode, _target) {
 }
 
 const STATE_IDENTIFIER = '#';
+let emptyCanActor;
+let emptyCanActorScope;
+function getEmptyCanActor() {
+  // A minimal inert actor used purely as the `self`/`parent` argument when
+  // dry-running transitions for `snapshot.can(...)`. Intentionally not built
+  // on `createLogic` so `can()` does not pull that machinery into bundles.
+  return emptyCanActor ??= dist_xstateActors.createActor({
+    transition: snapshot => [snapshot, []],
+    initialTransition: () => [{
+      status: 'active',
+      output: undefined,
+      error: undefined
+    }, []],
+    getInitialSnapshot: () => ({
+      status: 'active',
+      output: undefined,
+      error: undefined
+    }),
+    getPersistedSnapshot: snapshot => snapshot
+  });
+}
+function getEmptyCanActorScope() {
+  if (emptyCanActorScope) {
+    return emptyCanActorScope;
+  }
+  const actor = getEmptyCanActor();
+  emptyCanActorScope = {
+    self: actor,
+    logger: () => {},
+    id: '',
+    sessionId: '',
+    defer: () => {},
+    system: actor.system,
+    stopChild: () => {},
+    emit: () => {},
+    actionExecutor: () => {}
+  };
+  return emptyCanActorScope;
+}
 class StateMachine {
   constructor(/** The raw config used to create the machine. */
   config, implementations) {
@@ -463,9 +510,6 @@ class StateMachine {
     this.root._refreshEventMetadata();
     this.states = this.root.states; // TODO: remove!
     this.events = this.root.events;
-    if (!('output' in this.root) && Object.values(this.states).some(state => state.type === 'final' && 'output' in state)) {
-      console.warn('Missing `machine.output` declaration (top-level final state with output detected)');
-    }
   }
 
   /**
@@ -605,6 +649,49 @@ class StateMachine {
     return false;
   }
 
+  /**
+   * Determines whether sending the `event` to the given snapshot would select a
+   * non-forbidden transition. Backs `snapshot.can(...)`; lives here so that
+   * non-machine bundles don't pay for the transition-resolution machinery.
+   *
+   * @internal
+   */
+  _canTransition(snapshot, event) {
+    const emptyActor = getEmptyCanActor();
+    const emptyActorScope = getEmptyCanActorScope();
+    const transitionData = this.getTransitionData(snapshot, event, emptyActor);
+    if (!transitionData?.length) {
+      return false;
+    }
+
+    // Check that at least one transition is not forbidden
+    for (const transition of transitionData) {
+      if (transition.target !== undefined) {
+        return true;
+      }
+      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)) {
+        return true;
+      }
+    }
+    return false;
+  }
+
+  /**
+   * Returns the error event that the actor should transition with to recover
+   * from an execution error, if any active state node declares `onError`.
+   *
+   * @internal
+   */
+  getExecutionErrorEvent(snapshot, error) {
+    if (snapshot?.status !== 'active' || !snapshot._nodes?.some(stateNode => stateNode.config.onError)) {
+      return undefined;
+    }
+    return dist_xstateActors.createErrorPlatformEvent('execution', error);
+  }
+
   /**
    * The initial state _before_ evaluating any microsteps. This "pre-initial"
    * state is provided to initial actions executed in the initial state.
@@ -656,11 +743,26 @@ class StateMachine {
     const initEvent = dist_xstateActors.createInitEvent(input); // TODO: fix;
     const internalQueue = [];
     const preInitialState = this._getPreInitialState(actorScope, initEvent);
-    const [nextState, initialActions] = dist_xstateActors.initialMicrostep(this.root, preInitialState, actorScope, initEvent, internalQueue);
-    const {
-      snapshot: macroState,
-      microsteps
-    } = dist_xstateActors.macrostep(nextState, initEvent, actorScope, internalQueue);
+    let nextState;
+    let initialActions = [];
+    let microsteps = [];
+    let macroState;
+    try {
+      [nextState, initialActions] = dist_xstateActors.initialMicrostep(this.root, preInitialState, actorScope, initEvent, internalQueue);
+      ({
+        snapshot: macroState,
+        microsteps
+      } = dist_xstateActors.macrostep(nextState, initEvent, actorScope, internalQueue));
+    } catch (err) {
+      if (!this.root.config.onError) {
+        throw err;
+      }
+      const errorEvent = dist_xstateActors.createErrorPlatformEvent('execution', err);
+      const errorMacrostep = dist_xstateActors.macrostep(preInitialState, errorEvent, actorScope, []);
+      macroState = errorMacrostep.snapshot;
+      microsteps = errorMacrostep.microsteps;
+      initialActions = [];
+    }
     return [macroState, [...initialActions, ...microsteps.flatMap(([, actions]) => actions)]];
   }
   start(snapshot) {

package/dist/{StateMachine-e3b1aa2d.cjs.js → StateMachine-a10528bb.cjs.js}

@@ -1,6 +1,6 @@
 'use strict';
 
-var dist_xstateActors = require('./index-0d940f2c.cjs.js');
+var dist_xstateActors = require('./index-1ac35571.cjs.js');
 
 function createSpawner(actorScope, {
   machine,
@@ -66,7 +66,6 @@ function memo(object, key, fn) {
 }
 
 const EMPTY_OBJECT = {};
-const CHOICE_CONFIG_KEYS = ['invoke', 'after', 'on', 'entry', 'exit', 'always', 'states', 'initial', 'onDone', 'timeout', 'onTimeout', 'history', 'target', 'output'];
 class StateNode {
   constructor(/** The raw config used to create the machine. */
   config, options) {
@@ -246,30 +245,17 @@ class StateNode {
 function validateStateNodeConfig(stateNode) {
   const config = stateNode.config;
   if (stateNode.type !== 'choice') {
-    if (config.choice !== undefined) {
-      throw new Error(`State "${stateNode.id}" has \`choice\`, but \`choice\` can only be used with \`type: 'choice'\`.`);
-    }
     return;
   }
   if (typeof config.choice !== 'function') {
-    throw new Error(`Choice state "${stateNode.id}" must declare a \`choice\` function.`);
-  }
-  for (const key of CHOICE_CONFIG_KEYS) {
-    if (config[key] !== undefined) {
-      throw new Error(`Choice state "${stateNode.id}" cannot declare \`${key}\`.`);
-    }
+    throw new Error(`Missing \`choice\` function on "${stateNode.id}"`);
   }
 }
 function formatChoiceTransitions(stateNode) {
   const choice = stateNode.config.choice;
   const validateChoiceResult = result => {
     if (!result || result.target === undefined) {
-      throw new Error(`Choice state "${stateNode.id}" must resolve to a target.`);
-    }
-    for (const key of ['actions', 'to']) {
-      if (result[key] !== undefined) {
-        throw new Error(`Choice state "${stateNode.id}" cannot declare \`${key}\` on a choice.`);
-      }
+      throw new Error(`Choice "${stateNode.id}" has no target`);
     }
     return result;
   };
@@ -290,7 +276,7 @@ function formatTransitions(stateNode) {
   if (stateNode.config.on) {
     for (const descriptor of Object.keys(stateNode.config.on)) {
       if (descriptor === dist_xstateActors.NULL_EVENT) {
-        throw new Error('Null events ("") cannot be specified as a transition key. Use `always: { ... }` instead.');
+        throw new Error('Null event transition key');
       }
       const transitionsConfig = stateNode.config.on[descriptor];
       transitions.set(descriptor, mapTransitionConfigs(transitionsConfig, transition => dist_xstateActors.formatTransition(stateNode, descriptor, transition)));
@@ -300,6 +286,10 @@ function formatTransitions(stateNode) {
     const descriptor = `xstate.done.state.${stateNode.id}`;
     transitions.set(descriptor, mapTransitionConfigs(stateNode.config.onDone, transition => dist_xstateActors.formatTransition(stateNode, descriptor, transition)));
   }
+  if (stateNode.config.onError) {
+    const descriptor = 'xstate.error.*';
+    transitions.set(descriptor, mapTransitionConfigs(stateNode.config.onError, transition => dist_xstateActors.formatTransition(stateNode, descriptor, transition)));
+  }
   const createCancelInvokeTimeoutTransition = (descriptor, timeoutEventType) => dist_xstateActors.formatTransition(stateNode, descriptor, {
     to: (_args, enq) => {
       enq.cancel(timeoutEventType);
@@ -386,7 +376,7 @@ function formatInitialTransition(stateNode, _target) {
   const input = typeof _target === 'object' && _target !== null ? _target.input : undefined;
   const resolvedTarget = typeof targetString === 'string' ? stateNode.states[targetString] : undefined;
   if (!resolvedTarget && targetString) {
-    throw new Error(`Initial state node "${targetString}" not found on parent state node #${stateNode.id}`);
+    throw new Error(`Initial state "${targetString}" not found on "#${stateNode.id}"`);
   }
   const transition = {
     source: stateNode,
@@ -397,6 +387,45 @@ function formatInitialTransition(stateNode, _target) {
 }
 
 const STATE_IDENTIFIER = '#';
+let emptyCanActor;
+let emptyCanActorScope;
+function getEmptyCanActor() {
+  // A minimal inert actor used purely as the `self`/`parent` argument when
+  // dry-running transitions for `snapshot.can(...)`. Intentionally not built
+  // on `createLogic` so `can()` does not pull that machinery into bundles.
+  return emptyCanActor ??= dist_xstateActors.createActor({
+    transition: snapshot => [snapshot, []],
+    initialTransition: () => [{
+      status: 'active',
+      output: undefined,
+      error: undefined
+    }, []],
+    getInitialSnapshot: () => ({
+      status: 'active',
+      output: undefined,
+      error: undefined
+    }),
+    getPersistedSnapshot: snapshot => snapshot
+  });
+}
+function getEmptyCanActorScope() {
+  if (emptyCanActorScope) {
+    return emptyCanActorScope;
+  }
+  const actor = getEmptyCanActor();
+  emptyCanActorScope = {
+    self: actor,
+    logger: () => {},
+    id: '',
+    sessionId: '',
+    defer: () => {},
+    system: actor.system,
+    stopChild: () => {},
+    emit: () => {},
+    actionExecutor: () => {}
+  };
+  return emptyCanActorScope;
+}
 class StateMachine {
   constructor(/** The raw config used to create the machine. */
   config, implementations) {
@@ -591,6 +620,49 @@ class StateMachine {
     return false;
   }
 
+  /**
+   * Determines whether sending the `event` to the given snapshot would select a
+   * non-forbidden transition. Backs `snapshot.can(...)`; lives here so that
+   * non-machine bundles don't pay for the transition-resolution machinery.
+   *
+   * @internal
+   */
+  _canTransition(snapshot, event) {
+    const emptyActor = getEmptyCanActor();
+    const emptyActorScope = getEmptyCanActorScope();
+    const transitionData = this.getTransitionData(snapshot, event, emptyActor);
+    if (!transitionData?.length) {
+      return false;
+    }
+
+    // Check that at least one transition is not forbidden
+    for (const transition of transitionData) {
+      if (transition.target !== undefined) {
+        return true;
+      }
+      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)) {
+        return true;
+      }
+    }
+    return false;
+  }
+
+  /**
+   * Returns the error event that the actor should transition with to recover
+   * from an execution error, if any active state node declares `onError`.
+   *
+   * @internal
+   */
+  getExecutionErrorEvent(snapshot, error) {
+    if (snapshot?.status !== 'active' || !snapshot._nodes?.some(stateNode => stateNode.config.onError)) {
+      return undefined;
+    }
+    return dist_xstateActors.createErrorPlatformEvent('execution', error);
+  }
+
   /**
    * The initial state _before_ evaluating any microsteps. This "pre-initial"
    * state is provided to initial actions executed in the initial state.
@@ -642,11 +714,26 @@ class StateMachine {
     const initEvent = dist_xstateActors.createInitEvent(input); // TODO: fix;
     const internalQueue = [];
     const preInitialState = this._getPreInitialState(actorScope, initEvent);
-    const [nextState, initialActions] = dist_xstateActors.initialMicrostep(this.root, preInitialState, actorScope, initEvent, internalQueue);
-    const {
-      snapshot: macroState,
-      microsteps
-    } = dist_xstateActors.macrostep(nextState, initEvent, actorScope, internalQueue);
+    let nextState;
+    let initialActions = [];
+    let microsteps = [];
+    let macroState;
+    try {
+      [nextState, initialActions] = dist_xstateActors.initialMicrostep(this.root, preInitialState, actorScope, initEvent, internalQueue);
+      ({
+        snapshot: macroState,
+        microsteps
+      } = dist_xstateActors.macrostep(nextState, initEvent, actorScope, internalQueue));
+    } catch (err) {
+      if (!this.root.config.onError) {
+        throw err;
+      }
+      const errorEvent = dist_xstateActors.createErrorPlatformEvent('execution', err);
+      const errorMacrostep = dist_xstateActors.macrostep(preInitialState, errorEvent, actorScope, []);
+      macroState = errorMacrostep.snapshot;
+      microsteps = errorMacrostep.microsteps;
+      initialActions = [];
+    }
     return [macroState, [...initialActions, ...microsteps.flatMap(([, actions]) => actions)]];
   }
   start(snapshot) {