xstate 5.32.1 → 6.0.0-alpha.2

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

@@ -1,5 +1,7 @@
+import { StandardSchemaV1 } from "./schema.types.js";
 import { StateMachine } from "./StateMachine.js";
-import { ResolvedStateMachineTypes, TODO, AnyActorRef, EventObject, AnyEventObject, Cast, InternalMachineImplementations, MachineConfig, MachineContext, MachineTypes, NonReducibleUnknown, ParameterizedObject, ProvidedActor, StateValue, ToChildren, MetaObject } from "./types.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";
 /**
  * Creates a state machine (statechart) with the given configuration.
  *
@@ -42,9 +44,35 @@ import { ResolvedStateMachineTypes, TODO, AnyActorRef, EventObject, AnyEventObje
  * @param options DEPRECATED: use `setup({ ... })` or `machine.provide({ ... })`
  *   to provide machine implementations instead.
  */
-export declare function createMachine<TContext extends MachineContext, TEvent extends AnyEventObject, // TODO: consider using a stricter `EventObject` here
-TActor extends ProvidedActor, TAction extends ParameterizedObject, TGuard extends ParameterizedObject, TDelay extends string, TTag extends string, TInput, TOutput extends NonReducibleUnknown, TEmitted extends EventObject, TMeta extends MetaObject, _ = any>(config: {
-    types?: MachineTypes<TContext, TEvent, TActor, TAction, TGuard, TDelay, TTag, TInput, TOutput, TEmitted, TMeta>;
-    schemas?: unknown;
-} & MachineConfig<TContext, TEvent, TActor, TAction, TGuard, TDelay, TTag, TInput, TOutput, TEmitted, TMeta>, implementations?: InternalMachineImplementations<ResolvedStateMachineTypes<TContext, TEvent, TActor, TAction, TGuard, TDelay, TTag, TEmitted>>): StateMachine<TContext, TEvent, Cast<ToChildren<TActor>, Record<string, AnyActorRef | undefined>>, TActor, TAction, TGuard, TDelay, StateValue, TTag & string, TInput, TOutput, TEmitted, TMeta, // TMeta
-TODO>;
+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> & {
+    schemas: {
+        context: TContextSchema;
+    };
+}): 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
+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> & {
+    schemas?: {
+        context?: never;
+    };
+    context?: TContext | ((_: {
+        spawn: any;
+        actors: TActorMap;
+        input: InferOutput<TInputSchema, unknown>;
+        self: any;
+    }) => TContext);
+}): 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
+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;

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

