xstate 6.0.0-alpha.3 → 6.0.0-alpha.4

package/dist/{StateMachine-e1048cd6.cjs.js → StateMachine-445a8480.cjs.js}

@@ -1,6 +1,6 @@
 'use strict';
 
-var dist_xstateActors = require('./index-dda021d5.cjs.js');
+var dist_xstateActors = require('./index-918ab496.cjs.js');
 
 function createSpawner(actorScope, {
   machine,
@@ -438,6 +438,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);
@@ -513,7 +514,11 @@ class StateMachine {
    * @param event The received event
    */
   transition(snapshot, event, actorScope) {
-    return dist_xstateActors.macrostep(snapshot, event, actorScope, []).snapshot;
+    const {
+      snapshot: nextSnapshot,
+      microsteps
+    } = dist_xstateActors.macrostep(snapshot, event, actorScope, []);
+    return [nextSnapshot, microsteps.flatMap(([, actions]) => actions)];
   }
 
   /**
@@ -570,7 +575,7 @@ class StateMachine {
         self: actorScope.self,
         actors: this.implementations.actors
       });
-      const nextState = dist_xstateActors.resolveAndExecuteActionsWithContext(preInitial, initEvent, actorScope, []);
+      const [nextState] = dist_xstateActors.resolveActionsWithContext(preInitial, initEvent, actorScope, []);
       if (resolvedContext) {
         nextState.context = resolvedContext;
       }
@@ -590,14 +595,18 @@ class StateMachine {
    * `ActorRef`.
    */
   getInitialSnapshot(actorScope, input) {
+    return this.initialTransition(input, actorScope)[0];
+  }
+  initialTransition(input, actorScope) {
     const initEvent = dist_xstateActors.createInitEvent(input); // TODO: fix;
     const internalQueue = [];
     const preInitialState = this._getPreInitialState(actorScope, initEvent);
-    const [nextState] = dist_xstateActors.initialMicrostep(this.root, preInitialState, actorScope, initEvent, internalQueue);
+    const [nextState, initialActions] = dist_xstateActors.initialMicrostep(this.root, preInitialState, actorScope, initEvent, internalQueue);
     const {
-      snapshot: macroState
+      snapshot: macroState,
+      microsteps
     } = dist_xstateActors.macrostep(nextState, initEvent, actorScope, internalQueue);
-    return macroState;
+    return [macroState, [...initialActions, ...microsteps.flatMap(([, actions]) => actions)]];
   }
   start(snapshot) {
     // Start rehydrated children that were active when persisted. Freshly

package/dist/{StateMachine-e6ad61d0.development.esm.js → StateMachine-4deb4090.development.esm.js}

@@ -1,4 +1,4 @@
-import { P as ProcessingStatus, B as resolveReferencedActor, c as createActor, S as STATE_DELIMITER, C as mapValues, t as toArray, D as createInvokeId, E as getDelayedTransitions, F as evaluateCandidate, G as formatTransition, N as NULL_EVENT, H as toTransitionConfigArray, I as createInvokeTimeoutEvent, J as getCandidates, K as formatRouteTransitions, L as resolveStateValue, M as getAllStateNodes, f as getStateNodes, O as createMachineSnapshot, Q as isInFinalState, a as macrostep, R as transitionNode, m as matchesEventDescriptor, U as resolveAndExecuteActionsWithContext, b as createInitEvent, d as initialMicrostep, V as toStatePath, W as isStateId, X as getStateNodeByPath, Y as getPersistedSnapshot, $ as $$ACTOR_TYPE } from './index-66ff64a6.development.esm.js';
+import { P as ProcessingStatus, C as resolveReferencedActor, c as createActor, S as STATE_DELIMITER, D as mapValues, t as toArray, E as createInvokeId, F as getDelayedTransitions, G as evaluateCandidate, H as formatTransition, N as NULL_EVENT, I as toTransitionConfigArray, J as createInvokeTimeoutEvent, K as getCandidates, L as formatRouteTransitions, M as resolveStateValue, O as getAllStateNodes, f as getStateNodes, Q as createMachineSnapshot, R as isInFinalState, a as macrostep, U as transitionNode, m as matchesEventDescriptor, V as resolveActionsWithContext, b as createInitEvent, d as initialMicrostep, W as toStatePath, X as isStateId, Y as getStateNodeByPath, Z as getPersistedSnapshot, $ as $$ACTOR_TYPE } from './index-ccbe7c0b.development.esm.js';
 
 function createSpawner(actorScope, {
   machine,
@@ -447,6 +447,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);
@@ -525,7 +526,11 @@ class StateMachine {
    * @param event The received event
    */
   transition(snapshot, event, actorScope) {
-    return macrostep(snapshot, event, actorScope, []).snapshot;
+    const {
+      snapshot: nextSnapshot,
+      microsteps
+    } = macrostep(snapshot, event, actorScope, []);
+    return [nextSnapshot, microsteps.flatMap(([, actions]) => actions)];
   }
 
   /**
@@ -582,7 +587,7 @@ class StateMachine {
         self: actorScope.self,
         actors: this.implementations.actors
       });
-      const nextState = resolveAndExecuteActionsWithContext(preInitial, initEvent, actorScope, []);
+      const [nextState] = resolveActionsWithContext(preInitial, initEvent, actorScope, []);
       if (resolvedContext) {
         nextState.context = resolvedContext;
       }
@@ -602,14 +607,18 @@ 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 [nextState, initialActions] = initialMicrostep(this.root, preInitialState, actorScope, initEvent, internalQueue);
     const {
-      snapshot: macroState
+      snapshot: macroState,
+      microsteps
     } = macrostep(nextState, initEvent, actorScope, internalQueue);
-    return macroState;
+    return [macroState, [...initialActions, ...microsteps.flatMap(([, actions]) => actions)]];
   }
   start(snapshot) {
     // Start rehydrated children that were active when persisted. Freshly

package/dist/{StateMachine-8249d511.esm.js → StateMachine-f310bc72.esm.js}

@@ -1,4 +1,4 @@
-import { P as ProcessingStatus, B as resolveReferencedActor, c as createActor, S as STATE_DELIMITER, C as mapValues, t as toArray, D as createInvokeId, E as getDelayedTransitions, F as evaluateCandidate, G as formatTransition, N as NULL_EVENT, H as toTransitionConfigArray, I as createInvokeTimeoutEvent, J as getCandidates, K as formatRouteTransitions, L as resolveStateValue, M as getAllStateNodes, f as getStateNodes, O as createMachineSnapshot, Q as isInFinalState, a as macrostep, R as transitionNode, m as matchesEventDescriptor, U as resolveAndExecuteActionsWithContext, b as createInitEvent, d as initialMicrostep, V as toStatePath, W as isStateId, X as getStateNodeByPath, Y as getPersistedSnapshot, $ as $$ACTOR_TYPE } from './index-a7e3d8b3.esm.js';
+import { P as ProcessingStatus, C as resolveReferencedActor, c as createActor, S as STATE_DELIMITER, D as mapValues, t as toArray, E as createInvokeId, F as getDelayedTransitions, G as evaluateCandidate, H as formatTransition, N as NULL_EVENT, I as toTransitionConfigArray, J as createInvokeTimeoutEvent, K as getCandidates, L as formatRouteTransitions, M as resolveStateValue, O as getAllStateNodes, f as getStateNodes, Q as createMachineSnapshot, R as isInFinalState, a as macrostep, U as transitionNode, m as matchesEventDescriptor, V as resolveActionsWithContext, b as createInitEvent, d as initialMicrostep, W as toStatePath, X as isStateId, Y as getStateNodeByPath, Z as getPersistedSnapshot, $ as $$ACTOR_TYPE } from './index-9cce3480.esm.js';
 
 function createSpawner(actorScope, {
   machine,
@@ -436,6 +436,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);
@@ -511,7 +512,11 @@ class StateMachine {
    * @param event The received event
    */
   transition(snapshot, event, actorScope) {
-    return macrostep(snapshot, event, actorScope, []).snapshot;
+    const {
+      snapshot: nextSnapshot,
+      microsteps
+    } = macrostep(snapshot, event, actorScope, []);
+    return [nextSnapshot, microsteps.flatMap(([, actions]) => actions)];
   }
 
   /**
@@ -568,7 +573,7 @@ class StateMachine {
         self: actorScope.self,
         actors: this.implementations.actors
       });
-      const nextState = resolveAndExecuteActionsWithContext(preInitial, initEvent, actorScope, []);
+      const [nextState] = resolveActionsWithContext(preInitial, initEvent, actorScope, []);
       if (resolvedContext) {
         nextState.context = resolvedContext;
       }
@@ -588,14 +593,18 @@ 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 [nextState, initialActions] = initialMicrostep(this.root, preInitialState, actorScope, initEvent, internalQueue);
     const {
-      snapshot: macroState
+      snapshot: macroState,
+      microsteps
     } = macrostep(nextState, initEvent, actorScope, internalQueue);
-    return macroState;
+    return [macroState, [...initialActions, ...microsteps.flatMap(([, actions]) => actions)]];
   }
   start(snapshot) {
     // Start rehydrated children that were active when persisted. Freshly

package/dist/{StateMachine-0770ac71.development.cjs.js → StateMachine-f83f01f9.development.cjs.js}

@@ -1,6 +1,6 @@
 'use strict';
 
-var dist_xstateActors = require('./index-269d256d.development.cjs.js');
+var dist_xstateActors = require('./index-ebaf6fd8.development.cjs.js');
 
 function createSpawner(actorScope, {
   machine,
@@ -449,6 +449,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);
@@ -527,7 +528,11 @@ class StateMachine {
    * @param event The received event
    */
   transition(snapshot, event, actorScope) {
-    return dist_xstateActors.macrostep(snapshot, event, actorScope, []).snapshot;
+    const {
+      snapshot: nextSnapshot,
+      microsteps
+    } = dist_xstateActors.macrostep(snapshot, event, actorScope, []);
+    return [nextSnapshot, microsteps.flatMap(([, actions]) => actions)];
   }
 
   /**
@@ -584,7 +589,7 @@ class StateMachine {
         self: actorScope.self,
         actors: this.implementations.actors
       });
-      const nextState = dist_xstateActors.resolveAndExecuteActionsWithContext(preInitial, initEvent, actorScope, []);
+      const [nextState] = dist_xstateActors.resolveActionsWithContext(preInitial, initEvent, actorScope, []);
       if (resolvedContext) {
         nextState.context = resolvedContext;
       }
@@ -604,14 +609,18 @@ class StateMachine {
    * `ActorRef`.
    */
   getInitialSnapshot(actorScope, input) {
+    return this.initialTransition(input, actorScope)[0];
+  }
+  initialTransition(input, actorScope) {
     const initEvent = dist_xstateActors.createInitEvent(input); // TODO: fix;
     const internalQueue = [];
     const preInitialState = this._getPreInitialState(actorScope, initEvent);
-    const [nextState] = dist_xstateActors.initialMicrostep(this.root, preInitialState, actorScope, initEvent, internalQueue);
+    const [nextState, initialActions] = dist_xstateActors.initialMicrostep(this.root, preInitialState, actorScope, initEvent, internalQueue);
     const {
-      snapshot: macroState
+      snapshot: macroState,
+      microsteps
     } = dist_xstateActors.macrostep(nextState, initEvent, actorScope, internalQueue);
-    return macroState;
+    return [macroState, [...initialActions, ...microsteps.flatMap(([, actions]) => actions)]];
   }
   start(snapshot) {
     // Start rehydrated children that were active when persisted. Freshly

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

@@ -1,11 +1,11 @@
 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 type { ActorLogic, ActorLogicTransitionResult, ActorScope, AnyActor, AnyActorRef, AnyActorScope, AnyTransitionDefinition, Equals, EventDescriptor, EventObject, ExecutableActionObjectFromLogic, HistoryValue, MachineContext, MetaObject, Snapshot, StateValue, StateSchema, SnapshotStatus } from "./types.js";
 import { AnyMachineSchemas, 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> {
     /** The raw config used to create the machine. */
-    config: Next_MachineConfig<any, any, any, any, any, any, any, any, any, any> & {
+    config: Next_MachineConfig<any, any, any, any, any, any, any, any, any, any, any> & {
         schemas?: AnyMachineSchemas;
         internalEvents?: readonly string[];
     };
@@ -22,7 +22,7 @@ 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> & {
+    config: Next_MachineConfig<any, any, any, any, any, any, any, any, any, any, any> & {
         schemas?: AnyMachineSchemas;
         internalEvents?: readonly string[];
     }, implementations?: Implementations);
@@ -56,7 +56,7 @@ 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>>;
     /**
      * Determines the next state given the current `state` and `event`. Calculates
      * a microstep.
@@ -72,6 +72,7 @@ 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>;

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

@@ -10,5 +10,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/createActor.d.ts

@@ -35,9 +35,11 @@ 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;
+    private _initialEffects;
     systemId: string | undefined;
     /** The globally unique process ID for this invocation. */
     sessionId: string;
@@ -64,6 +66,7 @@ export declare class Actor<TLogic extends AnyActorLogic> implements ActorInstanc
     private _setErrorSnapshot;
     private _next;
     private update;
+    private _flushInitialEffects;
     /**
      * Subscribe an observer to an actor’s snapshot values.
      *

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

@@ -1,7 +1,8 @@
 import { StandardSchemaV1 } from "./schema.types.js";
 import { StateMachine } from "./StateMachine.js";
-import { AnyActorRef, EventObject, AnyEventObject, Cast, MachineContext, ProvidedActor, StateValue, ToChildren, MetaObject, StateSchema, DoNotInfer, RoutableStateId } from "./types.js";
-import { Implementations, DelayMapFromNames, InferOutput, InferEvents, Next_MachineConfig, Next_StateNodeConfig, ValidateDelayReferences, WidenLiterals, WithDefault } from "./types.v6.js";
+import { AnyActorRef, EventObject, AnyEventObject, Cast, MachineContext, ProvidedActor, StateValue, ToChildren, MetaObject, StateSchema, DoNotInfer, RoutableStateId, Compute } from "./types.js";
+import { Implementations, DelayMapFromNames, InferChildren, InferOutput, InferEvents, Next_MachineConfig, Next_StateNodeConfig, ValidateDelayReferences, WidenLiterals, WithDefault } from "./types.v6.js";
+type MergeChildren<TChildren extends Record<string, AnyActorRef | undefined>, TActor extends ProvidedActor> = [keyof TChildren] extends [never] ? Compute<ToChildren<TActor>> : Compute<TChildren>;
 /**
  * Creates a state machine (statechart) with the given configuration.
  *
@@ -44,19 +45,20 @@ import { Implementations, DelayMapFromNames, InferOutput, InferEvents, Next_Mach
  * @param options DEPRECATED: use `setup({ ... })` or `machine.provide({ ... })`
  *   to provide machine implementations instead.
  */
-export declare function createMachine<TContextSchema extends StandardSchemaV1, const TEventSchemaMap extends Record<string, StandardSchemaV1>, TEmittedSchemaMap extends Record<string, StandardSchemaV1>, TInputSchema extends StandardSchemaV1, TOutputSchema extends StandardSchemaV1, TMetaSchema extends StandardSchemaV1, TTagSchema extends StandardSchemaV1, _TEvent extends EventObject, TActor extends ProvidedActor, TActionMap extends Implementations['actions'], TActorMap extends Implementations['actors'], TGuardMap extends Implementations['guards'], TDelayMap extends Implementations['delays'], TDelays extends string, TTag extends StandardSchemaV1.InferOutput<TTagSchema> & string, TInput, const TSS extends StateSchema>(config: TSS & ValidateDelayReferences<TSS> & Next_MachineConfig<TContextSchema, TEventSchemaMap, TEmittedSchemaMap, TInputSchema, TOutputSchema, TMetaSchema, TTagSchema, InferOutput<TContextSchema, MachineContext>, InferEvents<TEventSchemaMap>, TDelays, TTag, TActionMap, TActorMap, TGuardMap, TDelayMap> & {
+export declare function createMachine<TContextSchema extends StandardSchemaV1, const TEventSchemaMap extends Record<string, StandardSchemaV1>, TEmittedSchemaMap extends Record<string, StandardSchemaV1>, TInputSchema extends StandardSchemaV1, TOutputSchema extends StandardSchemaV1, TMetaSchema extends StandardSchemaV1, TTagSchema extends StandardSchemaV1, const TChildrenSchemaMap extends Record<string, StandardSchemaV1>, _TEvent extends EventObject, TActor extends ProvidedActor, TActionMap extends Implementations['actions'], TActorMap extends Implementations['actors'], TGuardMap extends Implementations['guards'], TDelayMap extends Implementations['delays'], TDelays extends string, TTag extends StandardSchemaV1.InferOutput<TTagSchema> & string, TInput, const TSS extends StateSchema>(config: TSS & ValidateDelayReferences<TSS> & Next_MachineConfig<TContextSchema, TEventSchemaMap, TEmittedSchemaMap, TInputSchema, TOutputSchema, TMetaSchema, TTagSchema, TChildrenSchemaMap, InferOutput<TContextSchema, MachineContext>, InferEvents<TEventSchemaMap>, Cast<MergeChildren<InferChildren<TChildrenSchemaMap>, TActor>, Record<string, AnyActorRef | undefined>>, TDelays, TTag, TActionMap, TActorMap, TGuardMap, TDelayMap> & {
     schemas: {
         context: TContextSchema;
+        children?: TChildrenSchemaMap;
     };
 }): StateMachine<InferOutput<TContextSchema, MachineContext>, InferEvents<TEventSchemaMap> | ([RoutableStateId<TSS>] extends [never] ? never : {
     type: 'xstate.route';
     to: RoutableStateId<TSS>;
-}), Cast<ToChildren<TActor>, Record<string, AnyActorRef | undefined>>, StateValue, TTag & string, TInput, InferOutput<TOutputSchema, unknown>, WithDefault<InferEvents<TEmittedSchemaMap>, AnyEventObject>, InferOutput<TMetaSchema, MetaObject>, // TMeta
+}), Cast<MergeChildren<InferChildren<TChildrenSchemaMap>, TActor>, Record<string, AnyActorRef | undefined>>, StateValue, TTag & string, TInput, InferOutput<TOutputSchema, unknown>, WithDefault<InferEvents<TEmittedSchemaMap>, AnyEventObject>, InferOutput<TMetaSchema, MetaObject>, // TMeta
 TSS, // TStateSchema
 TActionMap, TActorMap, TGuardMap, DelayMapFromNames<TDelays, TDelayMap>> & {
     states: TSS;
 };
-export declare function createMachine<TContext extends MachineContext = never, const TEventSchemaMap extends Record<string, StandardSchemaV1> = Record<string, StandardSchemaV1>, TEmittedSchemaMap extends Record<string, StandardSchemaV1> = Record<string, StandardSchemaV1>, TInputSchema extends StandardSchemaV1 = StandardSchemaV1, TOutputSchema extends StandardSchemaV1 = StandardSchemaV1, TMetaSchema extends StandardSchemaV1 = StandardSchemaV1, TTagSchema extends StandardSchemaV1 = StandardSchemaV1, _TEvent extends EventObject = EventObject, TActor extends ProvidedActor = ProvidedActor, TActionMap extends Implementations['actions'] = Implementations['actions'], TActorMap extends Implementations['actors'] = Implementations['actors'], TGuardMap extends Implementations['guards'] = Implementations['guards'], TDelayMap extends Implementations['delays'] = Implementations['delays'], TDelays extends string = string, TTag extends StandardSchemaV1.InferOutput<TTagSchema> & string = StandardSchemaV1.InferOutput<TTagSchema> & string, TInput = unknown, const TSS extends StateSchema = StateSchema>(config: TSS & ValidateDelayReferences<TSS> & Next_MachineConfig<StandardSchemaV1, TEventSchemaMap, TEmittedSchemaMap, TInputSchema, TOutputSchema, TMetaSchema, TTagSchema, WidenLiterals<TContext>, InferEvents<TEventSchemaMap>, TDelays, TTag, TActionMap, TActorMap, TGuardMap, TDelayMap, false> & {
+export declare function createMachine<TContext extends MachineContext = never, const TEventSchemaMap extends Record<string, StandardSchemaV1> = Record<string, StandardSchemaV1>, TEmittedSchemaMap extends Record<string, StandardSchemaV1> = Record<string, StandardSchemaV1>, TInputSchema extends StandardSchemaV1 = StandardSchemaV1, TOutputSchema extends StandardSchemaV1 = StandardSchemaV1, TMetaSchema extends StandardSchemaV1 = StandardSchemaV1, TTagSchema extends StandardSchemaV1 = StandardSchemaV1, const TChildrenSchemaMap extends Record<string, StandardSchemaV1> = Record<string, StandardSchemaV1>, _TEvent extends EventObject = EventObject, TActor extends ProvidedActor = ProvidedActor, TActionMap extends Implementations['actions'] = Implementations['actions'], TActorMap extends Implementations['actors'] = Implementations['actors'], TGuardMap extends Implementations['guards'] = Implementations['guards'], TDelayMap extends Implementations['delays'] = Implementations['delays'], TDelays extends string = string, TTag extends StandardSchemaV1.InferOutput<TTagSchema> & string = StandardSchemaV1.InferOutput<TTagSchema> & string, TInput = unknown, const TSS extends StateSchema = StateSchema>(config: TSS & ValidateDelayReferences<TSS> & Next_MachineConfig<StandardSchemaV1, TEventSchemaMap, TEmittedSchemaMap, TInputSchema, TOutputSchema, TMetaSchema, TTagSchema, TChildrenSchemaMap, WidenLiterals<TContext>, InferEvents<TEventSchemaMap>, Cast<MergeChildren<InferChildren<TChildrenSchemaMap>, TActor>, Record<string, AnyActorRef | undefined>>, TDelays, TTag, TActionMap, TActorMap, TGuardMap, TDelayMap, false> & {
     schemas?: {
         context?: never;
     };
@@ -69,10 +71,11 @@ export declare function createMachine<TContext extends MachineContext = never, c
 }): StateMachine<WidenLiterals<TContext>, InferEvents<TEventSchemaMap> | ([RoutableStateId<TSS>] extends [never] ? never : {
     type: 'xstate.route';
     to: RoutableStateId<TSS>;
-}), Cast<ToChildren<TActor>, Record<string, AnyActorRef | undefined>>, StateValue, TTag & string, TInput, InferOutput<TOutputSchema, unknown>, WithDefault<InferEvents<TEmittedSchemaMap>, AnyEventObject>, InferOutput<TMetaSchema, MetaObject>, // TMeta
+}), Cast<MergeChildren<InferChildren<TChildrenSchemaMap>, TActor>, Record<string, AnyActorRef | undefined>>, StateValue, TTag & string, TInput, InferOutput<TOutputSchema, unknown>, WithDefault<InferEvents<TEmittedSchemaMap>, AnyEventObject>, InferOutput<TMetaSchema, MetaObject>, // TMeta
 TSS, // TStateSchema
 TActionMap, TActorMap, TGuardMap, DelayMapFromNames<TDelays, TDelayMap>> & {
     states: TSS;
 };
 export declare function createStateConfig<TContextSchema extends StandardSchemaV1, TEventSchema extends StandardSchemaV1, TEmittedSchema extends StandardSchemaV1, _TInputSchema extends StandardSchemaV1, TOutputSchema extends StandardSchemaV1, TMetaSchema extends StandardSchemaV1, TTagSchema extends StandardSchemaV1, _TEvent extends StandardSchemaV1.InferOutput<TEventSchema> & EventObject, // TODO: consider using a stricter `EventObject` here
-_TActor extends ProvidedActor, TActionMap extends Implementations['actions'], TActorMap extends Implementations['actors'], TGuardMap extends Implementations['guards'], TDelayMap extends Implementations['delays'], TDelays extends string, _TTag extends StandardSchemaV1.InferOutput<TTagSchema> & string, _TInput, const TSS extends StateSchema>(config: TSS & Next_StateNodeConfig<InferOutput<TContextSchema, MachineContext>, DoNotInfer<StandardSchemaV1.InferOutput<TEventSchema> & EventObject>, DoNotInfer<TDelays>, DoNotInfer<StandardSchemaV1.InferOutput<TTagSchema> & string>, DoNotInfer<StandardSchemaV1.InferOutput<TOutputSchema>>, DoNotInfer<StandardSchemaV1.InferOutput<TEmittedSchema> & EventObject>, DoNotInfer<InferOutput<TMetaSchema, MetaObject>>, DoNotInfer<TActionMap>, DoNotInfer<TActorMap>, DoNotInfer<TGuardMap>, DoNotInfer<TDelayMap>>): typeof config;
+_TActor extends ProvidedActor, TActionMap extends Implementations['actions'], TActorMap extends Implementations['actors'], TGuardMap extends Implementations['guards'], TDelayMap extends Implementations['delays'], TDelays extends string, _TTag extends StandardSchemaV1.InferOutput<TTagSchema> & string, _TInput, const TSS extends StateSchema>(config: TSS & Next_StateNodeConfig<InferOutput<TContextSchema, MachineContext>, DoNotInfer<StandardSchemaV1.InferOutput<TEventSchema> & EventObject>, DoNotInfer<TDelays>, DoNotInfer<StandardSchemaV1.InferOutput<TTagSchema> & string>, DoNotInfer<StandardSchemaV1.InferOutput<TOutputSchema>>, DoNotInfer<StandardSchemaV1.InferOutput<TEmittedSchema> & EventObject>, DoNotInfer<InferOutput<TMetaSchema, MetaObject>>, DoNotInfer<Record<string, AnyActorRef | undefined>>, DoNotInfer<TActionMap>, DoNotInfer<TActorMap>, DoNotInfer<TGuardMap>, DoNotInfer<TDelayMap>>): typeof config;
+export {};

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

@@ -1,4 +1,4 @@
-import { EventObject, AnyStateMachine, StateNode, AnyActorLogic, EventFromLogic, Snapshot, InputFrom } from "../index.js";
+import { EventObject, AnyStateMachine, StateNode, AnyActorLogic, EventFromLogic, Snapshot, InputFrom, SnapshotFrom } from "../index.js";
 import type { SerializedSnapshot, StatePath, DirectedGraphNode, TraversalOptions, AnyStateNode, TraversalConfig } from "./types.js";
 /**
  * Returns all state nodes of the given `node`.
@@ -9,8 +9,8 @@ export declare function getStateNodes(stateNode: {
     states: Record<string, AnyStateNode | StateNode<never, EventObject>>;
 }): AnyStateNode[];
 export declare function serializeSnapshot(snapshot: Snapshot<any>): SerializedSnapshot;
-export declare function createDefaultMachineOptions<TMachine extends AnyStateMachine>(machine: TMachine, options?: TraversalOptions<ReturnType<TMachine['transition']>, EventFromLogic<TMachine>, InputFrom<TMachine>>): TraversalOptions<ReturnType<TMachine['transition']>, EventFromLogic<TMachine>, InputFrom<TMachine>>;
+export declare function createDefaultMachineOptions<TMachine extends AnyStateMachine>(machine: TMachine, options?: TraversalOptions<SnapshotFrom<TMachine>, EventFromLogic<TMachine>, InputFrom<TMachine>>): TraversalOptions<SnapshotFrom<TMachine>, EventFromLogic<TMachine>, InputFrom<TMachine>>;
 export declare function createDefaultLogicOptions(): TraversalOptions<any, any, any>;
 export declare function toDirectedGraph(stateMachine: AnyStateNode | AnyStateMachine): DirectedGraphNode;
-export declare function resolveTraversalOptions<TLogic extends AnyActorLogic>(logic: TLogic, traversalOptions?: TraversalOptions<ReturnType<TLogic['transition']>, EventFromLogic<TLogic>, InputFrom<TLogic>>, defaultOptions?: TraversalOptions<ReturnType<TLogic['transition']>, EventFromLogic<TLogic>, InputFrom<TLogic>>): TraversalConfig<ReturnType<TLogic['transition']>, EventFromLogic<TLogic>>;
+export declare function resolveTraversalOptions<TLogic extends AnyActorLogic>(logic: TLogic, traversalOptions?: TraversalOptions<SnapshotFrom<TLogic>, EventFromLogic<TLogic>, InputFrom<TLogic>>, defaultOptions?: TraversalOptions<SnapshotFrom<TLogic>, EventFromLogic<TLogic>, InputFrom<TLogic>>): TraversalConfig<SnapshotFrom<TLogic>, EventFromLogic<TLogic>>;
 export declare function joinPaths<TSnapshot extends Snapshot<unknown>, TEvent extends EventObject>(headPath: StatePath<TSnapshot, TEvent>, tailPath: StatePath<TSnapshot, TEvent>): StatePath<TSnapshot, TEvent>;

package/dist/declarations/src/graph/shortestPaths.d.ts

@@ -1,3 +1,3 @@
-import { AnyActorLogic, EventFromLogic, InputFrom } from "../index.js";
+import { AnyActorLogic, EventFromLogic, InputFrom, SnapshotFrom } from "../index.js";
 import { StatePath, TraversalOptions } from "./types.js";
-export declare function getShortestPaths<TLogic extends AnyActorLogic>(logic: TLogic, options?: TraversalOptions<ReturnType<TLogic['transition']>, EventFromLogic<TLogic>, InputFrom<TLogic>>): Array<StatePath<ReturnType<TLogic['transition']>, EventFromLogic<TLogic>>>;
+export declare function getShortestPaths<TLogic extends AnyActorLogic>(logic: TLogic, options?: TraversalOptions<SnapshotFrom<TLogic>, EventFromLogic<TLogic>, InputFrom<TLogic>>): Array<StatePath<SnapshotFrom<TLogic>, EventFromLogic<TLogic>>>;

package/dist/declarations/src/graph/simplePaths.d.ts

@@ -1,3 +1,3 @@
-import { AnyActorLogic, EventFromLogic, InputFrom } from "../index.js";
+import { AnyActorLogic, EventFromLogic, InputFrom, SnapshotFrom } from "../index.js";
 import { StatePath, TraversalOptions } from "./types.js";
-export declare function getSimplePaths<TLogic extends AnyActorLogic>(logic: TLogic, options?: TraversalOptions<ReturnType<TLogic['transition']>, EventFromLogic<TLogic>, InputFrom<TLogic>>): Array<StatePath<ReturnType<TLogic['transition']>, EventFromLogic<TLogic>>>;
+export declare function getSimplePaths<TLogic extends AnyActorLogic>(logic: TLogic, options?: TraversalOptions<SnapshotFrom<TLogic>, EventFromLogic<TLogic>, InputFrom<TLogic>>): Array<StatePath<SnapshotFrom<TLogic>, EventFromLogic<TLogic>>>;

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

@@ -22,6 +22,7 @@ export * from "./types.js";
 export type { Next_MachineConfig as MachineConfig, Next_StateNodeConfig as StateNodeConfig, Next_InvokeConfig as InvokeConfig, Next_TransitionConfigOrTarget as TransitionConfigOrTarget, Implementations, InferEvents, WidenLiterals } from "./types.v6.js";
 export { getAllOwnEventDescriptors as __unsafe_getAllOwnEventDescriptors, matchesState, checkStateIn, pathToStateValue, toObserver } from "./utils.js";
 export { transition, initialTransition, getMicrosteps, getInitialMicrosteps, getNextTransitions } from "./transition.js";
+export { isBuiltInExecutableAction } from "./transitionActions.js";
 export { waitFor } from "./waitFor.js";
 declare global {
     interface SymbolConstructor {