xstate 6.0.0-alpha.31 → 6.0.0-alpha.33

package/dist/{StateMachine-54d3cf7a.development.esm.js → StateMachine-33eec203.development.esm.js}

@@ -1,4 +1,4 @@
-import { M as setSnapshotActorRef, N as getSnapshotActorRef, O as createSnapshotSystem, q as isMachineSnapshot, h as createActor, S as STATE_DELIMITER, P as mapValues, t as toArray, Q as createInvokeId, R as getDelayedTransitions, U as getEventDescriptorKey, V as evaluateCandidate, W as formatTransition, Y as NULL_EVENT, Z as toTransitionConfigArray, _ as createInvokeTimeoutEventId, $ as getCandidates, a0 as matchesActorSession, a1 as formatRouteTransitions, a2 as resolveStateValue, a3 as getAllStateNodes, s as getStateNodes, a4 as createMachineSnapshot, a5 as isInFinalState, a6 as assertValid, j as macrostep, a7 as cloneMachineSnapshot, a8 as transitionNode, e as XSTATE_TIMER, m as matchesEventDescriptor, a9 as getTransitionResult, aa as hasEffect, ab as createErrorPlatformEvent, r as resolveActionsWithContext, k as createInitEvent, l as createSpawnEffect, n as initialMicrostep, ac as toStatePath, ad as isStateId, ae as getStateNodeByPath, af as getPersistedSnapshot, ag as resolveReferencedActor, ah as createInvokeTimeoutEvent, ai as $$ACTOR_TYPE } from './index-fbe9e986.development.esm.js';
+import { M as setSnapshotActorRef, N as getSnapshotActorRef, O as createSnapshotSystem, q as isMachineSnapshot, h as createActor, S as STATE_DELIMITER, P as mapValues, t as toArray, Q as createInvokeId, R as getDelayedTransitions, U as getEventDescriptorKey, V as getCandidates, W as evaluateCandidate, Y as formatTransition, Z as NULL_EVENT, _ as toTransitionConfigArray, $ as createInvokeTimeoutEventId, a0 as matchesActorSession, a1 as formatRouteTransitions, a2 as resolveStateValue, a3 as getAllStateNodes, s as getStateNodes, a4 as createMachineSnapshot, a5 as isInFinalState, a6 as assertValid, j as macrostep, a7 as cloneMachineSnapshot, a8 as transitionNode, e as XSTATE_TIMER, m as matchesEventDescriptor, a9 as getTransitionResult, aa as hasEffect, ab as createErrorPlatformEvent, r as resolveActionsWithContext, k as createInitEvent, l as createSpawnEffect, n as initialMicrostep, ac as toStatePath, ad as isStateId, ae as getStateNodeByPath, af as getPersistedSnapshot, ag as resolveReferencedActor, ah as createInvokeTimeoutEvent, ai as $$ACTOR_TYPE } from './index-92227865.development.esm.js';
 
 function createSpawner(actorScope, actors, spawnedChildren) {
   return (src, options) => {
@@ -203,6 +203,7 @@ class StateNode {
     this.after = void 0;
     this.events = void 0;
     this.ownEvents = void 0;
+    this._candidateCache = void 0;
     this.parent = options._parent;
     this.key = options._key;
     this.machine = options._machine;
@@ -303,10 +304,15 @@ class StateNode {
   }
 
   /** @internal */
-  next(snapshot, event, self) {
-    const candidates = memo(this, `candidates-${getEventDescriptorKey(event)}`, () => getCandidates(this, event));
+  next(snapshot, event, self, selectionResults) {
+    const descriptorKey = getEventDescriptorKey(event);
+    let candidates = this._candidateCache?.get(descriptorKey);
+    if (!candidates) {
+      candidates = getCandidates(this, event);
+      (this._candidateCache ??= new Map()).set(descriptorKey, candidates);
+    }
     for (const candidate of candidates) {
-      const guardPassed = evaluateCandidate(candidate, event, snapshot, this, self);
+      const guardPassed = evaluateCandidate(candidate, event, snapshot, this, self, selectionResults);
       if (guardPassed) {
         return [candidate];
       }
@@ -563,6 +569,8 @@ class StateMachine {
     this.states = void 0;
     this.events = void 0;
     this.internalEventDescriptors = void 0;
+    /** @internal Skips eventless-selection scans for machines without `always`. */
+    this._hasEventlessTransitions = void 0;
     /**
      * The original JSON definition this machine was created from (set by
      * `createMachineFromConfig`), if any. Used by `serializeMachine` for lossless
@@ -610,6 +618,7 @@ class StateMachine {
     this.root._initialize();
     formatRouteTransitions(this.root);
     this.root._refreshEventMetadata();
+    this._hasEventlessTransitions = Array.from(this.idMap.values()).some(stateNode => !!stateNode.always?.length);
     this.states = this.root.states; // TODO: remove!
     this.events = this.root.events;
   }
@@ -787,8 +796,8 @@ class StateMachine {
     }
     return snapshots;
   }
-  getTransitionData(snapshot, event, self) {
-    return transitionNode(this.root, snapshot.value, snapshot, event, self) || [];
+  getTransitionData(snapshot, event, self, selectionResults) {
+    return transitionNode(this.root, snapshot.value, snapshot, event, self, selectionResults) || [];
   }
   isInternalEventType(eventType) {
     if (eventType === XSTATE_TIMER) {
@@ -860,7 +869,7 @@ class StateMachine {
       _nodes: [this.root],
       children: {},
       status: 'active'
-    }, this, actorScope.self);
+    }, this);
     if (typeof context === 'function') {
       const children = {};
       const spawn = createSpawner(actorScope, this.sources.actors, children);

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

@@ -1,4 +1,4 @@
-import { M as setSnapshotActorRef, N as getSnapshotActorRef, O as createSnapshotSystem, q as isMachineSnapshot, h as createActor, S as STATE_DELIMITER, P as mapValues, t as toArray, Q as createInvokeId, R as getDelayedTransitions, U as getEventDescriptorKey, V as evaluateCandidate, W as formatTransition, Y as NULL_EVENT, Z as toTransitionConfigArray, _ as createInvokeTimeoutEventId, $ as getCandidates, a0 as matchesActorSession, a1 as formatRouteTransitions, a2 as resolveStateValue, a3 as getAllStateNodes, s as getStateNodes, a4 as createMachineSnapshot, a5 as isInFinalState, a6 as assertValid, j as macrostep, a7 as cloneMachineSnapshot, a8 as transitionNode, e as XSTATE_TIMER, m as matchesEventDescriptor, a9 as getTransitionResult, aa as hasEffect, ab as createErrorPlatformEvent, r as resolveActionsWithContext, k as createInitEvent, l as createSpawnEffect, n as initialMicrostep, ac as toStatePath, ad as isStateId, ae as getStateNodeByPath, af as getPersistedSnapshot, ag as resolveReferencedActor, ah as createInvokeTimeoutEvent, ai as $$ACTOR_TYPE } from './index-2b16671f.esm.js';
+import { M as setSnapshotActorRef, N as getSnapshotActorRef, O as createSnapshotSystem, q as isMachineSnapshot, h as createActor, S as STATE_DELIMITER, P as mapValues, t as toArray, Q as createInvokeId, R as getDelayedTransitions, U as getEventDescriptorKey, V as getCandidates, W as evaluateCandidate, Y as formatTransition, Z as NULL_EVENT, _ as toTransitionConfigArray, $ as createInvokeTimeoutEventId, a0 as matchesActorSession, a1 as formatRouteTransitions, a2 as resolveStateValue, a3 as getAllStateNodes, s as getStateNodes, a4 as createMachineSnapshot, a5 as isInFinalState, a6 as assertValid, j as macrostep, a7 as cloneMachineSnapshot, a8 as transitionNode, e as XSTATE_TIMER, m as matchesEventDescriptor, a9 as getTransitionResult, aa as hasEffect, ab as createErrorPlatformEvent, r as resolveActionsWithContext, k as createInitEvent, l as createSpawnEffect, n as initialMicrostep, ac as toStatePath, ad as isStateId, ae as getStateNodeByPath, af as getPersistedSnapshot, ag as resolveReferencedActor, ah as createInvokeTimeoutEvent, ai as $$ACTOR_TYPE } from './index-ab93831d.esm.js';
 
 function createSpawner(actorScope, actors, spawnedChildren) {
   return (src, options) => {
@@ -202,6 +202,7 @@ class StateNode {
     this.after = void 0;
     this.events = void 0;
     this.ownEvents = void 0;
+    this._candidateCache = void 0;
     this.parent = options._parent;
     this.key = options._key;
     this.machine = options._machine;
@@ -302,10 +303,15 @@ class StateNode {
   }
 
   /** @internal */
-  next(snapshot, event, self) {
-    const candidates = memo(this, `candidates-${getEventDescriptorKey(event)}`, () => getCandidates(this, event));
+  next(snapshot, event, self, selectionResults) {
+    const descriptorKey = getEventDescriptorKey(event);
+    let candidates = this._candidateCache?.get(descriptorKey);
+    if (!candidates) {
+      candidates = getCandidates(this, event);
+      (this._candidateCache ??= new Map()).set(descriptorKey, candidates);
+    }
     for (const candidate of candidates) {
-      const guardPassed = evaluateCandidate(candidate, event, snapshot, this, self);
+      const guardPassed = evaluateCandidate(candidate, event, snapshot, this, self, selectionResults);
       if (guardPassed) {
         return [candidate];
       }
@@ -545,6 +551,8 @@ class StateMachine {
     this.states = void 0;
     this.events = void 0;
     this.internalEventDescriptors = void 0;
+    /** @internal Skips eventless-selection scans for machines without `always`. */
+    this._hasEventlessTransitions = void 0;
     /**
      * The original JSON definition this machine was created from (set by
      * `createMachineFromConfig`), if any. Used by `serializeMachine` for lossless
@@ -581,6 +589,7 @@ class StateMachine {
     this.root._initialize();
     formatRouteTransitions(this.root);
     this.root._refreshEventMetadata();
+    this._hasEventlessTransitions = Array.from(this.idMap.values()).some(stateNode => !!stateNode.always?.length);
     this.states = this.root.states; // TODO: remove!
     this.events = this.root.events;
   }
@@ -758,8 +767,8 @@ class StateMachine {
     }
     return snapshots;
   }
-  getTransitionData(snapshot, event, self) {
-    return transitionNode(this.root, snapshot.value, snapshot, event, self) || [];
+  getTransitionData(snapshot, event, self, selectionResults) {
+    return transitionNode(this.root, snapshot.value, snapshot, event, self, selectionResults) || [];
   }
   isInternalEventType(eventType) {
     if (eventType === XSTATE_TIMER) {
@@ -831,7 +840,7 @@ class StateMachine {
       _nodes: [this.root],
       children: {},
       status: 'active'
-    }, this, actorScope.self);
+    }, this);
     if (typeof context === 'function') {
       const children = {};
       const spawn = createSpawner(actorScope, this.sources.actors, children);

package/dist/{StateMachine-73b20de0.development.cjs.js → StateMachine-d3243bd1.development.cjs.js}

@@ -1,6 +1,6 @@
 'use strict';
 
-var dist_xstateActors = require('./index-0317dbd5.development.cjs.js');
+var dist_xstateActors = require('./index-691f27b9.development.cjs.js');
 
 function createSpawner(actorScope, actors, spawnedChildren) {
   return (src, options) => {
@@ -205,6 +205,7 @@ class StateNode {
     this.after = void 0;
     this.events = void 0;
     this.ownEvents = void 0;
+    this._candidateCache = void 0;
     this.parent = options._parent;
     this.key = options._key;
     this.machine = options._machine;
@@ -305,10 +306,15 @@ class StateNode {
   }
 
   /** @internal */
-  next(snapshot, event, self) {
-    const candidates = memo(this, `candidates-${dist_xstateActors.getEventDescriptorKey(event)}`, () => dist_xstateActors.getCandidates(this, event));
+  next(snapshot, event, self, selectionResults) {
+    const descriptorKey = dist_xstateActors.getEventDescriptorKey(event);
+    let candidates = this._candidateCache?.get(descriptorKey);
+    if (!candidates) {
+      candidates = dist_xstateActors.getCandidates(this, event);
+      (this._candidateCache ??= new Map()).set(descriptorKey, candidates);
+    }
     for (const candidate of candidates) {
-      const guardPassed = dist_xstateActors.evaluateCandidate(candidate, event, snapshot, this, self);
+      const guardPassed = dist_xstateActors.evaluateCandidate(candidate, event, snapshot, this, self, selectionResults);
       if (guardPassed) {
         return [candidate];
       }
@@ -565,6 +571,8 @@ class StateMachine {
     this.states = void 0;
     this.events = void 0;
     this.internalEventDescriptors = void 0;
+    /** @internal Skips eventless-selection scans for machines without `always`. */
+    this._hasEventlessTransitions = void 0;
     /**
      * The original JSON definition this machine was created from (set by
      * `createMachineFromConfig`), if any. Used by `serializeMachine` for lossless
@@ -612,6 +620,7 @@ class StateMachine {
     this.root._initialize();
     dist_xstateActors.formatRouteTransitions(this.root);
     this.root._refreshEventMetadata();
+    this._hasEventlessTransitions = Array.from(this.idMap.values()).some(stateNode => !!stateNode.always?.length);
     this.states = this.root.states; // TODO: remove!
     this.events = this.root.events;
   }
@@ -789,8 +798,8 @@ class StateMachine {
     }
     return snapshots;
   }
-  getTransitionData(snapshot, event, self) {
-    return dist_xstateActors.transitionNode(this.root, snapshot.value, snapshot, event, self) || [];
+  getTransitionData(snapshot, event, self, selectionResults) {
+    return dist_xstateActors.transitionNode(this.root, snapshot.value, snapshot, event, self, selectionResults) || [];
   }
   isInternalEventType(eventType) {
     if (eventType === dist_xstateActors.XSTATE_TIMER) {
@@ -862,7 +871,7 @@ class StateMachine {
       _nodes: [this.root],
       children: {},
       status: 'active'
-    }, this, actorScope.self);
+    }, this);
     if (typeof context === 'function') {
       const children = {};
       const spawn = createSpawner(actorScope, this.sources.actors, children);

package/dist/{StateMachine-4e86e818.cjs.js → StateMachine-ff580dd5.cjs.js}

@@ -1,6 +1,6 @@
 'use strict';
 
-var dist_xstateActors = require('./index-85c48a0a.cjs.js');
+var dist_xstateActors = require('./index-9939f02a.cjs.js');
 
 function createSpawner(actorScope, actors, spawnedChildren) {
   return (src, options) => {
@@ -204,6 +204,7 @@ class StateNode {
     this.after = void 0;
     this.events = void 0;
     this.ownEvents = void 0;
+    this._candidateCache = void 0;
     this.parent = options._parent;
     this.key = options._key;
     this.machine = options._machine;
@@ -304,10 +305,15 @@ class StateNode {
   }
 
   /** @internal */
-  next(snapshot, event, self) {
-    const candidates = memo(this, `candidates-${dist_xstateActors.getEventDescriptorKey(event)}`, () => dist_xstateActors.getCandidates(this, event));
+  next(snapshot, event, self, selectionResults) {
+    const descriptorKey = dist_xstateActors.getEventDescriptorKey(event);
+    let candidates = this._candidateCache?.get(descriptorKey);
+    if (!candidates) {
+      candidates = dist_xstateActors.getCandidates(this, event);
+      (this._candidateCache ??= new Map()).set(descriptorKey, candidates);
+    }
     for (const candidate of candidates) {
-      const guardPassed = dist_xstateActors.evaluateCandidate(candidate, event, snapshot, this, self);
+      const guardPassed = dist_xstateActors.evaluateCandidate(candidate, event, snapshot, this, self, selectionResults);
       if (guardPassed) {
         return [candidate];
       }
@@ -547,6 +553,8 @@ class StateMachine {
     this.states = void 0;
     this.events = void 0;
     this.internalEventDescriptors = void 0;
+    /** @internal Skips eventless-selection scans for machines without `always`. */
+    this._hasEventlessTransitions = void 0;
     /**
      * The original JSON definition this machine was created from (set by
      * `createMachineFromConfig`), if any. Used by `serializeMachine` for lossless
@@ -583,6 +591,7 @@ class StateMachine {
     this.root._initialize();
     dist_xstateActors.formatRouteTransitions(this.root);
     this.root._refreshEventMetadata();
+    this._hasEventlessTransitions = Array.from(this.idMap.values()).some(stateNode => !!stateNode.always?.length);
     this.states = this.root.states; // TODO: remove!
     this.events = this.root.events;
   }
@@ -760,8 +769,8 @@ class StateMachine {
     }
     return snapshots;
   }
-  getTransitionData(snapshot, event, self) {
-    return dist_xstateActors.transitionNode(this.root, snapshot.value, snapshot, event, self) || [];
+  getTransitionData(snapshot, event, self, selectionResults) {
+    return dist_xstateActors.transitionNode(this.root, snapshot.value, snapshot, event, self, selectionResults) || [];
   }
   isInternalEventType(eventType) {
     if (eventType === dist_xstateActors.XSTATE_TIMER) {
@@ -833,7 +842,7 @@ class StateMachine {
       _nodes: [this.root],
       children: {},
       status: 'active'
-    }, this, actorScope.self);
+    }, this);
     if (typeof context === 'function') {
       const children = {};
       const spawn = createSpawner(actorScope, this.sources.actors, children);

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

@@ -1,5 +1,6 @@
 import { MachineSnapshot } from "./State.js";
 import { StateNode } from "./StateNode.js";
+import { type TransitionSelectionResults } from "./stateUtils.js";
 import { AnyActorSystem } from "./system.js";
 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, Sources, Next_MachineConfig, MachineOptions } from "./types.v6.js";
@@ -76,7 +77,7 @@ export declare class StateMachine<TContext extends MachineContext, TEvent extend
      * @param event The received event
      */
     microstep(snapshot: MachineSnapshot<TContext, TEvent, TChildren, TStateValue, TTag, TOutput, TMeta, TConfig>, event: TEvent, actorScope: AnyActorScope): Array<MachineSnapshot<TContext, TEvent, TChildren, TStateValue, TTag, TOutput, TMeta, TConfig>>;
-    getTransitionData(snapshot: MachineSnapshot<TContext, TEvent, TChildren, TStateValue, TTag, TOutput, TMeta, TConfig>, event: TEvent, self: AnyActor): Array<AnyTransitionDefinition>;
+    getTransitionData(snapshot: MachineSnapshot<TContext, TEvent, TChildren, TStateValue, TTag, TOutput, TMeta, TConfig>, event: TEvent, self: AnyActor, selectionResults?: TransitionSelectionResults): Array<AnyTransitionDefinition>;
     isInternalEventType(eventType: string): boolean;
     /**
      * Returns the initial `State` instance, with reference to `self` as an

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

@@ -70,6 +70,7 @@ export declare class StateNode<TContext extends MachineContext = MachineContext,
     after: Array<DelayedTransitionDefinition<any, any>>;
     events: Array<EventDescriptor<any>>;
     ownEvents: Array<EventDescriptor<any>>;
+    private _candidateCache?;
     constructor(
     /** The raw config used to create the machine. */
     config: AnyStateNodeConfig, options: StateNodeOptions<TContext, TEvent>);

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

@@ -7,7 +7,7 @@ export { createMachineFromConfig } from "./createMachineFromConfig.js";
 export type { ActionJSON, GuardJSON, InvokeJSON, MachineJSON, StateNodeJSON, TransitionJSON } from "./createMachineFromConfig.js";
 export { machineConfigToJSON, serializeMachine, type CodeExpression } from "./serialize.js";
 export { mapState } from "./mapState.js";
-export { machineVersions, migrateSnapshot, type MachineVersionsOptions, type ParsedPersistedSnapshot, type PersistedMachineIdentity, type PersistedSnapshotDataFrom, type SnapshotMigrationHandlers, type PersistedSnapshotFrom } from "./machineVersions.js";
+export { machineVersions, type MigrateSnapshotOptions, type MachineVersionsOptions, type ParsedPersistedSnapshot, type PersistedMachineIdentity, type PersistedSnapshotDataFrom, type PersistedSnapshotSource, type SnapshotMigrationHandlers, type PersistedSnapshotFrom } from "./machineVersions.js";
 export { types, isTypeSchema, type StandardSchemaV1, type TypeSchema } from "./schema.types.js";
 export type { ActorValidationBoundary, ActorValidationEventOrigin, ActorValidationRequest, ActorLogicValidator } from "./validation.types.js";
 export { createSystem, setup } from "./setup.js";

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

@@ -26,26 +26,30 @@ export type ParsedPersistedSnapshot<TMachines extends readonly AnyStateMachine[]
 export type MachineVersionsOptions<TMachines extends readonly AnyStateMachine[]> = {
     unversioned?: NonNullable<TMachines[number]['version']>;
 };
-type ParsedSnapshotSource = {
-    machine: VersionedStateMachine;
-    snapshot: Snapshot<unknown> & {
-        context: unknown;
-        machine: PersistedMachineIdentity;
-        [key: string]: unknown;
-    };
-};
-type SourceVersion<TSource extends ParsedSnapshotSource> = TSource extends unknown ? NonNullable<TSource['machine']['version']> : never;
-type SourceForVersion<TSource extends ParsedSnapshotSource, TVersion extends string> = TSource extends unknown ? TSource['machine']['version'] extends TVersion ? TSource : never : never;
-export type SnapshotMigrationHandlers<TSource extends ParsedSnapshotSource, TTarget extends AnyStateMachine> = {
-    [TVersion in SourceVersion<TSource>]?: (snapshot: SourceForVersion<TSource, TVersion>['snapshot']) => PersistedSnapshotDataFrom<TTarget>;
+type MaybePromise<T> = T | PromiseLike<T>;
+type MachineVersion<TMachines extends readonly VersionedStateMachine[]> = TMachines[number]['version'];
+type MachineForVersion<TMachines extends readonly VersionedStateMachine[], TVersion extends string> = {
+    [K in keyof TMachines]: TMachines[K] extends VersionedStateMachine ? TMachines[K]['version'] extends TVersion ? TMachines[K] : never : never;
+}[number];
+export type PersistedSnapshotSource = {
+    id?: string;
+    version?: string;
+};
+export type SnapshotMigrationHandlers<TMachines extends readonly VersionedStateMachine[], TTarget extends VersionedStateMachine> = {
+    [TVersion in Exclude<MachineVersion<TMachines>, TTarget['version']>]?: (snapshot: PersistedSnapshotFrom<MachineForVersion<TMachines, TVersion>>) => MaybePromise<PersistedSnapshotDataFrom<TTarget>>;
+} & {
+    '*'?: (snapshot: unknown, source: PersistedSnapshotSource) => MaybePromise<PersistedSnapshotDataFrom<TTarget>>;
+};
+export type MigrateSnapshotOptions<TMachines extends readonly VersionedStateMachine[], TTargetVersion extends MachineVersion<TMachines>> = {
+    to: TTargetVersion;
+    migrations: SnapshotMigrationHandlers<TMachines, MachineForVersion<TMachines, TTargetVersion>>;
 };
 /** Creates parsers backed by retained versions of one machine. */
 export declare function machineVersions<const TMachines extends readonly [
     VersionedStateMachine,
     ...VersionedStateMachine[]
 ]>(machines: TMachines, options?: MachineVersionsOptions<TMachines>): {
-    parseSnapshot(raw: unknown): Promise<ParsedPersistedSnapshot<TMachines>>;
+    parseSnapshot: (raw: unknown) => Promise<ParsedPersistedSnapshot<TMachines>>;
+    migrateSnapshot<TTargetVersion extends MachineVersion<TMachines>>(raw: unknown, migrationOptions: MigrateSnapshotOptions<TMachines, TTargetVersion>): Promise<PersistedSnapshotFrom<MachineForVersion<TMachines, TTargetVersion>>>;
 };
-/** Migrates a parsed persisted snapshot directly to a target machine. */
-export declare function migrateSnapshot<TSource extends ParsedSnapshotSource, TTarget extends VersionedStateMachine>(source: TSource, target: TTarget, migrations: SnapshotMigrationHandlers<TSource, TTarget>): Promise<PersistedSnapshotFrom<TTarget>>;
 export {};

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

@@ -31,7 +31,13 @@ export declare function getStateNodeByPath(stateNode: AnyStateNode, statePath: s
  * @param stateValue The state value or State instance
  */
 export declare function getStateNodes(stateNode: AnyStateNode, stateValue: StateValue): Array<AnyStateNode>;
-export declare function transitionNode<TContext extends MachineContext, TEvent extends EventObject>(stateNode: AnyStateNode, stateValue: StateValue, snapshot: MachineSnapshot<TContext, TEvent, any, any, any, any, any, any>, event: TEvent, self: AnyActor): Array<TransitionDefinition<TContext, TEvent>> | undefined;
+export type TransitionSelectionResult = {
+    enabled: boolean;
+    result: unknown;
+    reusable: boolean;
+};
+export type TransitionSelectionResults = Map<AnyTransitionDefinition, TransitionSelectionResult>;
+export declare function transitionNode<TContext extends MachineContext, TEvent extends EventObject>(stateNode: AnyStateNode, stateValue: StateValue, snapshot: MachineSnapshot<TContext, TEvent, any, any, any, any, any, any>, event: TEvent, self: AnyActor, selectionResults?: TransitionSelectionResults): Array<TransitionDefinition<TContext, TEvent>> | undefined;
 type Microstep = readonly [AnyMachineSnapshot, ExecutableActionObject[]];
 export declare function initialMicrostep(root: AnyStateNode, preInitialState: AnyMachineSnapshot, actorScope: AnyActorScope, initEvent: AnyEventObject, internalQueue: AnyEventObject[]): Microstep;
 /**
@@ -44,6 +50,7 @@ export declare function getTransitionResult(transition: Pick<AnyTransitionDefini
     context?: AnyTransitionDefinition['context'];
 }, snapshot: AnyMachineSnapshot, event: AnyEventObject, actorScope: AnyActorScope, options?: {
     resolveActions?: boolean;
+    selectionResult?: TransitionSelectionResult;
 }): {
     targets: Readonly<AnyStateNode[]> | undefined;
     context: MachineContext | undefined;
@@ -64,5 +71,5 @@ export declare function macrostep(snapshot: AnyMachineSnapshot, event: EventObje
  */
 export declare function resolveStateValue(rootNode: AnyStateNode, stateValue: StateValue): StateValue;
 export declare function hasEffect(transition: AnyTransitionDefinition, context: MachineContext, event: EventObject, snapshot: AnyMachineSnapshot, self: AnyActor): boolean;
-export declare function evaluateCandidate(candidate: AnyTransitionDefinition, event: EventObject, snapshot: AnyMachineSnapshot, stateNode: AnyStateNode, self: AnyActor): boolean;
+export declare function evaluateCandidate(candidate: AnyTransitionDefinition, event: EventObject, snapshot: AnyMachineSnapshot, stateNode: AnyStateNode, self: AnyActor, selectionResults?: TransitionSelectionResults): boolean;
 export {};

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

@@ -351,7 +351,7 @@ export interface AnyStateMachine extends AnyActorLogic {
     schemas?: import("./types.v6.js").AnyMachineSchemas;
     provide(sources: any): AnyStateMachine;
     resolveState(config: any): any;
-    getTransitionData(snapshot: any, event: any, actor: AnyActorRef): AnyTransitionDefinition[];
+    getTransitionData(snapshot: any, event: any, actor: AnyActorRef, selectionResults?: Map<AnyTransitionDefinition, unknown>): AnyTransitionDefinition[];
     getStateNodeById(stateId: string): AnyStateNode;
     getPersistedSnapshot(snapshot: any, options?: unknown): Snapshot<unknown>;
 }