@@ -0,0 +1,176 @@
+import { AnyActorLogic, AnyEventObject, AnyStateMachine, EventObject, MachineContext, MetaObject } from "./types.js";
+export interface RaiseJSON {
+    type: '@xstate.raise';
+    event: EventObject;
+    id?: string;
+    delay?: number;
+}
+export interface CancelJSON {
+    type: '@xstate.cancel';
+    id: string;
+}
+export interface LogJSON {
+    type: '@xstate.log';
+    args: any[];
+}
+interface EmitJSON {
+    type: '@xstate.emit';
+    event: AnyEventObject;
+}
+interface AssignJSON {
+    type: '@xstate.assign';
+    context: MachineContext;
+}
+interface ScxmlAssignJSON {
+    type: 'scxml.assign';
+    /** SCXML location attribute - the context property to assign to */
+    location: string;
+    /** SCXML expr attribute - expression to evaluate */
+    expr: string;
+}
+export interface ScxmlRaiseJSON {
+    type: 'scxml.raise';
+    /** Event type, or undefined if using eventexpr */
+    event?: string;
+    /** Expression to evaluate for event type */
+    eventexpr?: string;
+    /** Params with expressions to evaluate */
+    params?: Array<{
+        name: string;
+        expr: string;
+    }>;
+    id?: string;
+    delay?: number;
+    /** Expression for delay */
+    delayexpr?: string;
+    /** Static target (e.g. '#_parent') */
+    target?: string;
+    /** Expression for target */
+    targetexpr?: string;
+}
+interface ScxmlScriptJSON {
+    type: 'scxml.script';
+    /** The script code to execute */
+    code: string;
+}
+export interface ScxmlForeachJSON {
+    type: 'scxml.foreach';
+    array: string;
+    item: string;
+    index?: string;
+    actions: ActionJSON[];
+}
+export interface ScxmlCancelJSON {
+    type: 'scxml.cancel';
+    sendidexpr: string;
+}
+export interface ScxmlDonedataJSON {
+    params?: Array<{
+        name: string;
+        expr: string;
+    }>;
+    contentExpr?: string;
+    contentText?: string;
+}
+/**
+ * Isolated executable-content block. Errors in nested actions stop this block
+ * but do not propagate to the surrounding action list. Used to model SCXML's
+ * separate <onentry>/<onexit> blocks: each is its own block per spec.
+ */
+interface ScxmlBlockJSON {
+    type: 'scxml.block';
+    actions: ActionJSON[];
+}
+interface ScxmlIfJSON {
+    type: 'scxml.if';
+    branches: Array<{
+        cond?: string;
+        actions: ActionJSON[];
+    }>;
+}
+interface CustomActionJSON {
+    type: string;
+    params?: Record<string, unknown>;
+}
+export type ActionJSON = CustomActionJSON | RaiseJSON | CancelJSON | LogJSON | EmitJSON | AssignJSON | ScxmlAssignJSON | ScxmlRaiseJSON | ScxmlScriptJSON | ScxmlIfJSON | ScxmlForeachJSON | ScxmlCancelJSON | ScxmlBlockJSON;
+export interface GuardJSON {
+    type: string;
+    params?: Record<string, unknown>;
+}
+export interface InvokeJSON {
+    id?: string;
+    systemId?: string;
+    src: string | UnserializableMarker;
+    input?: unknown;
+    onDone?: TransitionJSON | TransitionJSON[];
+    onError?: TransitionJSON | TransitionJSON[];
+    onSnapshot?: TransitionJSON | TransitionJSON[];
+    timeout?: number | string;
+    onTimeout?: TransitionJSON | TransitionJSON[];
+}
+export interface TransitionJSON {
+    target?: string | string[];
+    actions?: ActionJSON[];
+    guard?: GuardJSON;
+    description?: string;
+    reenter?: boolean;
+    meta?: MetaObject;
+    input?: unknown;
+}
+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;
+    /**
+     * 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)
+     * resolved against the machine's `guards` implementations.
+     */
+    route?: {
+        description?: string;
+        reenter?: boolean;
+        meta?: MetaObject;
+        guard?: string;
+        input?: Record<string, unknown>;
+    };
+    invoke?: InvokeJSON | InvokeJSON[];
+    entry?: ActionJSON[];
+    exit?: ActionJSON[];
+    meta?: MetaObject;
+    description?: string;
+    tags?: string[];
+    input?: unknown;
+    timeout?: number | string;
+    onTimeout?: TransitionJSON | TransitionJSON[];
+    history?: 'shallow' | 'deep';
+    target?: string;
+    output?: unknown;
+    context?: Record<string, unknown>;
+    _scxmlDonedata?: ScxmlDonedataJSON;
+}
+export interface MachineJSON extends StateNodeJSON {
+    version?: string;
+    actions?: Record<string, unknown>;
+    guards?: Record<string, unknown>;
+    actors?: Record<string, unknown>;
+    delays?: Record<string, unknown>;
+    schemas?: Record<string, unknown>;
+}
+interface UnserializableMarker {
+    $unserializable: 'function' | 'actor' | 'schema' | 'value';
+    id?: string;
+}
+interface MachineImplementations {
+    actions?: Record<string, (...args: any[]) => unknown>;
+    guards?: Record<string, (...args: any[]) => boolean>;
+    actors?: Record<string, AnyActorLogic>;
+    delays?: Record<string, number | ((...args: any[]) => number)>;
+}
+export declare function createMachineFromConfig(json: MachineJSON, implementations?: MachineImplementations): AnyStateMachine;
+export {};

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

@@ -1,11 +1,13 @@
-import { EventObject, AnyStateMachine, AnyActorLogic, EventFromLogic, Snapshot, InputFrom } from "../index.js";
+import { EventObject, AnyStateMachine, StateNode, AnyActorLogic, EventFromLogic, Snapshot, InputFrom } from "../index.js";
 import type { SerializedSnapshot, StatePath, DirectedGraphNode, TraversalOptions, AnyStateNode, TraversalConfig } from "./types.js";
 /**
  * Returns all state nodes of the given `node`.
  *
  * @param stateNode State node to recursively get child state nodes from
  */
-export declare function getStateNodes(stateNode: AnyStateNode | AnyStateMachine): AnyStateNode[];
+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 createDefaultLogicOptions(): TraversalOptions<any, any, any>;

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

