xstate 6.0.0-alpha.2 → 6.0.0-alpha.21

package/dist/{StateMachine-2ea0a7fa.development.esm.js → StateMachine-e25dd61f.development.esm.js}

@@ -1,4 +1,4 @@
-import { P as ProcessingStatus, G as resolveReferencedActor, c 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, n as getStateNodes, W as createMachineSnapshot, X as isInFinalState, a as macrostep, Y as transitionNode, m as matchesEventDescriptor, Z as resolveAndExecuteActionsWithContext, b as createInitEvent, d as initialMicrostep, _ as toStatePath, $ as isStateId, a0 as getStateNodeByPath, a1 as getPersistedSnapshot, a2 as $$ACTOR_TYPE } from './index-e61170ba.development.esm.js';
+import { P as ProcessingStatus, H as resolveReferencedActor, e as createActor, S as STATE_DELIMITER, I as mapValues, t as toArray, J as createInvokeId, K as getDelayedTransitions, L as evaluateCandidate, M as formatTransition, N as NULL_EVENT, O as toTransitionConfigArray, Q as createInvokeTimeoutEvent, R as getCandidates, U as formatRouteTransitions, V as resolveStateValue, W as getAllStateNodes, l as getStateNodes, Y as createMachineSnapshot, Z as isInFinalState, f as macrostep, d as deriveDeferredStarts, _ as cloneMachineSnapshot, $ as transitionNode, m as matchesEventDescriptor, a0 as getTransitionResult, a1 as hasEffect, a2 as createErrorPlatformEvent, r as resolveActionsWithContext, g as createInitEvent, h as initialMicrostep, a3 as toStatePath, a4 as isStateId, a5 as getStateNodeByPath, a6 as getPersistedSnapshot, a7 as $$ACTOR_TYPE } from './index-d39fb138.development.esm.js';
 
 function createSpawner(actorScope, {
   machine,
@@ -20,7 +20,7 @@ function createSpawner(actorScope, {
           self: actorScope.self
         }) : options?.input,
         src,
-        systemId: options?.systemId
+        registryKey: options?.registryKey
       });
       spawnedChildren[actor.id] = actor;
       return actor;
@@ -31,7 +31,7 @@ function createSpawner(actorScope, {
         syncSnapshot: options?.syncSnapshot,
         input: options?.input,
         src,
-        systemId: options?.systemId
+        registryKey: options?.registryKey
       });
       return actor;
     }
@@ -171,7 +171,7 @@ class StateNode {
     this.invoke = toArray(this.config.invoke).map((invokeConfig, i) => {
       const {
         src,
-        systemId
+        registryKey
       } = invokeConfig;
       const invokeId = createInvokeId(this.id, i);
       const resolvedId = invokeConfig.id ?? invokeId;
@@ -184,7 +184,7 @@ class StateNode {
         src: sourceName,
         logic: src,
         id: resolvedId,
-        systemId
+        registryKey
       };
     });
   }
