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

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, ValidateTopLevelFinalOutputs, 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,35 +45,37 @@ 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, const 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['actorSources'], 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 : {
+} & ValidateTopLevelFinalOutputs<TSS, InferOutput<TContextSchema, MachineContext>, InferEvents<TEventSchemaMap>>): 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, const 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['actorSources'] = Implementations['actorSources'], 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;
     };
     context?: TContext | ((_: {
         spawn: any;
-        actors: TActorMap;
+        actorSources: TActorMap;
         input: InferOutput<TInputSchema, unknown>;
         self: any;
     }) => TContext);
-}): StateMachine<WidenLiterals<TContext>, InferEvents<TEventSchemaMap> | ([RoutableStateId<TSS>] extends [never] ? never : {
+} & ValidateTopLevelFinalOutputs<TSS, WidenLiterals<TContext>, InferEvents<TEventSchemaMap>>): 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;
+export declare function createStateConfig<TContextSchema extends StandardSchemaV1, TEventSchema extends StandardSchemaV1, TEmittedSchema extends StandardSchemaV1, _TInputSchema extends StandardSchemaV1, const 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['actorSources'], 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/createMachineFromConfig.d.ts

@@ -90,43 +90,65 @@ interface ScxmlIfJSON {
 }
 interface CustomActionJSON {
     type: string;
-    params?: Record<string, unknown>;
+    params?: unknown;
 }
-export type ActionJSON = CustomActionJSON | RaiseJSON | CancelJSON | LogJSON | EmitJSON | AssignJSON | ScxmlAssignJSON | ScxmlRaiseJSON | ScxmlScriptJSON | ScxmlIfJSON | ScxmlForeachJSON | ScxmlCancelJSON | ScxmlBlockJSON;
+export type ActionJSON = CustomActionJSON | RaiseJSON | CancelJSON | LogJSON | EmitJSON | AssignJSON | ScxmlAssignJSON | ScxmlRaiseJSON | ScxmlScriptJSON | ScxmlIfJSON | ScxmlForeachJSON | ScxmlCancelJSON | ScxmlBlockJSON | ExpressionJSON | CodeJSON;
 export interface GuardJSON {
     type: string;
-    params?: Record<string, unknown>;
+    params?: unknown;
+}
+interface ExpressionJSON {
+    '@expr': string;
+    '@lang'?: string;
+}
+interface CodeJSON {
+    '@code': string;
+    '@lang'?: string;
+}
+type ResolvableJSON = ExpressionJSON | CodeJSON;
+type ConditionJSON = GuardJSON | ResolvableJSON;
+interface ChoiceBranchJSON {
+    when?: ConditionJSON;
+    target: string | string[];
+    context?: MachineContext;
+    input?: unknown;
+    description?: string;
+    reenter?: boolean;
+    meta?: MetaObject;
 }
 export interface InvokeJSON {
     id?: string;
-    systemId?: string;
-    src: string | UnserializableMarker;
+    registryKey?: string;
+    src: string;
     input?: unknown;
-    onDone?: TransitionJSON | TransitionJSON[];
-    onError?: TransitionJSON | TransitionJSON[];
-    onSnapshot?: TransitionJSON | TransitionJSON[];
-    timeout?: number | string;
-    onTimeout?: TransitionJSON | TransitionJSON[];
+    onDone?: TransitionConfigJSON | TransitionConfigJSON[];
+    onError?: TransitionConfigJSON | TransitionConfigJSON[];
+    onSnapshot?: TransitionConfigJSON | TransitionConfigJSON[];
+    timeout?: number | string | ResolvableJSON;
+    onTimeout?: TransitionConfigJSON | TransitionConfigJSON[];
 }
 export interface TransitionJSON {
     target?: string | string[];
+    context?: MachineContext;
     actions?: ActionJSON[];
-    guard?: GuardJSON;
+    guard?: ConditionJSON;
     description?: string;
     reenter?: boolean;
     meta?: MetaObject;
     input?: unknown;
 }