@@ -1,14 +1,17 @@
-export * from "./actions.js";
 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, interpret, type Interpreter, type RequiredActorOptionsKeys as RequiredActorOptionsKeys } from "./createActor.js";
-export { createMachine } from "./createMachine.js";
+export { Actor, createActor, type RequiredActorOptionsKeys as RequiredActorOptionsKeys } from "./createActor.js";
+export { createMachine, createStateConfig } from "./createMachine.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 { mapState } from "./mapState.js";
+export { types, isTypeSchema, type StandardSchemaV1, type TypeSchema } from "./schema.types.js";
+export { setup } from "./setup.js";
 export { getInitialSnapshot, getNextSnapshot } from "./getNextSnapshot.js";
-export { and, not, or, stateIn } from "./guards.js";
-export type { GuardPredicate, GuardArgs } from "./guards.js";
-export type { InspectedActionEvent, InspectedActorEvent, InspectedEventEvent, InspectedMicrostepEvent, InspectedSnapshotEvent, InspectedTransitionEvent, InspectionEvent } from "./inspection.js";
-export { setup, type SetupReturn } from "./setup.js";
+export type { InspectionEvent, ActorInspectionEvent, TransitionInspectionEvent, ActionRecord, SentRecord } from "./inspection.js";
 export { SimulatedClock } from "./SimulatedClock.js";
 export { type Spawner } from "./spawn.js";
 export { isMachineSnapshot, type MachineSnapshot } from "./State.js";
@@ -18,7 +21,8 @@ export { getStateNodes } from "./stateUtils.js";
 export type { ActorSystem } from "./system.js";
 export { toPromise } from "./toPromise.js";
 export * from "./types.js";
