xstate 6.0.0-alpha.50 → 6.0.0-alpha.51

package/README.md

@@ -17,28 +17,33 @@ XState is a state management and orchestration solution for JavaScript and TypeS
 
 It uses event-driven programming, state machines, statecharts, and the actor model to handle complex logic in predictable, robust, and visual ways. XState provides a powerful and flexible way to manage application and workflow state by allowing developers to model logic as actors and state machines.
 
-For flat finite state machines, `xstate/fsm` provides a self-contained compact
-runtime and a specialized actor:
+For flat finite state machines, `xstate/fsm` provides a tiny pure transition
+table with context and TypeScript support:
 
 <!-- public exports from packages/core/src/fsm/index.ts; exact capabilities documented in docs/fsm.md -->
 
 ```ts
-import { createFSM, createFSMActor } from 'xstate/fsm';
+import { createFSM } from 'xstate/fsm';
 
-const logic = createFSM({
+const machine = createFSM({
   initial: 'inactive',
   states: {
-    inactive: { on: { toggle: { target: 'active' } } },
-    active: { on: { toggle: { target: 'inactive' } } }
+    inactive: { on: { toggle: 'active' } },
+    active: { on: { toggle: 'inactive' } }
   }
 });
 
-const actor = createFSMActor(logic).start();
+let state = machine.initialState;
+state = machine.transition(state, { type: 'toggle' });
 ```
 