+type TransitionConfigJSON = TransitionJSON | ResolvableJSON;
 export interface StateNodeJSON {
     id?: string;
     key?: string;
     type?: 'atomic' | 'compound' | 'parallel' | 'final' | 'history' | 'choice';
     initial?: string;
     states?: Record<string, StateNodeJSON>;
-    on?: Record<string, TransitionJSON | TransitionJSON[]>;
-    after?: Record<string, TransitionJSON | TransitionJSON[]>;
-    always?: TransitionJSON | TransitionJSON[];
-    choice?: TransitionJSON;
+    on?: Record<string, TransitionConfigJSON | TransitionConfigJSON[]>;
+    onError?: TransitionConfigJSON | TransitionConfigJSON[];
+    after?: Record<string, TransitionConfigJSON | TransitionConfigJSON[]>;
+    always?: TransitionConfigJSON | TransitionConfigJSON[];
+    choice?: ChoiceBranchJSON[] | ResolvableJSON;
     /**
      * JSON route config. Unlike the authoring API (a function), the JSON layer
      * allows an object form whose `guard` may be a named guard reference (string)
@@ -138,16 +160,16 @@ export interface StateNodeJSON {
         meta?: MetaObject;
         guard?: string;
         input?: Record<string, unknown>;
-    };
+    } | ResolvableJSON;
     invoke?: InvokeJSON | InvokeJSON[];
-    entry?: ActionJSON[];
-    exit?: ActionJSON[];
+    entry?: ActionJSON | ActionJSON[];
+    exit?: ActionJSON | ActionJSON[];
     meta?: MetaObject;
     description?: string;
     tags?: string[];
     input?: unknown;
-    timeout?: number | string;
-    onTimeout?: TransitionJSON | TransitionJSON[];
+    timeout?: number | string | ResolvableJSON;
+    onTimeout?: TransitionConfigJSON | TransitionConfigJSON[];
     history?: 'shallow' | 'deep';
     target?: string;
     output?: unknown;
@@ -155,22 +177,33 @@ export interface StateNodeJSON {
     _scxmlDonedata?: ScxmlDonedataJSON;
 }
 export interface MachineJSON extends StateNodeJSON {
+    '@exprLang'?: string;
     version?: string;
-    actions?: Record<string, unknown>;
-    guards?: Record<string, unknown>;
-    actors?: Record<string, unknown>;
-    delays?: Record<string, unknown>;
+    actions?: Record<string, ActionJSON | ActionJSON[]>;
+    guards?: Record<string, {
+        when: ConditionJSON;
+    }>;
+    actorSources?: Record<string, unknown>;
+    delays?: Record<string, number | string | {
+        duration: number | string | ResolvableJSON;
+    }>;
     schemas?: Record<string, unknown>;
 }
-interface UnserializableMarker {
-    $unserializable: 'function' | 'actor' | 'schema' | 'value';
-    id?: string;
+type EvaluatorSlot = 'context' | 'guard' | 'choice' | 'action' | 'actionParams' | 'transition' | 'input' | 'output' | 'delay' | 'transitionContext' | 'unknown';
+type EvaluatorKind = 'expr' | 'code';
+interface EvaluatorArgs {
+    source: string;
+    kind: EvaluatorKind;
+    slot: EvaluatorSlot;
+    scope: Record<string, unknown>;
+    path: string;
 }
 interface MachineImplementations {
     actions?: Record<string, (...args: any[]) => unknown>;
     guards?: Record<string, (...args: any[]) => boolean>;
-    actors?: Record<string, AnyActorLogic>;
+    actorSources?: Record<string, AnyActorLogic>;
     delays?: Record<string, number | ((...args: any[]) => number)>;
+    evaluators?: Record<string, (args: EvaluatorArgs) => unknown>;
 }
 export declare function createMachineFromConfig(json: MachineJSON, implementations?: MachineImplementations): AnyStateMachine;
 export {};

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

@@ -0,0 +1,74 @@
+import { createTransitionEnqueue } from "./transitionActions.js";
+import type { ActorLogic, EventObject, MachineContext, 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: {};
+    _stateInput: Record<string, unknown> | undefined;
+    machine: {
+        id: string;
+        implementations: {
+            actions: {};
+            actorSources: {};
+            guards: {};
+            delays: {};
+        };
+    };
+};
+type FSMArgs<TContext extends MachineContext, TEvent extends EventObject, TState extends string, TInput> = {
+    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: ReturnType<typeof createTransitionEnqueue>) => void | {
+    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;
+};
+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>);
+};
+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: ReturnType<typeof createTransitionEnqueue>) => 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> = {
+    entry?: FSMAction<TContext, TEvent, TState, TInput> | Array<FSMAction<TContext, TEvent, TState, TInput>>;
+    exit?: FSMAction<TContext, TEvent, TState, TInput> | Array<FSMAction<TContext, TEvent, TState, TInput>>;
+    on?: Record<string, FSMTransition<TContext, TEvent, TState, TInput> | Array<FSMTransition<TContext, TEvent, TState, TInput>>>;
+};
+export type FSMConfig<TContext extends MachineContext, TEvent extends EventObject, TState extends string, TInput = NonReducibleUnknown> = {
+    id?: string;
+    initial: TState;
+    context?: TContext | ((args: {
+        input: TInput;
+    }) => TContext);
+    states: Record<TState, FSMStateConfig<TContext, TEvent, TState, TInput>>;
+};
+export type FSMActorLogic<TContext extends MachineContext, TEvent extends EventObject, TState extends string, TInput> = ActorLogic<FSMSnapshot<TContext, TState, TInput>, TEvent, TInput, any, EventObject> & {
+    id?: string;
+};
+export declare function createFSM<TContext extends MachineContext, TEvent extends EventObject, TInput = NonReducibleUnknown>(config: FSMConfig<TContext, TEvent, string, TInput>): FSMActorLogic<TContext, TEvent, string, TInput>;
+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

@@ -1,15 +1,15 @@
 export * from "./actors/index.js";
-export { createAtom, createAtomConfig, createAsyncAtom, createReducerAtom, isAtom } from "./atom.js";
-export type { AnyAtom, AnyAtomConfig, AsyncAtomOptions, AsyncAtomState, Atom, AtomConfig, AtomOptions, BaseAtom, InputFromAtomConfig, ReadonlyAtom, ReducerAtom, ValueFromAtomConfig } from "./atom.js";
 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 { createMachineFromConfig } from "./createMachineFromConfig.js";
 export type { ActionJSON, GuardJSON, InvokeJSON, MachineJSON, StateNodeJSON, TransitionJSON } from "./createMachineFromConfig.js";
-export { machineConfigToJSON, serializeMachine, type UnserializableMarker } from "./serialize.js";
+export { machineConfigToJSON, serializeMachine, type CodeExpression } from "./serialize.js";
 export { mapState } from "./mapState.js";
 export { types, isTypeSchema, type StandardSchemaV1, type TypeSchema } from "./schema.types.js";
-export { setup } from "./setup.js";
+export { createSystem, setup } from "./setup.js";
+export type { AnySetupConfig, SetupConfig, SetupReturn, SetupReturnFromConfig, SetupSchemas, SystemActorMap, SystemConfig, SystemRuntime, SetupStateSchema, SetupStateSchemas } from "./setup.js";
 export { getInitialSnapshot, getNextSnapshot } from "./getNextSnapshot.js";
 export type { InspectionEvent, ActorInspectionEvent, TransitionInspectionEvent, ActionRecord, SentRecord } from "./inspection.js";
 export { SimulatedClock } from "./SimulatedClock.js";
@@ -18,12 +18,13 @@ export { isMachineSnapshot, type MachineSnapshot } from "./State.js";
 export { StateMachine } from "./StateMachine.js";
 export { StateNode } from "./StateNode.js";
 export { getStateNodes } from "./stateUtils.js";
-export type { ActorSystem } from "./system.js";
+export type { ActorSystem, AnyActorSystem } from "./system.js";
 export { toPromise } from "./toPromise.js";
 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 {

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

@@ -3,29 +3,21 @@
  *
  * `machineConfigToJSON` converts a machine config into a JSON-safe structure
  * (the `MachineJSON` shape accepted by `createMachineFromConfig`). The boundary
- * between serializable structure and runtime implementations is explicit: any
- * value that cannot be represented as data (inline functions, actor logic,
- * runtime schemas) is replaced with an `{ "$unserializable": <kind> }` marker
- * rather than silently dropped.
- *
- * A machine definition is fully portable iff its JSON contains no
- * `$unserializable` markers; reviving a definition that has markers requires
- * re-providing those implementations (e.g. via `machine.provide(...)` or the
- * `actions`/`guards`/`actors` maps on `createMachineFromConfig` revival).
+ * between serializable structure and runtime implementations is explicit:
+ * functions are represented as `@code` source objects, while actor logic,
+ * runtime schemas, and other non-data runtime values are omitted.
  */
 import type { AnyStateMachine } from "./types.js";
-export interface UnserializableMarker {
-    $unserializable: 'function' | 'actor' | 'schema' | 'value';
-    /** Best-effort identifier (function name, actor logic id) for diagnostics. */
-    id?: string;
+export interface CodeExpression {
+    '@code': string;
+    '@lang': 'ts';
 }
 /**
  * Returns the JSON-serializable definition of a machine.
  *
- * Inline functions, actor logic, and runtime schemas cannot be represented as
- * data; they appear as `{ "$unserializable": ... }` markers. A machine created
- * via `createMachineFromConfig` returns its original JSON config (lossless
- * round-trip):
+ * Inline functions are represented as `{ "@code": string, "@lang": "ts" }`. A
+ * machine created via `createMachineFromConfig` returns its original JSON
+ * config (lossless round-trip):
  *
  * ```ts
  * import { serializeMachine, createMachineFromConfig } from 'xstate';
@@ -39,6 +31,6 @@ export interface UnserializableMarker {
 export declare function serializeMachine(machine: AnyStateMachine): Record<string, unknown>;
 /**
  * Converts a machine config (as passed to `createMachine`) to its JSON-safe
- * definition. See module docs for the `$unserializable` marker contract.
+ * definition.
  */
 export declare function machineConfigToJSON(config: Record<string, unknown>): Record<string, unknown>;