-export { getAllOwnEventDescriptors as __unsafe_getAllOwnEventDescriptors, matchesState, pathToStateValue, toObserver } from "./utils.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 { waitFor } from "./waitFor.js";
 declare global {

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

@@ -1,45 +1,99 @@
-import { ActorRefLike, AnyEventObject, AnyTransitionDefinition, Snapshot } from "./types.js";
-export type InspectionEvent = InspectedSnapshotEvent | InspectedEventEvent | InspectedActorEvent | InspectedTransitionEvent | InspectedMicrostepEvent | InspectedActionEvent;
+import { ActorRefLike, AnyActorLogic, AnyEventObject, AnyTransitionDefinition, Snapshot } from "./types.js";
+/**
+ * A record of a single action executed during a transition.
+ *
+ * Carried in {@link TransitionInspectionEvent.actions}, this replaces the v5
+ * standalone `@xstate.action` inspection event.
+ */
+export interface ActionRecord {
+    /** The action type (e.g. the action creator name or `'(anonymous)'`). */
+    type: string;
+    /** The resolved params for the action, if any. */
+    params: unknown;
+}
+/**
+ * A record of a single event relayed to another actor during a transition.
+ *
+ * Carried in {@link TransitionInspectionEvent.sent}, this captures the send on
+ * the _sender's_ transition — including delayed/scheduled sends that may never
+ * deliver — distinct from the target actor's own processed-event transition.
+ */
+export interface SentRecord {
+    /** The actor the event was sent to. */
+    targetRef: ActorRefLike;
+    /** The `id` of the target actor. */
+    targetId: string;
+    /** The event that was sent. */
+    event: AnyEventObject;
+    /** The delay (ms) for a scheduled send, or `undefined` for an immediate send. */
+    delay?: number;
+    /** The scheduling id for a scheduled send, used for cancellation. */
+    id?: string;
+}
 interface BaseInspectionEventProperties {
+    /** The session ID of the root actor. */
     rootId: string;
     /**
      * The relevant actorRef for the inspection event.
      *
-     * - For snapshot events, this is the `actorRef` of the snapshot.
-     * - For event events, this is the target `actorRef` (recipient of event).
-     * - For actor events, this is the `actorRef` of the registered actor.
+     * - For `@xstate.actor` events, this is the registered actor.
+     * - For `@xstate.transition` events, this is the actor that transitioned.
      */
     actorRef: ActorRefLike;
 }
-export interface InspectedSnapshotEvent extends BaseInspectionEventProperties {
-    type: '@xstate.snapshot';
-    event: AnyEventObject;
+/**
+ * Announces that an actor was created in the system (the root actor and every
+ * spawned/invoked child). This is the single topology event — it carries the
+ * actor identity and parent relationship needed to draw the actor graph before
+ * any transitions occur.
+ *
+ * Actor _stop_ is derivable from `snapshot.status` on the actor's final
+ * `@xstate.transition` event, so there is no separate stop event.
+ */
+export interface ActorInspectionEvent extends BaseInspectionEventProperties {
+    type: '@xstate.actor';
+    /** The parent actor, or `undefined` for the root actor. */
+    parentRef: ActorRefLike | undefined;
+    /** The `id` of the actor. */
+    id: string;
+    /** The source logic (or its referenced string) the actor was created from. */
+    src: string | AnyActorLogic;
+    /** The initial snapshot of the actor. */
     snapshot: Snapshot<unknown>;
 }
-export interface InspectedTransitionEvent extends BaseInspectionEventProperties {
+/**
+ * Announces an actor transition.
+ *
+ * All facets are flat and always present so consumers can read `event.actions`,
+ * `event.sent`, and `event.microsteps` directly without narrowing on absent
+ * properties. This is a superset of the v5
+ * `@xstate.event`/`@xstate.snapshot`/`@xstate.action`/`@xstate.microstep`
+ * events.
+ */
+export interface TransitionInspectionEvent extends BaseInspectionEventProperties {
     type: '@xstate.transition';
+    eventType: string;
+    /** The event that caused the transition. */
     event: AnyEventObject;
-    snapshot: Snapshot<unknown>;
-}
-export interface InspectedMicrostepEvent extends BaseInspectionEventProperties {
-    type: '@xstate.microstep';
-    event: AnyEventObject;
-    snapshot: Snapshot<unknown>;
-    _transitions: AnyTransitionDefinition[];
-}
-export interface InspectedActionEvent extends BaseInspectionEventProperties {
-    type: '@xstate.action';
-    action: {
-        type: string;
-        params: unknown;
-    };
-}
-export interface InspectedEventEvent extends BaseInspectionEventProperties {
-    type: '@xstate.event';
+    /** The source actor that sent the event, if any. */
     sourceRef: ActorRefLike | undefined;
-    event: AnyEventObject;
-}
-export interface InspectedActorEvent extends BaseInspectionEventProperties {
-    type: '@xstate.actor';
+    /** The target actor of the transition (usually the same as `actorRef`). */
+    targetRef: ActorRefLike | undefined;
+    /** The resulting snapshot of the transition. */
+    snapshot: Snapshot<unknown>;
+    /** The microstep transition definitions taken (always present). */
+    microsteps: AnyTransitionDefinition[];
+    /** The actions executed during the transition (always present). */
+    actions: ActionRecord[];
+    /** The events relayed to other actors during the transition (always present). */
+    sent: SentRecord[];
 }
+/**
+ * A lossless, two-event inspection protocol:
+ *
+ * - `@xstate.actor` — actor topology (identity + parent), drawable up front.
+ * - `@xstate.transition` — every transition facet: event, snapshot, source,
+ *   microsteps, executed actions, and sent/scheduled events.
+ */
+export type InspectionEvent = ActorInspectionEvent | TransitionInspectionEvent;
 export {};

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

@@ -1,4 +1,6 @@
-import { AnyMachineSnapshot, AnyStateNode, StateSchema, StateSchemaFrom } from "./types.js";
+import { MachineSnapshot } from "./State.js";
+import { AnyMachineSnapshot, AnyStateNode, StateSchema } from "./types.js";
+type StateSchemaFromSnapshot<TSnapshot extends AnyMachineSnapshot> = TSnapshot extends MachineSnapshot<infer _TContext, infer _TEvent, infer _TChildren, infer _TStateValue, infer _TTag, infer _TOutput, infer _TMeta, infer TStateSchema extends StateSchema> ? TStateSchema : StateSchema;
 /**
  * A mapper object that defines how to transform a snapshot based on its state.
  * Can be nested to match the state hierarchy of the machine.
@@ -18,7 +20,7 @@ type StateSchemaMapper<TSnapshot extends AnyMachineSnapshot, T extends StateSche
  * collects results from matching `map` functions in the mapper object. Results
  * are ordered leaf-to-root (most specific state first).
  */
-export declare function mapState<T extends AnyMachineSnapshot, TResult>(snapshot: T, mapper: StateSchemaMapper<T, StateSchemaFrom<T['machine']>, TResult>): {
+export declare function mapState<T extends AnyMachineSnapshot, TResult>(snapshot: T, mapper: StateSchemaMapper<T, StateSchemaFromSnapshot<T>, TResult>): {
     stateNode: AnyStateNode;
     result: TResult;
 }[];

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

@@ -0,0 +1,90 @@
+/** The Standard Schema interface. */
+export interface StandardSchemaV1<Input = unknown, Output = Input> {
+    /** The Standard Schema properties. */
+    readonly '~standard': StandardSchemaV1.Props<Input, Output>;
+}
+/** A type-only Standard Schema produced by {@link types}. */
+export interface TypeSchema<T> extends StandardSchemaV1<T, T> {
+    readonly '~standard': StandardSchemaV1.Props<T, T> & {
+        readonly vendor: 'xstate.types';
+    };
+}
+/**
+ * Declares schema types for inference only — no runtime validation.
+ *
+ * Use in a machine's `schemas` when you want TypeScript types without pulling
+ * in a schema library like Zod. The returned value is a valid Standard Schema
+ * whose validation is the identity function, so it carries types but never
+ * rejects input.
+ *
+ * @example
+ *
+ * ```ts
+ * import { createMachine, types } from 'xstate';
+ *
+ * const machine = createMachine({
+ *   schemas: {
+ *     context: types<{ count: number }>(),
+ *     events: {
+ *       inc: types<{ by: number }>(),
+ *       reset: types<{}>()
+ *     }
+ *   },
+ *   context: { count: 0 }
+ *   // ...
+ * });
+ * ```
+ */
+export declare function types<T>(): TypeSchema<T>;
+/** Returns true if the value is a type-only schema created by {@link types}. */
+export declare function isTypeSchema(value: unknown): value is TypeSchema<unknown>;
+export declare namespace StandardSchemaV1 {
+    /** The Standard Schema properties interface. */
+    interface Props<Input = unknown, Output = Input> {
+        /** The version number of the standard. */
+        readonly version: 1;
+        /** The vendor name of the schema library. */
+        readonly vendor: string;
+        /** Validates unknown input values. */
+        readonly validate: (value: unknown) => Result<Output> | Promise<Result<Output>>;
+        /** Inferred types associated with the schema. */
+        readonly types?: Types<Input, Output> | undefined;
+    }
+    /** The result interface of the validate function. */
+    type Result<Output> = SuccessResult<Output> | FailureResult;
+    /** The result interface if validation succeeds. */
+    interface SuccessResult<Output> {
+        /** The typed output value. */
+        readonly value: Output;
+        /** The non-existent issues. */
+        readonly issues?: undefined;
+    }
+    /** The result interface if validation fails. */
+    interface FailureResult {
+        /** The issues of failed validation. */
+        readonly issues: ReadonlyArray<Issue>;
+    }
+    /** The issue interface of the failure output. */
+    interface Issue {
+        /** The error message of the issue. */
+        readonly message: string;
+        /** The path of the issue, if any. */
+        readonly path?: ReadonlyArray<PropertyKey | PathSegment> | undefined;
+    }
+    /** The path segment interface of the issue. */
+    interface PathSegment {
+        /** The key representing a path segment. */
+        readonly key: PropertyKey;
+    }
+    /** The Standard Schema types interface. */
+    interface Types<Input = unknown, Output = Input> {
+        /** The input type of the schema. */
+        readonly input: Input;
+        /** The output type of the schema. */
+        readonly output: Output;
+    }
+    /** Infers the input type of a Standard Schema. */
+    type InferInput<Schema extends StandardSchemaV1> = NonNullable<Schema['~standard']['types']>['input'];
+    /** Infers the output type of a Standard Schema. */
+    type InferOutput<Schema extends StandardSchemaV1> = NonNullable<Schema['~standard']['types']>['output'];
+}

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

@@ -0,0 +1,44 @@
+/**
+ * Machine-definition serialization.
+ *
+ * `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).
+ */
+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;
+}
+/**
+ * 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):
+ *
+ * ```ts
+ * import { serializeMachine, createMachineFromConfig } from 'xstate';
+ *
+ * const json = serializeMachine(machine);
+ * const revived = createMachineFromConfig(
+ *   JSON.parse(JSON.stringify(json))
+ * );
+ * ```
+ */
+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.
+ */
+export declare function machineConfigToJSON(config: Record<string, unknown>): Record<string, unknown>;