@@ -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', 'context']) {
-      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) {
@@ -422,7 +469,7 @@ class StateMachine {
     this._json = void 0;
     this.id = config.id || '(machine)';
     this.implementations = {
-      actors: config.actors ?? {},
+      actorSources: config.actorSources ?? {},
       actions: config.actions ?? {},
       delays: config.delays ?? {},
       guards: config.guards ?? {},
@@ -431,7 +478,7 @@ class StateMachine {
     {
       // The `@xstate.` prefix is reserved for built-in serialized action and
       // guard descriptors — user implementation names must not collide.
-      for (const kind of ['actions', 'guards', 'actors', 'delays']) {
+      for (const kind of ['actions', 'guards', 'actorSources', 'delays']) {
         for (const key of Object.keys(this.implementations[kind])) {
           if (key.startsWith('@xstate.')) {
             throw new Error(`Invalid ${kind} name '${key}': the '@xstate.' prefix is reserved for built-in descriptors.`);
@@ -447,6 +494,7 @@ class StateMachine {
       ...this.config.options
     };
     this.transition = this.transition.bind(this);
+    this.initialTransition = this.initialTransition.bind(this);
     this.getInitialSnapshot = this.getInitialSnapshot.bind(this);
     this.getPersistedSnapshot = this.getPersistedSnapshot.bind(this);
     this.restoreSnapshot = this.restoreSnapshot.bind(this);
@@ -460,23 +508,20 @@ 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)');
-    }
   }
 
   /**
    * Clones this state machine with the provided implementations.
    *
-   * @param implementations Options (`actions`, `guards`, `actors`, `delays`) to
-   *   recursively merge with the existing options.
+   * @param implementations Options (`actions`, `guards`, `actorSources`,
+   *   `delays`) to recursively merge with the existing options.
    * @returns A new `StateMachine` instance with the provided implementations.
    */
   provide(implementations) {
     const {
       actions,
       guards,
-      actors,
+      actorSources,
       delays
     } = this.implementations;
     const provided = new StateMachine(this.config, {
@@ -488,9 +533,9 @@ class StateMachine {
         ...guards,
         ...implementations.guards
       },
-      actors: {
-        ...actors,
-        ...implementations.actors
+      actorSources: {
+        ...actorSources,
+        ...implementations.actorSources
       },
       delays: {
         ...delays,
@@ -525,7 +570,56 @@ class StateMachine {
    * @param event The received event
    */
   transition(snapshot, event, actorScope) {
-    return macrostep(snapshot, event, actorScope, []).snapshot;
+    const fastSnapshot = this._transitionFast(snapshot, event, actorScope);
+    if (fastSnapshot) {
+      return [fastSnapshot, []];
+    }
+    const {
+      snapshot: nextSnapshot,
+      microsteps
+    } = macrostep(snapshot, event, actorScope, []);
+    return [nextSnapshot, this._collectEffects(microsteps)];
+  }
+  _collectEffects(microsteps, initialActions = []) {
+    const effects = [...initialActions, ...microsteps.flatMap(([, actions]) => actions)];
+    return [...effects, ...deriveDeferredStarts(effects)];
+  }
+  _transitionFast(snapshot, event, actorScope) {
+    if (snapshot.status !== 'active' || typeof snapshot.value !== 'string' || this.root.always?.length) {
+      return undefined;
+    }
+    const sourceNode = this.root.states[snapshot.value];
+    if (!sourceNode || sourceNode.type !== 'atomic' || sourceNode.exit || sourceNode.invoke.length || sourceNode.always?.length || sourceNode.after?.length) {
+      return undefined;
+    }
+    const transitions = sourceNode.transitions.get(event.type);
+    if (transitions?.length !== 1) {
+      return undefined;
+    }
+    const selected = transitions[0];
+    if (selected.guard || selected.actions || selected.to || selected.reenter || selected.input || typeof selected.context === 'function' || selected.target && selected.target.length !== 1) {
+      return undefined;
+    }
+    const targetNode = selected.target?.[0] ?? sourceNode;
+    const stateChanged = targetNode !== sourceNode;
+    if (targetNode.parent !== this.root || targetNode.type !== 'atomic' || stateChanged && (targetNode.entry || targetNode.invoke.length || targetNode.always?.length || targetNode.after?.length)) {
+      return undefined;
+    }
+    const context = selected.context !== undefined ? {
+      ...snapshot.context,
+      ...selected.context
+    } : snapshot.context;
+    const collectedMicrosteps = actorScope.self._collectedMicrosteps || [];
+    collectedMicrosteps.push(selected);
+    actorScope.self._collectedMicrosteps = collectedMicrosteps;
+    return cloneMachineSnapshot(snapshot, {
+      ...(context !== snapshot.context ? {
+        context
+      } : {}),
+      ...(stateChanged ? {
+        _nodes: [this.root, targetNode]
+      } : {})
+    });
   }
 
   /**
@@ -557,6 +651,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.
@@ -580,9 +717,9 @@ class StateMachine {
         spawn,
         input: initEvent.input,
         self: actorScope.self,
-        actors: this.implementations.actors
+        actorSources: this.implementations.actorSources
       });
-      const nextState = resolveAndExecuteActionsWithContext(preInitial, initEvent, actorScope, []);
+      const [nextState] = resolveActionsWithContext(preInitial, initEvent, actorScope, []);
       if (resolvedContext) {
         nextState.context = resolvedContext;
       }
@@ -602,14 +739,33 @@ class StateMachine {
    * `ActorRef`.
    */
   getInitialSnapshot(actorScope, input) {
+    return this.initialTransition(input, actorScope)[0];
+  }
+  initialTransition(input, actorScope) {
     const initEvent = createInitEvent(input); // TODO: fix;
     const internalQueue = [];
     const preInitialState = this._getPreInitialState(actorScope, initEvent);
-    const [nextState] = initialMicrostep(this.root, preInitialState, actorScope, initEvent, internalQueue);
-    const {
-      snapshot: macroState
-    } = macrostep(nextState, initEvent, actorScope, internalQueue);
-    return macroState;
+    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, this._collectEffects(microsteps, initialActions)];
   }
   start(snapshot) {
     // Start rehydrated children that were active when persisted. Freshly
@@ -663,7 +819,7 @@ class StateMachine {
         syncSnapshot: actorData.syncSnapshot,
         snapshot: childState,
         src,
-        systemId: actorData.systemId
+        registryKey: actorData.registryKey
       });
       // Mark so `start()` knows to start this child (freshly invoked/spawned
       // children are started via deferred `@xstate.start` actions instead).
@@ -710,7 +866,8 @@ class StateMachine {
       children,
       _nodes: nodes,
       value: snapshotData.value,
-      historyValue: revivedHistoryValue
+      historyValue: revivedHistoryValue,
+      _stateInputs: snapshotData.stateInputs ?? {}
     }, this);
     const seen = new WeakSet();
     function reviveContext(contextPart) {

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

@@ -1,5 +1,14 @@
-import type { AnyMachineSnapshot, AnyStateMachine, EventObject, HistoryValue, MachineContext, StateConfig, StateValue, AnyActorRef, Snapshot, MetaObject, StateSchema, StateId, StateIdInputs, StateContextFromStateValue, SnapshotStatus, AnyStateNode } from "./types.js";
+import type { AnyMachineSnapshot, AnyStateMachine, EventObject, HistoryValue, MachineContext, StateConfig, StateValue, StateValueMap, AnyActorRef, Snapshot, MetaObject, StateSchema, StateId, StateIdInputs, StateContextFromStateValue, SnapshotStatus, AnyStateNode } from "./types.js";
 export declare function isMachineSnapshot(value: unknown): value is AnyMachineSnapshot;
+type Values<T> = T[keyof T];
+type MatchingObjectStateValue<TStateValue extends Record<string, unknown>, TTestStateValue extends Record<string, unknown>> = false extends Values<{
+    [K in keyof TTestStateValue]: K extends keyof TStateValue ? NonNullable<TStateValue[K]> extends StateValue ? NonNullable<TTestStateValue[K]> extends StateValue ? [
+        MatchingStateValue<NonNullable<TStateValue[K]>, NonNullable<TTestStateValue[K]>>
+    ] extends [never] ? false : true : false : false : false;
+}> ? never : {
+    [K in keyof TStateValue]: K extends keyof TTestStateValue ? MatchingStateValue<NonNullable<TStateValue[K]>, NonNullable<TTestStateValue[K]>> : TStateValue[K];
+};
+type MatchingStateValue<TStateValue extends StateValue, TTestStateValue extends StateValue> = StateValue extends TTestStateValue ? TStateValue : string extends TTestStateValue ? TStateValue : TStateValue extends unknown ? TTestStateValue extends string ? TStateValue extends string ? TTestStateValue extends TStateValue ? TTestStateValue : Extract<TStateValue, TTestStateValue> : TStateValue extends Record<string, unknown> ? TStateValue & Record<TTestStateValue, StateValue | undefined> : never : TTestStateValue extends Record<string, unknown> ? TStateValue extends Record<string, unknown> ? MatchingObjectStateValue<TStateValue, TTestStateValue> : never : never : never;
 interface MachineSnapshotBase<TContext extends MachineContext, TEvent extends EventObject, TChildren extends Record<string, AnyActorRef | undefined>, TStateValue extends StateValue, TTag extends string, _TOutput, TMeta extends MetaObject, TStateSchema extends StateSchema = StateSchema> {
     /** The state machine that produced this state snapshot. */
     machine: AnyStateMachine;
@@ -42,7 +51,9 @@ interface MachineSnapshotBase<TContext extends MachineContext, TEvent extends Ev
      *
      * @param partialStateValue
      */
-    matches<const TTestStateValue extends StateValue>(partialStateValue: TTestStateValue): this is MachineSnapshot<StateContextFromStateValue<TStateSchema, TContext, TTestStateValue>, TEvent, TChildren, TStateValue, TTag, _TOutput, TMeta, TStateSchema>;
+    matches<const TTestStateValue extends string>(partialStateValue: TTestStateValue, ...args: string extends TTestStateValue ? [never] : []): this is MachineSnapshot<StateContextFromStateValue<TStateSchema, TContext, TTestStateValue>, TEvent, TChildren, MatchingStateValue<TStateValue, TTestStateValue>, TTag, _TOutput, TMeta, TStateSchema>;
+    matches<const TTestStateValue extends StateValueMap>(partialStateValue: TTestStateValue, ...args: string extends keyof TTestStateValue ? [never] : []): this is MachineSnapshot<StateContextFromStateValue<TStateSchema, TContext, TTestStateValue>, TEvent, TChildren, MatchingStateValue<TStateValue, TTestStateValue>, TTag, _TOutput, TMeta, TStateSchema>;
+    matches(partialStateValue: StateValue): boolean;
     /**
      * Whether the current state nodes has a state node with the specified `tag`.
      *

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

@@ -1,17 +1,23 @@
 import { MachineSnapshot } from "./State.js";
 import { StateNode } from "./StateNode.js";
 import { AnyActorSystem } from "./system.js";
-import type { ActorLogic, ActorScope, AnyActor, AnyActorRef, AnyActorScope, AnyTransitionDefinition, Equals, EventDescriptor, EventObject, HistoryValue, MachineContext, MetaObject, Snapshot, StateValue, StateSchema, SnapshotStatus } from "./types.js";
-import { Implementations, Next_MachineConfig, MachineOptions } from "./types.v6.js";
-export declare class StateMachine<TContext extends MachineContext, TEvent extends EventObject, TChildren extends Record<string, AnyActorRef | undefined>, TStateValue extends StateValue, TTag extends string, TInput, TOutput, TEmitted extends EventObject, TMeta extends MetaObject, TConfig extends StateSchema, TActionMap extends Implementations['actions'], TActorMap extends Implementations['actors'], TGuardMap extends Implementations['guards'], TDelayMap extends Implementations['delays']> implements ActorLogic<MachineSnapshot<TContext, TEvent, TChildren, TStateValue, TTag, TOutput, TMeta, TConfig>, TEvent, TInput, AnyActorSystem, TEmitted> {
+import type { ActorLogic, ActorLogicTransitionResult, ActorScope, AnyActor, AnyActorLogic, AnyActorRef, AnyActorScope, AnyTransitionDefinition, Equals, EventDescriptor, EmittedFrom, EventObject, EventFromLogic, ExecutableActionObjectFromLogic, HistoryValue, InputFrom, IsAny, MachineContext, MetaObject, OutputFrom, Snapshot, SnapshotFrom, StateValue, StateSchema, SnapshotStatus } from "./types.js";
+import { AnyMachineSchemas, Implementations, Next_MachineConfig, MachineOptions } from "./types.v6.js";
+type CompatibleProvidedActorSource<TExpected extends AnyActorLogic, TActual extends AnyActorLogic> = IsAny<TActual> extends true ? TActual : [OutputFrom<TActual>] extends [OutputFrom<TExpected>] ? [Omit<SnapshotFrom<TActual>, 'input'>] extends [
+    Omit<SnapshotFrom<TExpected>, 'input'>
+] ? [InputFrom<TExpected>] extends [InputFrom<TActual>] ? [EventFromLogic<TExpected>] extends [EventFromLogic<TActual>] ? [EmittedFrom<TActual>] extends [EmittedFrom<TExpected>] ? TActual : never : never : never : never : never;
+type ProvidedActorSources<TExpectedActorMap extends Implementations['actorSources'], TProvidedActorMap extends Partial<Record<keyof TExpectedActorMap & string, AnyActorLogic>>> = {
+    [K in keyof TProvidedActorMap]: K extends keyof TExpectedActorMap ? TProvidedActorMap[K] extends AnyActorLogic ? CompatibleProvidedActorSource<TExpectedActorMap[K], TProvidedActorMap[K]> : never : never;
+};
+export declare class StateMachine<TContext extends MachineContext, TEvent extends EventObject, TChildren extends Record<string, AnyActorRef | undefined>, TStateValue extends StateValue, TTag extends string, TInput, TOutput, TEmitted extends EventObject, TMeta extends MetaObject, TConfig extends StateSchema, TActionMap extends Implementations['actions'], TActorMap extends Implementations['actorSources'], TGuardMap extends Implementations['guards'], TDelayMap extends Implementations['delays']> implements ActorLogic<MachineSnapshot<TContext, TEvent, TChildren, TStateValue, TTag, TOutput, TMeta, TConfig>, TEvent, TInput, AnyActorSystem, TEmitted> {
     /** The raw config used to create the machine. */
-    config: Next_MachineConfig<any, any, any, any, any, any, any, any, any, any> & {
-        schemas?: unknown;
+    config: Next_MachineConfig<any, any, any, any, any, any, any, any, any, any, any> & {
+        schemas?: AnyMachineSchemas;
         internalEvents?: readonly string[];
     };
     /** The machine's own version. */
     version?: string;
-    schemas: unknown;
+    schemas: AnyMachineSchemas | undefined;
     implementations: Implementations;
     /** Runtime options for machine execution. */
     options: MachineOptions;
@@ -22,20 +28,20 @@ export declare class StateMachine<TContext extends MachineContext, TEvent extend
     internalEventDescriptors: ReadonlyArray<string>;
     constructor(
     /** The raw config used to create the machine. */
-    config: Next_MachineConfig<any, any, any, any, any, any, any, any, any, any> & {
-        schemas?: unknown;
+    config: Next_MachineConfig<any, any, any, any, any, any, any, any, any, any, any> & {
+        schemas?: AnyMachineSchemas;
         internalEvents?: readonly string[];
     }, implementations?: Implementations);
     /**
      * Clones this state machine with the provided implementations.
      *
-     * @param implementations Options (`actions`, `guards`, `actors`, `delays`) to
-     *   recursively merge with the existing options.
+     * @param implementations Options (`actions`, `guards`, `actorSources`,
+     *   `delays`) to recursively merge with the existing options.
      * @returns A new `StateMachine` instance with the provided implementations.
      */
-    provide(implementations: {
+    provide<const TProvidedActorMap extends Partial<Record<keyof TActorMap & string, AnyActorLogic>> = {}>(implementations: {
         actions?: Partial<TActionMap>;
-        actors?: Partial<TActorMap>;
+        actorSources?: TProvidedActorMap & ProvidedActorSources<TActorMap, TProvidedActorMap>;
         guards?: Partial<TGuardMap>;
         delays?: Partial<TDelayMap>;
     }): StateMachine<TContext, TEvent, TChildren, TStateValue, TTag, TInput, TOutput, TEmitted, TMeta, TConfig, TActionMap, TActorMap, TGuardMap, TDelayMap>;
@@ -56,7 +62,9 @@ export declare class StateMachine<TContext extends MachineContext, TEvent extend
      * @param snapshot The current snapshot
      * @param event The received event
      */
-    transition(snapshot: MachineSnapshot<TContext, TEvent, TChildren, TStateValue, TTag, TOutput, TMeta, TConfig>, event: TEvent, actorScope: ActorScope<typeof snapshot, TEvent, AnyActorSystem, TEmitted>): MachineSnapshot<TContext, TEvent, TChildren, TStateValue, TTag, TOutput, TMeta, TConfig>;
+    transition(snapshot: MachineSnapshot<TContext, TEvent, TChildren, TStateValue, TTag, TOutput, TMeta, TConfig>, event: TEvent, actorScope: ActorScope<typeof snapshot, TEvent, AnyActorSystem, TEmitted>): ActorLogicTransitionResult<MachineSnapshot<TContext, TEvent, TChildren, TStateValue, TTag, TOutput, TMeta, TConfig>, ExecutableActionObjectFromLogic<this>>;
+    private _collectEffects;
+    private _transitionFast;
     /**
      * Determines the next state given the current `state` and `event`. Calculates
      * a microstep.
@@ -72,8 +80,10 @@ export declare class StateMachine<TContext extends MachineContext, TEvent extend
      * `ActorRef`.
      */
     getInitialSnapshot(actorScope: ActorScope<MachineSnapshot<TContext, TEvent, TChildren, TStateValue, TTag, TOutput, TMeta, TConfig>, TEvent, AnyActorSystem, TEmitted>, input?: TInput): MachineSnapshot<TContext, TEvent, TChildren, TStateValue, TTag, TOutput, TMeta, TConfig>;
+    initialTransition(input: TInput | undefined, actorScope: ActorScope<MachineSnapshot<TContext, TEvent, TChildren, TStateValue, TTag, TOutput, TMeta, TConfig>, TEvent, AnyActorSystem, TEmitted>): ActorLogicTransitionResult<MachineSnapshot<TContext, TEvent, TChildren, TStateValue, TTag, TOutput, TMeta, TConfig>, ExecutableActionObjectFromLogic<this>>;
     start(snapshot?: MachineSnapshot<TContext, TEvent, TChildren, TStateValue, TTag, TOutput, TMeta, TConfig>): void;
     getStateNodeById(stateId: string): StateNode<TContext, TEvent>;
     getPersistedSnapshot(snapshot: MachineSnapshot<TContext, TEvent, TChildren, TStateValue, TTag, TOutput, TMeta, TConfig>, options?: unknown): Snapshot<unknown>;
     restoreSnapshot(snapshot: Snapshot<unknown>, _actorScope: ActorScope<MachineSnapshot<TContext, TEvent, TChildren, TStateValue, TTag, TOutput, TMeta, TConfig>, TEvent, AnyActorSystem, TEmitted>): MachineSnapshot<TContext, TEvent, TChildren, TStateValue, TTag, TOutput, TMeta, TConfig>;
 }
+export {};

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

@@ -1,5 +1,6 @@
 import { AnyActor, AnyActorScope, EventObject } from "./types.js";
 export declare const builtInActions: {
+    "@xstate.spawn": (_actor: AnyActor) => void;
     "@xstate.start": (actor: AnyActor) => void;
     "@xstate.raise": (actorScope: AnyActorScope, event: EventObject, options: {
         id?: string;
@@ -10,5 +11,5 @@ export declare const builtInActions: {
         delay?: number;
     }) => void;
     "@xstate.cancel": (actorScope: AnyActorScope, sendId: string) => void;
-    "@xstate.stopChild": (actorScope: AnyActorScope, actor: AnyActor) => void;
+    "@xstate.stop": (actorScope: AnyActorScope, actor: AnyActor) => void;
 };

package/dist/declarations/src/actors/promise.d.ts

@@ -41,6 +41,7 @@ export interface LogicEnqueue<TEmitted extends EventObject> {
     step: <TStepOutput>(key: string, exec: () => TStepOutput | PromiseLike<TStepOutput>) => Promise<TStepOutput>;
 }
 export type LogicFunction<TOutput, TInput = NonReducibleUnknown, TEmitted extends EventObject = EventObject> = (args: LogicArgs<TOutput, TInput>, enq: LogicEnqueue<TEmitted>) => PromiseLike<TOutput>;
+type AsyncLogicFunctionOutput<TLogicFunction extends (...args: any[]) => PromiseLike<any>> = Awaited<ReturnType<TLogicFunction>>;
 export interface LogicConfig<TOutput, TInput = NonReducibleUnknown, TEmitted extends EventObject = EventObject, TInputSchema extends StandardSchemaV1 = StandardSchemaV1, TOutputSchema extends StandardSchemaV1 = StandardSchemaV1> {
     /**
      * Stable identifier for this async logic. This identifies the logic, not a
@@ -165,12 +166,13 @@ export declare function createAsyncLogic<const TInputSchema extends StandardSche
 }): AsyncActorLogic<StandardSchemaV1.InferOutput<TOutputSchema>, StandardSchemaV1.InferOutput<TInputSchema>, TEmitted> & {
     id?: string;
 };
-export declare function createAsyncLogic<TOutput, const TInputSchema extends StandardSchemaV1, TEmitted extends EventObject = EventObject>(asyncLogic: LogicConfig<TOutput, StandardSchemaV1.InferOutput<TInputSchema>, TEmitted, TInputSchema> & {
+export declare function createAsyncLogic<const TInputSchema extends StandardSchemaV1, TEmitted extends EventObject = EventObject, TLogicFunction extends LogicFunction<any, StandardSchemaV1.InferOutput<TInputSchema>, TEmitted> = LogicFunction<any, StandardSchemaV1.InferOutput<TInputSchema>, TEmitted>>(asyncLogic: Omit<LogicConfig<never, StandardSchemaV1.InferOutput<TInputSchema>, TEmitted, TInputSchema>, 'run' | 'schemas'> & {
     schemas: {
         input: TInputSchema;
         output?: never;
     };
-}): AsyncActorLogic<TOutput, StandardSchemaV1.InferOutput<TInputSchema>, TEmitted> & {
+    run: TLogicFunction;
+}): AsyncActorLogic<AsyncLogicFunctionOutput<TLogicFunction>, StandardSchemaV1.InferOutput<TInputSchema>, TEmitted> & {
     id?: string;
 };
 export declare function createAsyncLogic<const TOutputSchema extends StandardSchemaV1, TInput = NonReducibleUnknown, TEmitted extends EventObject = EventObject>(asyncLogic: LogicConfig<StandardSchemaV1.InferOutput<TOutputSchema>, TInput, TEmitted, StandardSchemaV1, TOutputSchema> & {

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

@@ -1,6 +1,6 @@
 import { symbolObservable } from "./symbolObservable.js";
 import { AnyActorSystem, Clock } from "./system.js";
-import type { AnyActor, AnyActorLogic, EmittedFrom, EventFromLogic, SendableEventFromLogic, InputFrom, Snapshot, SnapshotFrom, Readable } from "./types.js";
+import type { ActorTrigger, AnyActor, AnyActorLogic, EmittedFrom, EventFromLogic, SendableEventFromLogic, InputFrom, Snapshot, SnapshotFrom, Readable } from "./types.js";
 import { ActorOptions, ActorInstance, ActorRef, InteropSubscribable, Observer, Subscription } from "./types.js";
 export declare const $$ACTOR_TYPE = 1;
 export declare enum ProcessingStatus {
@@ -35,21 +35,17 @@ export declare class Actor<TLogic extends AnyActorLogic> implements ActorInstanc
     private observers;
     private eventListeners;
     private logger;
+    private _forceDeferredActions;
     _parent?: AnyActor;
     ref: ActorRef<SnapshotFrom<TLogic>, EventFromLogic<TLogic>, EmittedFrom<TLogic>, SendableEventFromLogic<TLogic>>;
     private _actorScope;
-    systemId: string | undefined;
+    private _initialEffects;
+    registryKey: string | undefined;
     /** The globally unique process ID for this invocation. */
     sessionId: string;
     /** The system to which this actor belongs. */
     system: AnyActorSystem;
-    trigger: {
-        [K in SendableEventFromLogic<TLogic>['type']]: {} extends Omit<Extract<SendableEventFromLogic<TLogic>, {
-            type: K;
-        }>, 'type'> ? () => void : (payload: Omit<Extract<SendableEventFromLogic<TLogic>, {
-            type: K;
-        }>, 'type'>) => void;
-    };
+    trigger: ActorTrigger<SendableEventFromLogic<TLogic>>;
     src: string | AnyActorLogic;
     /**
      * Creates a new actor instance for the given logic with the provided options,
@@ -62,8 +58,12 @@ export declare class Actor<TLogic extends AnyActorLogic> implements ActorInstanc
     private _deferred;
     private _pendingEffects?;
     private _setErrorSnapshot;
+    /** Recover via the logic's error event if possible; otherwise error out. */
+    private _recoverOrError;
+    private _tryHandleExecutionError;
     private _next;
     private update;
+    private _flushInitialEffects;
     /**
      * Subscribe an observer to an actor’s snapshot values.
      *
@@ -177,8 +177,6 @@ export declare class Actor<TLogic extends AnyActorLogic> implements ActorInstanc
      * @see {@link Actor.getPersistedSnapshot} to persist the internal state of an actor (which is more than just a snapshot).
      */
     getSnapshot(): SnapshotFrom<TLogic>;
-    /** Read the actor's current snapshot as an atom value. */
-    get(): SnapshotFrom<TLogic>;
 }
 export type RequiredActorOptionsKeys<TLogic extends AnyActorLogic> = undefined extends InputFrom<TLogic> ? never : 'input';
 /**