+For typed context, event payloads, or state-specific context snapshots, use
+`setup` and `types` from `xstate/fsm`. These schemas are type-only in this
+subpath; use root `xstate` for runtime schema validation.
+
 See the [exact supported surface](https://stately.ai/docs/fsm). Use the root `xstate`
 entry point for compound or parallel statecharts, invocation, named sources,
-schemas, serialization and inspection.
+runtime schemas, serialization and inspection.
 
 ### ✨ Create state machines visually in Stately Studio → [state.new](https://state.new)
 

package/dist/{StateMachine-70df737c.development.cjs.js → StateMachine-559e0140.development.cjs.js}

@@ -1,6 +1,6 @@
 'use strict';
 
-var createActor = require('./createActor-ea9a560c.development.cjs.js');
+var createActor = require('./createActor-ae612b26.development.cjs.js');
 var validation = require('./validation-f2714a35.development.cjs.js');
 
 function createSpawner(actorScope, actors, spawnedChildren) {

package/dist/{StateMachine-1e6ee14a.cjs.js → StateMachine-c3c54551.cjs.js}

@@ -1,6 +1,6 @@
 'use strict';
 
-var createActor = require('./createActor-27fd819f.cjs.js');
+var createActor = require('./createActor-a0610101.cjs.js');
 var validation = require('./validation-4561b43c.cjs.js');
 
 function createSpawner(actorScope, actors, spawnedChildren) {

package/dist/{StateMachine-8cea8974.esm.js → StateMachine-c6e2cb9e.esm.js}

@@ -1,4 +1,4 @@
-import { M as resolveRegisteredActorSource, N as allocateChildId, O as assertChildIdFree, P as reserveChildId, S as STATE_DELIMITER, Q as mapValues, t as toArray, R as createInvokeId, T 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, f as getStateNodes, a4 as createMachineSnapshot, a5 as isInFinalState, a6 as createInertActorScope, a7 as setInertActorScopeSnapshot, z as createDeadLetterEffect, a8 as beginSpawnAllocation, a9 as attachSnapshotActorRef, aa as macrostep, ab as isInertActorScope, ac as setSnapshotActorRef, ad as cloneMachineSnapshot, ae as transitionNode, K as XSTATE_TIMER, m as matchesEventDescriptor, af as getTransitionResult, ag as hasEffect, ah as createErrorPlatformEvent, ai as withActorSelf, aj as resolveActionsWithContext, ak as takeSpawnAllocationCounters, al as mergeActorIdCounters, y as createInitEvent, am as createSpawnEffect, an as initialMicrostep, ao as toStatePath, ap as isStateId, aq as getStateNodeByPath, ar as getPersistedSnapshot, as as createRemoteActorRef, at as resolveReferencedActor, au as createInvokeTimeoutEvent, av as parseGeneratedActorId, aw as ACTOR_REF_TYPE, c as createActor } from './createActor-ad3a1abe.esm.js';
+import { J as resolveRegisteredActorSource, K as allocateChildId, L as assertChildIdFree, M as reserveChildId, S as STATE_DELIMITER, N as mapValues, t as toArray, O as createInvokeId, P as getDelayedTransitions, Q as getEventDescriptorKey, R as getCandidates, T as evaluateCandidate, U as formatTransition, V as NULL_EVENT, W as toTransitionConfigArray, Y as createInvokeTimeoutEventId, Z as matchesActorSession, _ as formatRouteTransitions, $ as resolveStateValue, a0 as getAllStateNodes, f as getStateNodes, a1 as createMachineSnapshot, a2 as isInFinalState, a3 as createInertActorScope, a4 as setInertActorScopeSnapshot, z as createDeadLetterEffect, a5 as beginSpawnAllocation, a6 as attachSnapshotActorRef, a7 as macrostep, a8 as isInertActorScope, a9 as setSnapshotActorRef, aa as cloneMachineSnapshot, ab as transitionNode, ac as XSTATE_TIMER, m as matchesEventDescriptor, ad as getTransitionResult, ae as hasEffect, af as createErrorPlatformEvent, ag as withActorSelf, ah as resolveActionsWithContext, ai as takeSpawnAllocationCounters, aj as mergeActorIdCounters, y as createInitEvent, ak as createSpawnEffect, al as initialMicrostep, am as toStatePath, an as isStateId, ao as getStateNodeByPath, ap as getPersistedSnapshot, aq as createRemoteActorRef, ar as resolveReferencedActor, as as createInvokeTimeoutEvent, at as parseGeneratedActorId, au as ACTOR_REF_TYPE, c as createActor } from './createActor-5d4780c4.esm.js';
 import { a as assertValid } from './validation-05f1d517.esm.js';
 
 function createSpawner(actorScope, actors, spawnedChildren) {

package/dist/{StateMachine-bc28e207.development.esm.js → StateMachine-df7199a8.development.esm.js}

@@ -1,4 +1,4 @@
-import { M as resolveRegisteredActorSource, N as allocateChildId, O as assertChildIdFree, P as reserveChildId, S as STATE_DELIMITER, Q as mapValues, t as toArray, R as createInvokeId, T 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, f as getStateNodes, a4 as createMachineSnapshot, a5 as isInFinalState, a6 as createInertActorScope, a7 as setInertActorScopeSnapshot, z as createDeadLetterEffect, a8 as beginSpawnAllocation, a9 as attachSnapshotActorRef, aa as macrostep, ab as isInertActorScope, ac as setSnapshotActorRef, ad as cloneMachineSnapshot, ae as transitionNode, K as XSTATE_TIMER, m as matchesEventDescriptor, af as getTransitionResult, ag as hasEffect, ah as createErrorPlatformEvent, ai as withActorSelf, aj as resolveActionsWithContext, ak as takeSpawnAllocationCounters, al as mergeActorIdCounters, y as createInitEvent, am as createSpawnEffect, an as initialMicrostep, ao as toStatePath, ap as isStateId, aq as getStateNodeByPath, ar as getPersistedSnapshot, as as createRemoteActorRef, at as resolveReferencedActor, au as createInvokeTimeoutEvent, av as parseGeneratedActorId, aw as ACTOR_REF_TYPE, c as createActor } from './createActor-74e185ee.development.esm.js';
+import { J as resolveRegisteredActorSource, K as allocateChildId, L as assertChildIdFree, M as reserveChildId, S as STATE_DELIMITER, N as mapValues, t as toArray, O as createInvokeId, P as getDelayedTransitions, Q as getEventDescriptorKey, R as getCandidates, T as evaluateCandidate, U as formatTransition, V as NULL_EVENT, W as toTransitionConfigArray, Y as createInvokeTimeoutEventId, Z as matchesActorSession, _ as formatRouteTransitions, $ as resolveStateValue, a0 as getAllStateNodes, f as getStateNodes, a1 as createMachineSnapshot, a2 as isInFinalState, a3 as createInertActorScope, a4 as setInertActorScopeSnapshot, z as createDeadLetterEffect, a5 as beginSpawnAllocation, a6 as attachSnapshotActorRef, a7 as macrostep, a8 as isInertActorScope, a9 as setSnapshotActorRef, aa as cloneMachineSnapshot, ab as transitionNode, ac as XSTATE_TIMER, m as matchesEventDescriptor, ad as getTransitionResult, ae as hasEffect, af as createErrorPlatformEvent, ag as withActorSelf, ah as resolveActionsWithContext, ai as takeSpawnAllocationCounters, aj as mergeActorIdCounters, y as createInitEvent, ak as createSpawnEffect, al as initialMicrostep, am as toStatePath, an as isStateId, ao as getStateNodeByPath, ap as getPersistedSnapshot, aq as createRemoteActorRef, ar as resolveReferencedActor, as as createInvokeTimeoutEvent, at as parseGeneratedActorId, au as ACTOR_REF_TYPE, c as createActor } from './createActor-67a1cda3.development.esm.js';
 import { a as assertValid } from './validation-e69470ad.development.esm.js';
 
 function createSpawner(actorScope, actors, spawnedChildren) {

package/dist/{createActor-ad3a1abe.esm.js → createActor-5d4780c4.esm.js}

@@ -2985,6 +2985,7 @@ function microstep(transitions, currentSnapshot, actorScope, event, isInitial, i
             self: actorScope.self,
             context: nextState.context,
             event,
+            input: stateInputMap[stateNodeToEnter.id],
             output: getEventOutput(event)
           }) : invokeDef.input;
           assertChildIdFree(actorScope, invokeDef.id);
@@ -5824,4 +5825,4 @@ function createActor(logic, options) {
   return new Actor(logic, options);
 }
 
-export { createInvokeTimeoutEventId as $, Actor as A, createCustomEffect as B, XSTATE_LOGIC_EFFECT_START as C, XSTATE_LOGIC_EFFECT_RESOLVE as D, XSTATE_LOGIC_EFFECT_REJECT as E, finalizeTransitionResult as F, createEmitEffect as G, createSendToEffect as H, XSTATE_INIT as I, withActorScope as J, XSTATE_TIMER as K, isLazyActorScope as L, resolveRegisteredActorSource as M, allocateChildId as N, assertChildIdFree as O, reserveChildId as P, mapValues as Q, createInvokeId as R, STATE_DELIMITER as S, getDelayedTransitions as T, getEventDescriptorKey as U, getCandidates as V, evaluateCandidate as W, XSTATE_STOP as X, formatTransition as Y, NULL_EVENT as Z, toTransitionConfigArray as _, createListenerLogic as a, matchesActorSession as a0, formatRouteTransitions as a1, resolveStateValue as a2, getAllStateNodes as a3, createMachineSnapshot as a4, isInFinalState as a5, createInertActorScope as a6, setInertActorScopeSnapshot as a7, beginSpawnAllocation as a8, attachSnapshotActorRef as a9, getActorIdPrefix as aA, getAllOwnEvents as aB, matchesEvent as aC, encodeAddressSegment as aD, getRootActorId as aE, RUNTIME_OPERATIONS as aF, withSystemInspector as aG, getSnapshotActorRef as aH, withExecutionIdentity as aI, macrostep as aa, isInertActorScope as ab, setSnapshotActorRef as ac, cloneMachineSnapshot as ad, transitionNode as ae, getTransitionResult as af, hasEffect as ag, createErrorPlatformEvent as ah, withActorSelf as ai, resolveActionsWithContext as aj, takeSpawnAllocationCounters as ak, mergeActorIdCounters as al, createSpawnEffect as am, initialMicrostep as an, toStatePath as ao, isStateId as ap, getStateNodeByPath as aq, getPersistedSnapshot as ar, createRemoteActorRef as as, resolveReferencedActor as at, createInvokeTimeoutEvent as au, parseGeneratedActorId as av, ACTOR_REF_TYPE as aw, hasAmbientInspector as ax, getProperAncestors as ay, isRemoteActorRef as az, createSubscriptionLogic as b, createActor as c, getNextSnapshot as d, isMachineSnapshot as e, getStateNodes as f, getInitialSnapshot as g, getAllOwnEventDescriptors as h, isAtomicStateNode as i, matchesState as j, checkStateIn as k, listenerLogic as l, matchesEventDescriptor as m, pathToStateValue as n, toObserver as o, parseDelayToMilliseconds as p, executeEffects as q, isBuiltInExecutableAction as r, subscriptionLogic as s, toArray as t, deliverEvent as u, runStep as v, stopActor as w, terminateActor as x, createInitEvent as y, createDeadLetterEffect as z };
+export { resolveStateValue as $, Actor as A, createCustomEffect as B, XSTATE_LOGIC_EFFECT_START as C, XSTATE_LOGIC_EFFECT_RESOLVE as D, XSTATE_LOGIC_EFFECT_REJECT as E, finalizeTransitionResult as F, createEmitEffect as G, createSendToEffect as H, XSTATE_INIT as I, resolveRegisteredActorSource as J, allocateChildId as K, assertChildIdFree as L, reserveChildId as M, mapValues as N, createInvokeId as O, getDelayedTransitions as P, getEventDescriptorKey as Q, getCandidates as R, STATE_DELIMITER as S, evaluateCandidate as T, formatTransition as U, NULL_EVENT as V, toTransitionConfigArray as W, XSTATE_STOP as X, createInvokeTimeoutEventId as Y, matchesActorSession as Z, formatRouteTransitions as _, createListenerLogic as a, getAllStateNodes as a0, createMachineSnapshot as a1, isInFinalState as a2, createInertActorScope as a3, setInertActorScopeSnapshot as a4, beginSpawnAllocation as a5, attachSnapshotActorRef as a6, macrostep as a7, isInertActorScope as a8, setSnapshotActorRef as a9, matchesEvent as aA, encodeAddressSegment as aB, getRootActorId as aC, RUNTIME_OPERATIONS as aD, withSystemInspector as aE, getSnapshotActorRef as aF, withExecutionIdentity as aG, cloneMachineSnapshot as aa, transitionNode as ab, XSTATE_TIMER as ac, getTransitionResult as ad, hasEffect as ae, createErrorPlatformEvent as af, withActorSelf as ag, resolveActionsWithContext as ah, takeSpawnAllocationCounters as ai, mergeActorIdCounters as aj, createSpawnEffect as ak, initialMicrostep as al, toStatePath as am, isStateId as an, getStateNodeByPath as ao, getPersistedSnapshot as ap, createRemoteActorRef as aq, resolveReferencedActor as ar, createInvokeTimeoutEvent as as, parseGeneratedActorId as at, ACTOR_REF_TYPE as au, hasAmbientInspector as av, getProperAncestors as aw, isRemoteActorRef as ax, getActorIdPrefix as ay, getAllOwnEvents as az, createSubscriptionLogic as b, createActor as c, getNextSnapshot as d, isMachineSnapshot as e, getStateNodes as f, getInitialSnapshot as g, getAllOwnEventDescriptors as h, isAtomicStateNode as i, matchesState as j, checkStateIn as k, listenerLogic as l, matchesEventDescriptor as m, pathToStateValue as n, toObserver as o, parseDelayToMilliseconds as p, executeEffects as q, isBuiltInExecutableAction as r, subscriptionLogic as s, toArray as t, deliverEvent as u, runStep as v, stopActor as w, terminateActor as x, createInitEvent as y, createDeadLetterEffect as z };

package/dist/{createActor-74e185ee.development.esm.js → createActor-67a1cda3.development.esm.js}

@@ -3003,6 +3003,7 @@ function microstep(transitions, currentSnapshot, actorScope, event, isInitial, i
             self: actorScope.self,
             context: nextState.context,
             event,
+            input: stateInputMap[stateNodeToEnter.id],
             output: getEventOutput(event)
           }) : invokeDef.input;
           assertChildIdFree(actorScope, invokeDef.id);
@@ -5863,4 +5864,4 @@ function createActor(logic, options) {
   return new Actor(logic, options);
 }
 
-export { createInvokeTimeoutEventId as $, Actor as A, createCustomEffect as B, XSTATE_LOGIC_EFFECT_START as C, XSTATE_LOGIC_EFFECT_RESOLVE as D, XSTATE_LOGIC_EFFECT_REJECT as E, finalizeTransitionResult as F, createEmitEffect as G, createSendToEffect as H, XSTATE_INIT as I, withActorScope as J, XSTATE_TIMER as K, isLazyActorScope as L, resolveRegisteredActorSource as M, allocateChildId as N, assertChildIdFree as O, reserveChildId as P, mapValues as Q, createInvokeId as R, STATE_DELIMITER as S, getDelayedTransitions as T, getEventDescriptorKey as U, getCandidates as V, evaluateCandidate as W, XSTATE_STOP as X, formatTransition as Y, NULL_EVENT as Z, toTransitionConfigArray as _, createListenerLogic as a, matchesActorSession as a0, formatRouteTransitions as a1, resolveStateValue as a2, getAllStateNodes as a3, createMachineSnapshot as a4, isInFinalState as a5, createInertActorScope as a6, setInertActorScopeSnapshot as a7, beginSpawnAllocation as a8, attachSnapshotActorRef as a9, getActorIdPrefix as aA, getAllOwnEvents as aB, matchesEvent as aC, encodeAddressSegment as aD, getRootActorId as aE, RUNTIME_OPERATIONS as aF, withSystemInspector as aG, getSnapshotActorRef as aH, withExecutionIdentity as aI, macrostep as aa, isInertActorScope as ab, setSnapshotActorRef as ac, cloneMachineSnapshot as ad, transitionNode as ae, getTransitionResult as af, hasEffect as ag, createErrorPlatformEvent as ah, withActorSelf as ai, resolveActionsWithContext as aj, takeSpawnAllocationCounters as ak, mergeActorIdCounters as al, createSpawnEffect as am, initialMicrostep as an, toStatePath as ao, isStateId as ap, getStateNodeByPath as aq, getPersistedSnapshot as ar, createRemoteActorRef as as, resolveReferencedActor as at, createInvokeTimeoutEvent as au, parseGeneratedActorId as av, ACTOR_REF_TYPE as aw, hasAmbientInspector as ax, getProperAncestors as ay, isRemoteActorRef as az, createSubscriptionLogic as b, createActor as c, getNextSnapshot as d, isMachineSnapshot as e, getStateNodes as f, getInitialSnapshot as g, getAllOwnEventDescriptors as h, isAtomicStateNode as i, matchesState as j, checkStateIn as k, listenerLogic as l, matchesEventDescriptor as m, pathToStateValue as n, toObserver as o, parseDelayToMilliseconds as p, executeEffects as q, isBuiltInExecutableAction as r, subscriptionLogic as s, toArray as t, deliverEvent as u, runStep as v, stopActor as w, terminateActor as x, createInitEvent as y, createDeadLetterEffect as z };
+export { resolveStateValue as $, Actor as A, createCustomEffect as B, XSTATE_LOGIC_EFFECT_START as C, XSTATE_LOGIC_EFFECT_RESOLVE as D, XSTATE_LOGIC_EFFECT_REJECT as E, finalizeTransitionResult as F, createEmitEffect as G, createSendToEffect as H, XSTATE_INIT as I, resolveRegisteredActorSource as J, allocateChildId as K, assertChildIdFree as L, reserveChildId as M, mapValues as N, createInvokeId as O, getDelayedTransitions as P, getEventDescriptorKey as Q, getCandidates as R, STATE_DELIMITER as S, evaluateCandidate as T, formatTransition as U, NULL_EVENT as V, toTransitionConfigArray as W, XSTATE_STOP as X, createInvokeTimeoutEventId as Y, matchesActorSession as Z, formatRouteTransitions as _, createListenerLogic as a, getAllStateNodes as a0, createMachineSnapshot as a1, isInFinalState as a2, createInertActorScope as a3, setInertActorScopeSnapshot as a4, beginSpawnAllocation as a5, attachSnapshotActorRef as a6, macrostep as a7, isInertActorScope as a8, setSnapshotActorRef as a9, matchesEvent as aA, encodeAddressSegment as aB, getRootActorId as aC, RUNTIME_OPERATIONS as aD, withSystemInspector as aE, getSnapshotActorRef as aF, withExecutionIdentity as aG, cloneMachineSnapshot as aa, transitionNode as ab, XSTATE_TIMER as ac, getTransitionResult as ad, hasEffect as ae, createErrorPlatformEvent as af, withActorSelf as ag, resolveActionsWithContext as ah, takeSpawnAllocationCounters as ai, mergeActorIdCounters as aj, createSpawnEffect as ak, initialMicrostep as al, toStatePath as am, isStateId as an, getStateNodeByPath as ao, getPersistedSnapshot as ap, createRemoteActorRef as aq, resolveReferencedActor as ar, createInvokeTimeoutEvent as as, parseGeneratedActorId as at, ACTOR_REF_TYPE as au, hasAmbientInspector as av, getProperAncestors as aw, isRemoteActorRef as ax, getActorIdPrefix as ay, getAllOwnEvents as az, createSubscriptionLogic as b, createActor as c, getNextSnapshot as d, isMachineSnapshot as e, getStateNodes as f, getInitialSnapshot as g, getAllOwnEventDescriptors as h, isAtomicStateNode as i, matchesState as j, checkStateIn as k, listenerLogic as l, matchesEventDescriptor as m, pathToStateValue as n, toObserver as o, parseDelayToMilliseconds as p, executeEffects as q, isBuiltInExecutableAction as r, subscriptionLogic as s, toArray as t, deliverEvent as u, runStep as v, stopActor as w, terminateActor as x, createInitEvent as y, createDeadLetterEffect as z };

package/dist/{createActor-27fd819f.cjs.js → createActor-a0610101.cjs.js}

@@ -2987,6 +2987,7 @@ function microstep(transitions, currentSnapshot, actorScope, event, isInitial, i
             self: actorScope.self,
             context: nextState.context,
             event,
+            input: stateInputMap[stateNodeToEnter.id],
             output: getEventOutput(event)
           }) : invokeDef.input;
           assertChildIdFree(actorScope, invokeDef.id);
@@ -5889,7 +5890,6 @@ exports.isAtomicStateNode = isAtomicStateNode;
 exports.isBuiltInExecutableAction = isBuiltInExecutableAction;
 exports.isInFinalState = isInFinalState;
 exports.isInertActorScope = isInertActorScope;
-exports.isLazyActorScope = isLazyActorScope;
 exports.isMachineSnapshot = isMachineSnapshot;
 exports.isRemoteActorRef = isRemoteActorRef;
 exports.isStateId = isStateId;
@@ -5921,7 +5921,6 @@ exports.toObserver = toObserver;
 exports.toStatePath = toStatePath;
 exports.toTransitionConfigArray = toTransitionConfigArray;
 exports.transitionNode = transitionNode;
-exports.withActorScope = withActorScope;
 exports.withActorSelf = withActorSelf;
 exports.withExecutionIdentity = withExecutionIdentity;
 exports.withSystemInspector = withSystemInspector;

package/dist/{createActor-ea9a560c.development.cjs.js → createActor-ae612b26.development.cjs.js}

@@ -3005,6 +3005,7 @@ function microstep(transitions, currentSnapshot, actorScope, event, isInitial, i
             self: actorScope.self,
             context: nextState.context,
             event,
+            input: stateInputMap[stateNodeToEnter.id],
             output: getEventOutput(event)
           }) : invokeDef.input;
           assertChildIdFree(actorScope, invokeDef.id);
@@ -5928,7 +5929,6 @@ exports.isAtomicStateNode = isAtomicStateNode;
 exports.isBuiltInExecutableAction = isBuiltInExecutableAction;
 exports.isInFinalState = isInFinalState;
 exports.isInertActorScope = isInertActorScope;
-exports.isLazyActorScope = isLazyActorScope;
 exports.isMachineSnapshot = isMachineSnapshot;
 exports.isRemoteActorRef = isRemoteActorRef;
 exports.isStateId = isStateId;
@@ -5960,7 +5960,6 @@ exports.toObserver = toObserver;
 exports.toStatePath = toStatePath;
 exports.toTransitionConfigArray = toTransitionConfigArray;
 exports.transitionNode = transitionNode;
-exports.withActorScope = withActorScope;
 exports.withActorSelf = withActorSelf;
 exports.withExecutionIdentity = withExecutionIdentity;
 exports.withSystemInspector = withSystemInspector;

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

@@ -1,2 +1,2 @@
-export { createFSMActor, FSMActor } from "./createFSMActor.js";
-export { createFSM, type FSMActorLogic, type FSMConfig, type FSMSnapshot } from "../fsm.js";
+export { types } from "../schema.types.js";
+export { createFSM, setup, type FSM, type FSMArgs, type FSMConfig, type FSMContextPatch, type FSMStateConfig, type FSMTransition, type FSMTransitionConfig, type FSMTransitionFunction, type FSMSnapshot, type FSMSetupConfig, type FSMSetupReturn } from "../fsm.js";

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

@@ -1,78 +1,134 @@
-import type { ActorLogic, EnqueueObject, EventObject, MachineContext, LogicalTimer, NonReducibleUnknown, Snapshot } from "./types.js";
-export type FSMSnapshot<TContext extends MachineContext, TState extends string, TInput = unknown> = Snapshot<undefined> & {
-    value: TState;
-    context: TContext;
-    input: TInput | undefined;
-    children: {};
-    timers: Record<string, LogicalTimer>;
-    _nextTimerId: number;
-    _nextActorIds?: Record<string, number>;
-    _stateInput: Record<string, unknown> | undefined;
-    machine: {
-        id: string;
-        sources: {
-            actions: {};
-            actors: {};
-            guards: {};
-            delays: {};
-        };
-    };
-};
-type FSMArgs<TContext extends MachineContext, TEvent extends EventObject, TState extends string, TInput> = {
+import type { EventObject, MachineContext } from "./types.js";
+import type { StandardSchemaV1 } from "./schema.types.js";
+import type { SetupSchemas, SetupStateSchema } from "./setup.js";
+import type { InferEvents } from "./types.v6.js";
+export type FSMArgs<TContext extends MachineContext, TEvent extends EventObject> = {
     context: TContext;
     event: TEvent;
-    input: TInput | undefined;
-    value: TState;
-    self: any;
-    system: any;
-    parent: any;
-    children: {};
 };
-type FSMAction<TContext extends MachineContext, TEvent extends EventObject, TState extends string, TInput> = (args: FSMArgs<TContext, TEvent, TState, TInput> & {
-    input: Record<string, unknown> | undefined;
-}, enq: EnqueueObject<TEvent, EventObject>) => void | {
+export type FSMContextPatch<TContext extends MachineContext> = Partial<TContext>;
+export type FSMTransitionConfig<TContext extends MachineContext, TState extends string> = {
+    target?: TState;
     context?: FSMContextPatch<TContext>;
 };
-type FSMGuard<TContext extends MachineContext, TEvent extends EventObject, TState extends string, TInput> = (args: FSMArgs<TContext, TEvent, TState, TInput>) => boolean;
-type FSMContextPatch<TContext extends MachineContext> = Partial<TContext> & {
-    call?: never;
-    apply?: never;
-    bind?: never;
+export type FSMTransitionFunction<TContext extends MachineContext, TEvent extends EventObject, TState extends string, TTransitionContext extends MachineContext = TContext> = (args: FSMArgs<TContext, TEvent>) => FSMTransitionConfig<TTransitionContext, TState> | undefined;
+type EventForType<TEvent extends EventObject, TType extends string> = [
+    Extract<TEvent, {
+        type: TType;
+    }>
+] extends [never] ? TEvent : Extract<TEvent, {
+    type: TType;
+}>;
+export type FSMTransition<TContext extends MachineContext, TEvent extends EventObject, TState extends string, TTransitionContext extends MachineContext = TContext> = TState | FSMTransitionConfig<TTransitionContext, TState> | FSMTransitionFunction<TContext, TEvent, TState, TTransitionContext>;
+type FSMOn<TContext extends MachineContext, TEvent extends EventObject, TState extends string, TTransitionContext extends MachineContext = TContext> = {
+    [TType in TEvent['type'] & string]?: FSMTransition<TContext, EventForType<TEvent, TType>, TState, TTransitionContext>;
 };
-type FSMContextMapper<TContext extends MachineContext, TEvent extends EventObject, TState extends string, TInput> = (args: FSMArgs<TContext, TEvent, TState, TInput>) => FSMContextPatch<TContext>;
-type FSMTarget<TContext extends MachineContext> = {
-    target?: string;
-    context?: FSMContextPatch<TContext>;
-    input?: Record<string, unknown> | ((args: {
-        context: TContext;
-        event: EventObject;
-    }) => Record<string, unknown>);
+export type FSMStateConfig<TContext extends MachineContext, TEvent extends EventObject, TState extends string, TTransitionContext extends MachineContext = TContext> = {
+    on?: FSMOn<TContext, TEvent, TState, TTransitionContext>;
 };
-type FSMObjectTarget<TContext extends MachineContext, TEvent extends EventObject, TState extends string, TInput> = Omit<FSMTarget<TContext>, 'context'> & {
-    context?: FSMContextPatch<TContext> | FSMContextMapper<TContext, TEvent, TState, TInput>;
-};
-type FSMTransitionFunction<TContext extends MachineContext, TEvent extends EventObject, TState extends string, TInput> = (args: FSMArgs<TContext, TEvent, TState, TInput>, enq: EnqueueObject<TEvent, EventObject>) => void | false | FSMTarget<TContext>;
-type FSMTransition<TContext extends MachineContext, TEvent extends EventObject, TState extends string, TInput> = FSMObjectTarget<TContext, TEvent, TState, TInput> | (FSMObjectTarget<TContext, TEvent, TState, TInput> & {
-    guard?: FSMGuard<TContext, TEvent, TState, TInput>;
-    actions?: FSMAction<TContext, TEvent, TState, TInput> | Array<FSMAction<TContext, TEvent, TState, TInput>>;
-}) | FSMTransitionFunction<TContext, TEvent, TState, TInput>;
-type FSMStateConfig<TContext extends MachineContext, TEvent extends EventObject, TState extends string, TInput> = {
-    type?: 'final';
-    entry?: FSMAction<TContext, TEvent, TState, TInput> | Array<FSMAction<TContext, TEvent, TState, TInput>>;
-    exit?: FSMAction<TContext, TEvent, TState, TInput> | Array<FSMAction<TContext, TEvent, TState, TInput>>;
-    always?: FSMTransition<TContext, TEvent, TState, TInput> | Array<FSMTransition<TContext, TEvent, TState, TInput>>;
-    on?: Record<string, FSMTransition<TContext, TEvent, TState, TInput> | Array<FSMTransition<TContext, TEvent, TState, TInput>>>;
+type FSMContextConfig<TContext extends MachineContext> = string extends keyof TContext ? {
+    context?: TContext;
+} : keyof TContext extends never ? {
+    context?: TContext;
+} : {
+    context: TContext;
 };
-export type FSMConfig<TContext extends MachineContext, TEvent extends EventObject, TState extends string, TInput = NonReducibleUnknown> = {
+export type FSMConfig<TContext extends MachineContext = {}, TEvent extends EventObject = EventObject, TState extends string = string> = {
     id?: string;
     initial: TState;
-    context?: TContext | ((args: {
-        input: TInput;
-    }) => TContext);
-    states: Record<TState, FSMStateConfig<TContext, TEvent, TState, TInput>>;
+    states: {
+        [K in TState]: FSMStateConfig<TContext, TEvent, TState>;
+    };
+} & FSMContextConfig<TContext>;
+type FSMConfigForStates<TContext extends MachineContext, TEvent extends EventObject, TStates extends Record<string, unknown>> = Omit<FSMConfig<TContext, TEvent, keyof TStates & string>, 'initial' | 'states'> & {
+    initial: keyof TStates & string;
+    states: {
+        [K in keyof TStates]: FSMStateConfig<TContext, TEvent, keyof TStates & string>;
+    };
 };
-export type FSMActorLogic<TContext extends MachineContext, TEvent extends EventObject, TState extends string, TInput> = ActorLogic<FSMSnapshot<TContext, TState, TInput>, TEvent, TInput, any, EventObject> & {
+export type FSMSnapshot<TContext extends MachineContext, TState extends string> = {
+    value: TState;
+    context: TContext;
+};
+export type FSM<TContext extends MachineContext, TEvent extends EventObject, TState extends string, TSnapshot extends {
+    value: TState;
+    context: MachineContext;
+} = FSMSnapshot<TContext, TState>, TConfig = FSMConfig<TContext, TEvent, TState>> = {
+    readonly id: string | undefined;
+    readonly config: TConfig;
+    readonly initialState: TSnapshot;
+    transition(snapshot: TSnapshot, event: TEvent): TSnapshot;
+};
+type FSMSetupSchemas = Pick<SetupSchemas, 'context' | 'events'>;
+type FSMSetupStates = Record<string, SetupStateSchema>;
+type FSMSchemaContext<TSchema extends StandardSchemaV1> = StandardSchemaV1.InferOutput<TSchema> extends MachineContext ? StandardSchemaV1.InferOutput<TSchema> : MachineContext;
+type FSMSetupContext<TSchemas extends FSMSetupSchemas> = TSchemas extends {
+    context: infer TSchema extends StandardSchemaV1;
+} ? FSMSchemaContext<TSchema> : MachineContext;
+type FSMSetupEvents<TSchemas extends FSMSetupSchemas> = TSchemas extends {
+    events: infer TEventSchemas extends Record<string, StandardSchemaV1>;
+} ? InferEvents<TEventSchemas> : EventObject;
+type FSMStateContext<TStateSchema, TGlobalContext extends MachineContext> = TStateSchema extends {
+    schemas?: infer TSchemas;
+} ? TSchemas extends {
+    context?: infer TSchema extends StandardSchemaV1;
+} ? FSMSchemaContext<TSchema> & ([MachineContext] extends [TGlobalContext] ? unknown : TGlobalContext) : TGlobalContext : TGlobalContext;
+type FSMContextFromDeclaredStates<TStates extends FSMSetupStates, TGlobalContext extends MachineContext> = {
+    [K in keyof TStates & string]: FSMStateContext<TStates[K], TGlobalContext>;
+}[keyof TStates & string];
+type FSMContextFromStates<TStates extends FSMSetupStates, TGlobalContext extends MachineContext> = [keyof TStates] extends [never] ? TGlobalContext : [MachineContext] extends [TGlobalContext] ? FSMContextFromDeclaredStates<TStates, TGlobalContext> : TGlobalContext | FSMContextFromDeclaredStates<TStates, TGlobalContext>;
+type FSMSetupStateContext<TState extends string, TStates extends FSMSetupStates, TGlobalContext extends MachineContext> = TState extends keyof TStates ? FSMStateContext<TStates[TState], TGlobalContext> : TGlobalContext;
+type FSMSetupSnapshot<TStates extends FSMSetupStates, TGlobalContext extends MachineContext, TMachineStates extends Record<string, unknown>> = [keyof TStates] extends [never] ? FSMSnapshot<TGlobalContext, keyof TMachineStates & string> : {
+    [K in keyof TMachineStates & string]: {
+        value: K;
+        context: FSMSetupStateContext<K, TStates, TGlobalContext>;
+    };
+}[keyof TMachineStates & string];
+type FSMSetupTargetTransitionConfig<TSourceContext extends MachineContext, TTarget extends string, TTargetContext extends MachineContext> = [FSMRequiredTargetContextKeys<TSourceContext, TTargetContext>] extends [
+    never
+] ? {
+    target: TTarget;
+    context?: FSMTargetContextPatch<TSourceContext, TTargetContext>;
+} : {
+    target: TTarget;
+    context: FSMTargetContextPatch<TSourceContext, TTargetContext>;
+};
+type FSMRequiredTargetContextKeys<TSourceContext, TTargetContext> = {
+    [K in keyof TTargetContext]-?: K extends keyof TSourceContext ? [TSourceContext[K]] extends [TTargetContext[K]] ? never : K : K;
+}[keyof TTargetContext];
+type FSMTargetContextPatch<TSourceContext, TTargetContext> = Partial<TTargetContext> & Pick<TTargetContext, Extract<FSMRequiredTargetContextKeys<TSourceContext, TTargetContext>, string>>;
+type FSMSetupTransitionConfig<TSourceContext extends MachineContext, TStates extends FSMSetupStates, TGlobalContext extends MachineContext> = {
+    target?: undefined;
+    context?: FSMContextPatch<TSourceContext>;
+} | {
+    [TTarget in keyof TStates & string]: FSMSetupTargetTransitionConfig<TSourceContext, TTarget, FSMSetupStateContext<TTarget, TStates, TGlobalContext>>;
+}[keyof TStates & string];
+type FSMSetupStringTransition<TSourceContext extends MachineContext, TStates extends FSMSetupStates, TGlobalContext extends MachineContext> = {
+    [TTarget in keyof TStates & string]: [TSourceContext] extends [
+        FSMSetupStateContext<TTarget, TStates, TGlobalContext>
+    ] ? TTarget : never;
+}[keyof TStates & string];
+type FSMSetupTransitionFunction<TSourceContext extends MachineContext, TEvent extends EventObject, TStates extends FSMSetupStates, TGlobalContext extends MachineContext> = (args: FSMArgs<TSourceContext, TEvent>) => FSMSetupTransitionConfig<TSourceContext, TStates, TGlobalContext> | undefined;
+type FSMSetupTransition<TSourceContext extends MachineContext, TEvent extends EventObject, TStates extends FSMSetupStates, TGlobalContext extends MachineContext, TMachineStates extends Record<string, unknown>> = [keyof TStates] extends [never] ? FSMTransition<TSourceContext, TEvent, keyof TMachineStates & string> : FSMSetupStringTransition<TSourceContext, TStates, TGlobalContext> | FSMSetupTransitionConfig<TSourceContext, TStates, TGlobalContext> | FSMSetupTransitionFunction<TSourceContext, TEvent, TStates, TGlobalContext>;
+type FSMSetupStateConfig<TSourceContext extends MachineContext, TEvent extends EventObject, TStates extends FSMSetupStates, TGlobalContext extends MachineContext, TMachineStates extends Record<string, unknown>> = {
+    on?: {
+        [TType in TEvent['type'] & string]?: FSMSetupTransition<TSourceContext, EventForType<TEvent, TType>, TStates, TGlobalContext, TMachineStates>;
+    };
+};
+type FSMSetupMachineConfig<TSchemas extends FSMSetupSchemas, TStates extends FSMSetupStates, TMachineStates extends Record<string, unknown>> = {
     id?: string;
+    initial: keyof TMachineStates & string;
+    states: {
+        [K in keyof TMachineStates]: FSMSetupStateConfig<FSMStateContext<K extends keyof TStates ? TStates[K] : {}, FSMSetupContext<TSchemas>>, FSMSetupEvents<TSchemas>, TStates, FSMSetupContext<TSchemas>, TMachineStates>;
+    };
+} & FSMContextConfig<FSMContextFromStates<TStates, FSMSetupContext<TSchemas>>>;
+export type FSMSetupConfig<TSchemas extends FSMSetupSchemas = {}, TStates extends FSMSetupStates = {}> = {
+    schemas?: TSchemas;
+    states?: TStates;
+};
+export type FSMSetupReturn<TSchemas extends FSMSetupSchemas, TStates extends FSMSetupStates> = {
+    createFSM<const TMachineStates extends Record<string, unknown>>(config: FSMSetupMachineConfig<TSchemas, TStates, TMachineStates>): FSM<FSMContextFromStates<TStates, FSMSetupContext<TSchemas>>, FSMSetupEvents<TSchemas>, keyof TMachineStates & string, FSMSetupSnapshot<TStates, FSMSetupContext<TSchemas>, TMachineStates>, FSMSetupMachineConfig<TSchemas, TStates, TMachineStates>>;
 };
-export declare function createFSM<TContext extends MachineContext, TEvent extends EventObject, TInput = NonReducibleUnknown>(config: FSMConfig<TContext, TEvent, string, TInput>): FSMActorLogic<TContext, TEvent, string, TInput>;
+export declare function setup<const TSchemas extends FSMSetupSchemas = {}, const TStates extends FSMSetupStates = {}>(_config?: FSMSetupConfig<TSchemas, TStates>): FSMSetupReturn<TSchemas, TStates>;
+export declare function createFSM<TContext extends MachineContext = {}, TEvent extends EventObject = EventObject, const TStates extends Record<string, unknown> = Record<string, unknown>>(config: FSMConfigForStates<TContext, TEvent, TStates>): FSM<TContext, TEvent, keyof TStates & string, FSMSnapshot<TContext, keyof TStates & string>, FSMConfigForStates<TContext, TEvent, TStates>>;
 export {};

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

@@ -2,7 +2,7 @@ export { createAsyncLogic, createCallbackLogic, createEmptyActor, createEventObs
 export { assertEvent } from "./assert.js";
 export { Actor, createActor, type RequiredActorOptionsKeys as RequiredActorOptionsKeys } from "./createActor.js";
 export { createMachine, createStateConfig } from "./createMachine.js";
-export { createFSM, type FSMActorLogic, type FSMConfig, type FSMSnapshot } from "./fsm.js";
+export { createFSM, type FSM, type FSMArgs, type FSMConfig, type FSMContextPatch, type FSMStateConfig, type FSMTransition, type FSMTransitionConfig, type FSMTransitionFunction, type FSMSnapshot } from "./fsm.js";
 export { createMachineFromConfig } from "./createMachineFromConfig.js";
 export type { ActionJSON, GuardJSON, InvokeJSON, MachineJSON, StateNodeJSON, TransitionJSON } from "./createMachineFromConfig.js";
 export { machineConfigToJSON, serializeMachine, type CodeExpression } from "./serialize.js";
@@ -11,7 +11,7 @@ export { machineVersions, type AdaptEventsOptions, type EventAdapterHandlers, ty
 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";
-export type { AnySetupConfig, SetupConfig, SetupReturn, SetupReturnFromConfig, SetupSchemas, SystemActorMap, SystemConfig, SystemRuntime, SetupStateSchema, SetupStateSchemas } from "./setup.js";
+export type { AnySetupConfig, SetupConfig, SetupReturn, SetupReturnFromConfig, SetupSchemas, SystemActorMap, SystemConfig, SystemRuntime, SetupStateSchema, SetupStateSchemas, SetupStateType } from "./setup.js";
 export { getInitialSnapshot, getNextSnapshot } from "./getNextSnapshot.js";
 export type { InspectionEvent, ActorInspectionEvent, DeadLetterInspectionEvent, TransitionInspectionEvent, ActionRecord, SentRecord } from "./inspection.js";
 export { SimulatedClock } from "./SimulatedClock.js";

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

@@ -5,6 +5,7 @@ export interface StandardSchemaV1<Input = unknown, Output = Input> {
 }
 /** Schemas that can be declared for an individual state node. */
 export type SetupStateSchemas = {
+    /** Refines the machine's root context schema while this state is active. */
     context?: StandardSchemaV1;
     input?: StandardSchemaV1;
     /** The output emitted when this state node completes. */