xstate 6.0.0-alpha.11 → 6.0.0-alpha.13

package/dist/{StateMachine-0aa98f54.development.esm.js → StateMachine-193c2d4d.development.esm.js}

@@ -1,4 +1,4 @@
-import { P as ProcessingStatus, C as resolveReferencedActor, c as createActor, S as STATE_DELIMITER, D as mapValues, t as toArray, E as createInvokeId, F as getDelayedTransitions, G as evaluateCandidate, H as formatTransition, N as NULL_EVENT, I as toTransitionConfigArray, J as createInvokeTimeoutEvent, K as getCandidates, L as formatRouteTransitions, M as resolveStateValue, O as getAllStateNodes, f as getStateNodes, Q as createMachineSnapshot, R as isInFinalState, a as macrostep, U as transitionNode, m as matchesEventDescriptor, V as resolveActionsWithContext, b as createInitEvent, d as initialMicrostep, W as toStatePath, X as isStateId, Y as getStateNodeByPath, Z as getPersistedSnapshot, $ as $$ACTOR_TYPE } from './index-2f2fbd9b.development.esm.js';
+import { P as ProcessingStatus, G as resolveReferencedActor, d as createActor, S as STATE_DELIMITER, H as mapValues, t as toArray, I as createInvokeId, J as getDelayedTransitions, K as evaluateCandidate, L as formatTransition, N as NULL_EVENT, M as toTransitionConfigArray, O as createInvokeTimeoutEvent, Q as getCandidates, R as formatRouteTransitions, U as resolveStateValue, V as getAllStateNodes, k as getStateNodes, W as createMachineSnapshot, Y as isInFinalState, e as macrostep, Z as cloneMachineSnapshot, _ as transitionNode, m as matchesEventDescriptor, r as resolveActionsWithContext, f as createInitEvent, g as initialMicrostep, $ as toStatePath, a0 as isStateId, a1 as getStateNodeByPath, a2 as getPersistedSnapshot, a3 as $$ACTOR_TYPE } from './index-7081e0c9.development.esm.js';
 
 function createSpawner(actorScope, {
   machine,
@@ -264,7 +264,7 @@ function formatChoiceTransitions(stateNode) {
     if (!result || result.target === undefined) {
       throw new Error(`Choice state "${stateNode.id}" must resolve to a target.`);
     }
-    for (const key of ['actions', 'to', 'context']) {
+    for (const key of ['actions', 'to']) {
       if (result[key] !== undefined) {
         throw new Error(`Choice state "${stateNode.id}" cannot declare \`${key}\` on a choice.`);
       }
@@ -526,12 +526,53 @@ class StateMachine {
    * @param event The received event
    */
   transition(snapshot, event, actorScope) {
+    const fastSnapshot = this._transitionFast(snapshot, event, actorScope);
+    if (fastSnapshot) {
+      return [fastSnapshot, []];
+    }
     const {
       snapshot: nextSnapshot,
       microsteps
     } = macrostep(snapshot, event, actorScope, []);
     return [nextSnapshot, microsteps.flatMap(([, actions]) => actions)];
   }
+  _transitionFast(snapshot, event, actorScope) {
+    if (snapshot.status !== 'active' || typeof snapshot.value !== 'string' || this.root.always?.length) {
+      return undefined;
+    }
+    const sourceNode = this.root.states[snapshot.value];
+    if (!sourceNode || sourceNode.type !== 'atomic' || sourceNode.exit || sourceNode.invoke.length || sourceNode.always?.length || sourceNode.after?.length) {
+      return undefined;
+    }
+    const transitions = sourceNode.transitions.get(event.type);
+    if (transitions?.length !== 1) {
+      return undefined;
+    }
+    const selected = transitions[0];
+    if (selected.guard || selected.actions || selected.to || selected.reenter || selected.input || typeof selected.context === 'function' || selected.target && selected.target.length !== 1) {
+      return undefined;
+    }
+    const targetNode = selected.target?.[0] ?? sourceNode;
+    const stateChanged = targetNode !== sourceNode;
+    if (targetNode.parent !== this.root || targetNode.type !== 'atomic' || stateChanged && (targetNode.entry || targetNode.invoke.length || targetNode.always?.length || targetNode.after?.length)) {
+      return undefined;
+    }
+    const context = selected.context !== undefined ? {
+      ...snapshot.context,
+      ...selected.context
+    } : snapshot.context;
+    const collectedMicrosteps = actorScope.self._collectedMicrosteps || [];
+    collectedMicrosteps.push(selected);
+    actorScope.self._collectedMicrosteps = collectedMicrosteps;
+    return cloneMachineSnapshot(snapshot, {
+      ...(context !== snapshot.context ? {
+        context
+      } : {}),
+      ...(stateChanged ? {
+        _nodes: [this.root, targetNode]
+      } : {})
+    });
+  }
 
   /**
    * Determines the next state given the current `state` and `event`. Calculates

package/dist/{StateMachine-aef700df.cjs.js → StateMachine-1b26c5de.cjs.js}

@@ -1,6 +1,6 @@
 'use strict';
 
-var dist_xstateActors = require('./index-559ceab3.cjs.js');
+var dist_xstateActors = require('./index-32631949.cjs.js');
 
 function createSpawner(actorScope, {
   machine,
@@ -266,7 +266,7 @@ function formatChoiceTransitions(stateNode) {
     if (!result || result.target === undefined) {
       throw new Error(`Choice state "${stateNode.id}" must resolve to a target.`);
     }
-    for (const key of ['actions', 'to', 'context']) {
+    for (const key of ['actions', 'to']) {
       if (result[key] !== undefined) {
         throw new Error(`Choice state "${stateNode.id}" cannot declare \`${key}\` on a choice.`);
       }
@@ -514,12 +514,53 @@ class StateMachine {
    * @param event The received event
    */
   transition(snapshot, event, actorScope) {
+    const fastSnapshot = this._transitionFast(snapshot, event, actorScope);
+    if (fastSnapshot) {
+      return [fastSnapshot, []];
+    }
     const {
       snapshot: nextSnapshot,
       microsteps
     } = dist_xstateActors.macrostep(snapshot, event, actorScope, []);
     return [nextSnapshot, microsteps.flatMap(([, actions]) => actions)];
   }
+  _transitionFast(snapshot, event, actorScope) {
+    if (snapshot.status !== 'active' || typeof snapshot.value !== 'string' || this.root.always?.length) {
+      return undefined;
+    }
+    const sourceNode = this.root.states[snapshot.value];
+    if (!sourceNode || sourceNode.type !== 'atomic' || sourceNode.exit || sourceNode.invoke.length || sourceNode.always?.length || sourceNode.after?.length) {
+      return undefined;
+    }
+    const transitions = sourceNode.transitions.get(event.type);
+    if (transitions?.length !== 1) {
+      return undefined;
+    }
+    const selected = transitions[0];
+    if (selected.guard || selected.actions || selected.to || selected.reenter || selected.input || typeof selected.context === 'function' || selected.target && selected.target.length !== 1) {
+      return undefined;
+    }
+    const targetNode = selected.target?.[0] ?? sourceNode;
+    const stateChanged = targetNode !== sourceNode;
+    if (targetNode.parent !== this.root || targetNode.type !== 'atomic' || stateChanged && (targetNode.entry || targetNode.invoke.length || targetNode.always?.length || targetNode.after?.length)) {
+      return undefined;
+    }
+    const context = selected.context !== undefined ? {
+      ...snapshot.context,
+      ...selected.context
+    } : snapshot.context;
+    const collectedMicrosteps = actorScope.self._collectedMicrosteps || [];
+    collectedMicrosteps.push(selected);
+    actorScope.self._collectedMicrosteps = collectedMicrosteps;
+    return dist_xstateActors.cloneMachineSnapshot(snapshot, {
+      ...(context !== snapshot.context ? {
+        context
+      } : {}),
+      ...(stateChanged ? {
+        _nodes: [this.root, targetNode]
+      } : {})
+    });
+  }
 
   /**
    * Determines the next state given the current `state` and `event`. Calculates

package/dist/{StateMachine-da872dde.development.cjs.js → StateMachine-3120a7ff.development.cjs.js}

@@ -1,6 +1,6 @@
 'use strict';
 
-var dist_xstateActors = require('./index-219cb621.development.cjs.js');
+var dist_xstateActors = require('./index-08d86676.development.cjs.js');
 
 function createSpawner(actorScope, {
   machine,
@@ -266,7 +266,7 @@ function formatChoiceTransitions(stateNode) {
     if (!result || result.target === undefined) {
       throw new Error(`Choice state "${stateNode.id}" must resolve to a target.`);
     }
-    for (const key of ['actions', 'to', 'context']) {
+    for (const key of ['actions', 'to']) {
       if (result[key] !== undefined) {
         throw new Error(`Choice state "${stateNode.id}" cannot declare \`${key}\` on a choice.`);
       }
@@ -528,12 +528,53 @@ class StateMachine {
    * @param event The received event
    */
   transition(snapshot, event, actorScope) {
+    const fastSnapshot = this._transitionFast(snapshot, event, actorScope);
+    if (fastSnapshot) {
+      return [fastSnapshot, []];
+    }
     const {
       snapshot: nextSnapshot,
       microsteps
     } = dist_xstateActors.macrostep(snapshot, event, actorScope, []);
     return [nextSnapshot, microsteps.flatMap(([, actions]) => actions)];
   }
+  _transitionFast(snapshot, event, actorScope) {
+    if (snapshot.status !== 'active' || typeof snapshot.value !== 'string' || this.root.always?.length) {
+      return undefined;
+    }
+    const sourceNode = this.root.states[snapshot.value];
+    if (!sourceNode || sourceNode.type !== 'atomic' || sourceNode.exit || sourceNode.invoke.length || sourceNode.always?.length || sourceNode.after?.length) {
+      return undefined;
+    }
+    const transitions = sourceNode.transitions.get(event.type);
+    if (transitions?.length !== 1) {
+      return undefined;
+    }
+    const selected = transitions[0];
+    if (selected.guard || selected.actions || selected.to || selected.reenter || selected.input || typeof selected.context === 'function' || selected.target && selected.target.length !== 1) {
+      return undefined;
+    }
+    const targetNode = selected.target?.[0] ?? sourceNode;
+    const stateChanged = targetNode !== sourceNode;
+    if (targetNode.parent !== this.root || targetNode.type !== 'atomic' || stateChanged && (targetNode.entry || targetNode.invoke.length || targetNode.always?.length || targetNode.after?.length)) {
+      return undefined;
+    }
+    const context = selected.context !== undefined ? {
+      ...snapshot.context,
+      ...selected.context
+    } : snapshot.context;
+    const collectedMicrosteps = actorScope.self._collectedMicrosteps || [];
+    collectedMicrosteps.push(selected);
+    actorScope.self._collectedMicrosteps = collectedMicrosteps;
+    return dist_xstateActors.cloneMachineSnapshot(snapshot, {
+      ...(context !== snapshot.context ? {
+        context
+      } : {}),
+      ...(stateChanged ? {
+        _nodes: [this.root, targetNode]
+      } : {})
+    });
+  }
 
   /**
    * Determines the next state given the current `state` and `event`. Calculates

package/dist/{StateMachine-d4931336.esm.js → StateMachine-614c0f36.esm.js}

@@ -1,4 +1,4 @@
-import { P as ProcessingStatus, C as resolveReferencedActor, c as createActor, S as STATE_DELIMITER, D as mapValues, t as toArray, E as createInvokeId, F as getDelayedTransitions, G as evaluateCandidate, H as formatTransition, N as NULL_EVENT, I as toTransitionConfigArray, J as createInvokeTimeoutEvent, K as getCandidates, L as formatRouteTransitions, M as resolveStateValue, O as getAllStateNodes, f as getStateNodes, Q as createMachineSnapshot, R as isInFinalState, a as macrostep, U as transitionNode, m as matchesEventDescriptor, V as resolveActionsWithContext, b as createInitEvent, d as initialMicrostep, W as toStatePath, X as isStateId, Y as getStateNodeByPath, Z as getPersistedSnapshot, $ as $$ACTOR_TYPE } from './index-8828376f.esm.js';
+import { P as ProcessingStatus, G as resolveReferencedActor, d as createActor, S as STATE_DELIMITER, H as mapValues, t as toArray, I as createInvokeId, J as getDelayedTransitions, K as evaluateCandidate, L as formatTransition, N as NULL_EVENT, M as toTransitionConfigArray, O as createInvokeTimeoutEvent, Q as getCandidates, R as formatRouteTransitions, U as resolveStateValue, V as getAllStateNodes, k as getStateNodes, W as createMachineSnapshot, Y as isInFinalState, e as macrostep, Z as cloneMachineSnapshot, _ as transitionNode, m as matchesEventDescriptor, r as resolveActionsWithContext, f as createInitEvent, g as initialMicrostep, $ as toStatePath, a0 as isStateId, a1 as getStateNodeByPath, a2 as getPersistedSnapshot, a3 as $$ACTOR_TYPE } from './index-603c1cda.esm.js';
 
 function createSpawner(actorScope, {
   machine,
@@ -264,7 +264,7 @@ function formatChoiceTransitions(stateNode) {
     if (!result || result.target === undefined) {
       throw new Error(`Choice state "${stateNode.id}" must resolve to a target.`);
     }
-    for (const key of ['actions', 'to', 'context']) {
+    for (const key of ['actions', 'to']) {
       if (result[key] !== undefined) {
         throw new Error(`Choice state "${stateNode.id}" cannot declare \`${key}\` on a choice.`);
       }
@@ -512,12 +512,53 @@ class StateMachine {
    * @param event The received event
    */
   transition(snapshot, event, actorScope) {
+    const fastSnapshot = this._transitionFast(snapshot, event, actorScope);
+    if (fastSnapshot) {
+      return [fastSnapshot, []];
+    }
     const {
       snapshot: nextSnapshot,
       microsteps
     } = macrostep(snapshot, event, actorScope, []);
     return [nextSnapshot, microsteps.flatMap(([, actions]) => actions)];
   }
+  _transitionFast(snapshot, event, actorScope) {
+    if (snapshot.status !== 'active' || typeof snapshot.value !== 'string' || this.root.always?.length) {
+      return undefined;
+    }
+    const sourceNode = this.root.states[snapshot.value];
+    if (!sourceNode || sourceNode.type !== 'atomic' || sourceNode.exit || sourceNode.invoke.length || sourceNode.always?.length || sourceNode.after?.length) {
+      return undefined;
+    }
+    const transitions = sourceNode.transitions.get(event.type);
+    if (transitions?.length !== 1) {
+      return undefined;
+    }
+    const selected = transitions[0];
+    if (selected.guard || selected.actions || selected.to || selected.reenter || selected.input || typeof selected.context === 'function' || selected.target && selected.target.length !== 1) {
+      return undefined;
+    }
+    const targetNode = selected.target?.[0] ?? sourceNode;
+    const stateChanged = targetNode !== sourceNode;
+    if (targetNode.parent !== this.root || targetNode.type !== 'atomic' || stateChanged && (targetNode.entry || targetNode.invoke.length || targetNode.always?.length || targetNode.after?.length)) {
+      return undefined;
+    }
+    const context = selected.context !== undefined ? {
+      ...snapshot.context,
+      ...selected.context
+    } : snapshot.context;
+    const collectedMicrosteps = actorScope.self._collectedMicrosteps || [];
+    collectedMicrosteps.push(selected);
+    actorScope.self._collectedMicrosteps = collectedMicrosteps;
+    return cloneMachineSnapshot(snapshot, {
+      ...(context !== snapshot.context ? {
+        context
+      } : {}),
+      ...(stateChanged ? {
+        _nodes: [this.root, targetNode]
+      } : {})
+    });
+  }
 
   /**
    * Determines the next state given the current `state` and `event`. Calculates

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

@@ -63,6 +63,7 @@ export declare class StateMachine<TContext extends MachineContext, TEvent extend
      * @param event The received event
      */
     transition(snapshot: MachineSnapshot<TContext, TEvent, TChildren, TStateValue, TTag, TOutput, TMeta, TConfig>, event: TEvent, actorScope: ActorScope<typeof snapshot, TEvent, AnyActorSystem, TEmitted>): ActorLogicTransitionResult<MachineSnapshot<TContext, TEvent, TChildren, TStateValue, TTag, TOutput, TMeta, TConfig>, ExecutableActionObjectFromLogic<this>>;
+    private _transitionFast;
     /**
      * Determines the next state given the current `state` and `event`. Calculates
      * a microstep.

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

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

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

@@ -1,6 +1,6 @@
 import { symbolObservable } from "./symbolObservable.js";
 import { AnyActorSystem, Clock } from "./system.js";
-import type { AnyActor, AnyActorLogic, EmittedFrom, EventFromLogic, SendableEventFromLogic, InputFrom, Snapshot, SnapshotFrom, Readable } from "./types.js";
+import type { ActorTrigger, AnyActor, AnyActorLogic, EmittedFrom, EventFromLogic, SendableEventFromLogic, InputFrom, Snapshot, SnapshotFrom, Readable } from "./types.js";
 import { ActorOptions, ActorInstance, ActorRef, InteropSubscribable, Observer, Subscription } from "./types.js";
 export declare const $$ACTOR_TYPE = 1;
 export declare enum ProcessingStatus {
@@ -45,13 +45,7 @@ export declare class Actor<TLogic extends AnyActorLogic> implements ActorInstanc
     sessionId: string;
     /** The system to which this actor belongs. */
     system: AnyActorSystem;
-    trigger: {
-        [K in SendableEventFromLogic<TLogic>['type']]: {} extends Omit<Extract<SendableEventFromLogic<TLogic>, {
-            type: K;
-        }>, 'type'> ? () => void : (payload: Omit<Extract<SendableEventFromLogic<TLogic>, {
-            type: K;
-        }>, 'type'>) => void;
-    };
+    trigger: ActorTrigger<SendableEventFromLogic<TLogic>>;
     src: string | AnyActorLogic;
     /**
      * Creates a new actor instance for the given logic with the provided options,

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

@@ -90,44 +90,64 @@ 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;
     registryKey?: string;
-    src: string | UnserializableMarker;
+    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[]>;
+    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)
@@ -139,16 +159,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;
@@ -156,22 +176,33 @@ export interface StateNodeJSON {
     _scxmlDonedata?: ScxmlDonedataJSON;
 }
 export interface MachineJSON extends StateNodeJSON {
+    '@exprLang'?: string;
     version?: string;
-    actions?: Record<string, unknown>;
-    guards?: Record<string, unknown>;
+    actions?: Record<string, ActionJSON | ActionJSON[]>;
+    guards?: Record<string, {
+        when: ConditionJSON;
+    }>;
     actorSources?: Record<string, unknown>;
-    delays?: 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>;
     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/index.d.ts

@@ -2,9 +2,10 @@ export * from "./actors/index.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 CodeExpression, 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 { createSystem, setup } from "./setup.js";

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

@@ -4,34 +4,20 @@
  * `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:
- * functions are represented as code expressions, while actor logic, runtime
- * schemas, and other non-code runtime values are 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`/`actorSources` maps on `createMachineFromConfig`
- * revival).
+ * 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 {
-    '@type': 'code';
-    lang: 'ts';
-    expr: string;
+    '@code': string;
+    '@lang': 'ts';
 }
 /**
  * Returns the JSON-serializable definition of a machine.
  *
- * Inline functions are represented as `{ "@type": "code", lang: "ts", expr }`.
- * Actor logic and runtime schemas 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';
@@ -45,6 +31,6 @@ export interface CodeExpression {
 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>;