xstate 6.0.0-alpha.2 → 6.0.0-alpha.3

package/dist/{StateMachine-8d22a79c.development.cjs.js → StateMachine-0770ac71.development.cjs.js}

@@ -1,6 +1,6 @@
 'use strict';
 
-var dist_xstateActors = require('./index-f6ef20d1.development.cjs.js');
+var dist_xstateActors = require('./index-269d256d.development.cjs.js');
 
 function createSpawner(actorScope, {
   machine,

package/dist/{StateMachine-2dcdb1f5.esm.js → StateMachine-8249d511.esm.js}

@@ -1,4 +1,4 @@
-import { P as ProcessingStatus, G as resolveReferencedActor, c 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, n as getStateNodes, W as createMachineSnapshot, X as isInFinalState, a as macrostep, Y as transitionNode, m as matchesEventDescriptor, Z as resolveAndExecuteActionsWithContext, b as createInitEvent, d as initialMicrostep, _ as toStatePath, $ as isStateId, a0 as getStateNodeByPath, a1 as getPersistedSnapshot, a2 as $$ACTOR_TYPE } from './index-93edd3bd.esm.js';
+import { P as ProcessingStatus, B as resolveReferencedActor, c as createActor, S as STATE_DELIMITER, C as mapValues, t as toArray, D as createInvokeId, E as getDelayedTransitions, F as evaluateCandidate, G as formatTransition, N as NULL_EVENT, H as toTransitionConfigArray, I as createInvokeTimeoutEvent, J as getCandidates, K as formatRouteTransitions, L as resolveStateValue, M as getAllStateNodes, f as getStateNodes, O as createMachineSnapshot, Q as isInFinalState, a as macrostep, R as transitionNode, m as matchesEventDescriptor, U as resolveAndExecuteActionsWithContext, b as createInitEvent, d as initialMicrostep, V as toStatePath, W as isStateId, X as getStateNodeByPath, Y as getPersistedSnapshot, $ as $$ACTOR_TYPE } from './index-a7e3d8b3.esm.js';
 
 function createSpawner(actorScope, {
   machine,

package/dist/{StateMachine-64813f46.cjs.js → StateMachine-e1048cd6.cjs.js}

@@ -1,6 +1,6 @@
 'use strict';
 
-var dist_xstateActors = require('./index-9cb3b3a0.cjs.js');
+var dist_xstateActors = require('./index-dda021d5.cjs.js');
 
 function createSpawner(actorScope, {
   machine,

package/dist/{StateMachine-2ea0a7fa.development.esm.js → StateMachine-e6ad61d0.development.esm.js}

@@ -1,4 +1,4 @@
-import { P as ProcessingStatus, G as resolveReferencedActor, c 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, n as getStateNodes, W as createMachineSnapshot, X as isInFinalState, a as macrostep, Y as transitionNode, m as matchesEventDescriptor, Z as resolveAndExecuteActionsWithContext, b as createInitEvent, d as initialMicrostep, _ as toStatePath, $ as isStateId, a0 as getStateNodeByPath, a1 as getPersistedSnapshot, a2 as $$ACTOR_TYPE } from './index-e61170ba.development.esm.js';
+import { P as ProcessingStatus, B as resolveReferencedActor, c as createActor, S as STATE_DELIMITER, C as mapValues, t as toArray, D as createInvokeId, E as getDelayedTransitions, F as evaluateCandidate, G as formatTransition, N as NULL_EVENT, H as toTransitionConfigArray, I as createInvokeTimeoutEvent, J as getCandidates, K as formatRouteTransitions, L as resolveStateValue, M as getAllStateNodes, f as getStateNodes, O as createMachineSnapshot, Q as isInFinalState, a as macrostep, R as transitionNode, m as matchesEventDescriptor, U as resolveAndExecuteActionsWithContext, b as createInitEvent, d as initialMicrostep, V as toStatePath, W as isStateId, X as getStateNodeByPath, Y as getPersistedSnapshot, $ as $$ACTOR_TYPE } from './index-66ff64a6.development.esm.js';
 
 function createSpawner(actorScope, {
   machine,

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

@@ -2,16 +2,16 @@ import { MachineSnapshot } from "./State.js";
 import { StateNode } from "./StateNode.js";
 import { AnyActorSystem } from "./system.js";
 import type { ActorLogic, ActorScope, AnyActor, AnyActorRef, AnyActorScope, AnyTransitionDefinition, Equals, EventDescriptor, EventObject, HistoryValue, MachineContext, MetaObject, Snapshot, StateValue, StateSchema, SnapshotStatus } from "./types.js";
-import { Implementations, Next_MachineConfig, MachineOptions } from "./types.v6.js";
+import { AnyMachineSchemas, Implementations, Next_MachineConfig, MachineOptions } from "./types.v6.js";
 export declare class StateMachine<TContext extends MachineContext, TEvent extends EventObject, TChildren extends Record<string, AnyActorRef | undefined>, TStateValue extends StateValue, TTag extends string, TInput, TOutput, TEmitted extends EventObject, TMeta extends MetaObject, TConfig extends StateSchema, TActionMap extends Implementations['actions'], TActorMap extends Implementations['actors'], TGuardMap extends Implementations['guards'], TDelayMap extends Implementations['delays']> implements ActorLogic<MachineSnapshot<TContext, TEvent, TChildren, TStateValue, TTag, TOutput, TMeta, TConfig>, TEvent, TInput, AnyActorSystem, TEmitted> {
     /** The raw config used to create the machine. */
     config: Next_MachineConfig<any, any, any, any, any, any, any, any, any, any> & {
-        schemas?: unknown;
+        schemas?: AnyMachineSchemas;
         internalEvents?: readonly string[];
     };
     /** The machine's own version. */
     version?: string;
-    schemas: unknown;
+    schemas: AnyMachineSchemas | undefined;
     implementations: Implementations;
     /** Runtime options for machine execution. */
     options: MachineOptions;
@@ -23,7 +23,7 @@ export declare class StateMachine<TContext extends MachineContext, TEvent extend
     constructor(
     /** The raw config used to create the machine. */
     config: Next_MachineConfig<any, any, any, any, any, any, any, any, any, any> & {
-        schemas?: unknown;
+        schemas?: AnyMachineSchemas;
         internalEvents?: readonly string[];
     }, implementations?: Implementations);
     /**

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

@@ -177,8 +177,6 @@ export declare class Actor<TLogic extends AnyActorLogic> implements ActorInstanc
      * @see {@link Actor.getPersistedSnapshot} to persist the internal state of an actor (which is more than just a snapshot).
      */
     getSnapshot(): SnapshotFrom<TLogic>;
-    /** Read the actor's current snapshot as an atom value. */
-    get(): SnapshotFrom<TLogic>;
 }
 export type RequiredActorOptionsKeys<TLogic extends AnyActorLogic> = undefined extends InputFrom<TLogic> ? never : 'input';
 /**

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

@@ -1,12 +1,10 @@
 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 { 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, 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";

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

@@ -3,10 +3,10 @@
  *
  * `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.
+ * 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
@@ -19,13 +19,18 @@ export interface UnserializableMarker {
     /** Best-effort identifier (function name, actor logic id) for diagnostics. */
     id?: string;
 }
+export interface CodeExpression {
+    '@type': 'code';
+    lang: 'ts';
+    expr: 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):
+ * 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):
  *
  * ```ts
  * import { serializeMachine, createMachineFromConfig } from 'xstate';

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

@@ -2,7 +2,6 @@ import type { MachineSnapshot } from "./State.js";
 import type { StateMachine } from "./StateMachine.js";
 import type { StateNode } from "./StateNode.js";
 import { AsyncActorLogic } from "./actors/promise.js";
-import type { BaseAtom } from "./atom.js";
 import type { Actor } from "./createActor.js";
 import { InspectionEvent } from "./inspection.js";
 import { Spawner } from "./spawn.js";
@@ -1019,9 +1018,6 @@ export type EnqueueObject<TEvent extends EventObject, TEmittedEvent extends Even
      */
     subscribeTo: {
         <TSnapshot extends Snapshot<unknown>, TOutput, TMappedEvent extends TEvent>(actor: AnyActor, mappers: SubscribeToMappers<TSnapshot, TOutput, TMappedEvent> | ((snapshot: TSnapshot) => TMappedEvent)): AnyActor;
-        <TValue, TMappedEvent extends TEvent>(atom: BaseAtom<TValue>, mappers: {
-            snapshot?: (value: TValue) => TMappedEvent;
-        } | ((value: TValue) => TMappedEvent)): AnyActor;
     };
 };
 export type Action<TContext extends MachineContext, TEvent extends EventObject, TEmittedEvent extends EventObject, TActionMap extends Implementations['actions'], TActorMap extends Implementations['actors'], TGuardMap extends Implementations['guards'], TDelayMap extends Implementations['delays'], TParams = Record<string, unknown> | undefined, _TCtx = [TContext] extends [never] ? any : TContext> = (_: {

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

@@ -46,17 +46,19 @@ export interface MachineOptions {
      */
     maxIterations?: number;
 }
+type MachineSchemas<TContextSchema extends StandardSchemaV1, TEventSchemaMap extends Record<string, StandardSchemaV1>, TEmittedSchemaMap extends Record<string, StandardSchemaV1>, TInputSchema extends StandardSchemaV1, TOutputSchema extends StandardSchemaV1, TMetaSchema extends StandardSchemaV1, TTagSchema extends StandardSchemaV1> = {
+    events?: TEventSchemaMap;
+    context?: TContextSchema;
+    emitted?: TEmittedSchemaMap;
+    input?: TInputSchema;
+    output?: TOutputSchema;
+    meta?: TMetaSchema;
+    tags?: TTagSchema;
+};
+export type AnyMachineSchemas = MachineSchemas<StandardSchemaV1, Record<string, StandardSchemaV1>, Record<string, StandardSchemaV1>, StandardSchemaV1, StandardSchemaV1, StandardSchemaV1, StandardSchemaV1>;
 export type Next_MachineConfig<TContextSchema extends StandardSchemaV1, TEventSchemaMap extends Record<string, StandardSchemaV1>, TEmittedSchemaMap extends Record<string, StandardSchemaV1>, TInputSchema extends StandardSchemaV1, TOutputSchema extends StandardSchemaV1, TMetaSchema extends StandardSchemaV1, TTagSchema extends StandardSchemaV1, TContext extends MachineContext = InferOutput<TContextSchema, MachineContext>, TEvent extends EventObject = InferEvents<TEventSchemaMap>, TDelays extends string = string, _TTag extends string = string, TActionMap extends Implementations['actions'] = Implementations['actions'], TActorMap extends Implementations['actors'] = Implementations['actors'], TGuardMap extends Implementations['guards'] = Implementations['guards'], TDelayMap extends Implementations['delays'] = Implementations['delays'], TContextRequired extends boolean = IsNever<TContext> extends true ? false : true> = (DistributiveOmit<Next_StateNodeConfig<TContext, DoNotInfer<InferEvents<TEventSchemaMap>>, DoNotInfer<TDelays>, DoNotInfer<StandardSchemaV1.InferOutput<TTagSchema> & string>, DoNotInfer<StandardSchemaV1.InferOutput<TOutputSchema>>, DoNotInfer<InferEvents<TEmittedSchemaMap>>, DoNotInfer<InferOutput<TMetaSchema, MetaObject>>, DoNotInfer<TActionMap>, DoNotInfer<TActorMap>, DoNotInfer<TGuardMap>, DoNotInfer<TDelayMap>>, 'output'> & {
     internalEvents?: readonly InternalEventDescriptorFor<InferEvents<TEventSchemaMap>>[];
-    schemas?: {
-        events?: TEventSchemaMap;
-        context?: TContextSchema;
-        emitted?: TEmittedSchemaMap;
-        input?: TInputSchema;
-        output?: TOutputSchema;
-        meta?: TMetaSchema;
-        tags?: TTagSchema;
-    };
+    schemas?: MachineSchemas<TContextSchema, TEventSchemaMap, TEmittedSchemaMap, TInputSchema, TOutputSchema, TMetaSchema, TTagSchema>;
     actions?: TActionMap;
     guards?: TGuardMap;
     actors?: TActorMap;