xstate 6.0.0-beta.1 → 6.0.0-beta.3

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

@@ -1,7 +1,7 @@
 import { type ExecutableEffectDescriptor } from "../effectDescriptor.js";
 import { type ActorSystemRuntime } from "../system.js";
 import type { InspectionEvent } from "../inspection.js";
-import type { AnyActor, AnyActorLogic, AnyEventObject, CustomExecutableEffect, EventFromLogic, ExecutableEffectFrom, InputFrom, OutputFrom, Snapshot, SnapshotFrom } from "../types.js";
+import type { AnyActor, AnyActorLogic, AnyEventObject, CustomExecutableEffect, EventFromLogic, ExecutableEffectFrom, InputFrom, OutputFrom, SerializedActorRef, Snapshot, SnapshotFrom } from "../types.js";
 /** @experimental */
 export interface DurableEffectMetadata {
     /** Stable within one durable execution. */
@@ -26,6 +26,28 @@ export interface DurableRootEvent<TEvent> {
     event: TEvent;
     source: AnyActor | undefined;
 }
+/**
+ * A root-addressed event that the execution received but has not processed,
+ * stored in a checkpoint. `source` is the sender's logical address.
+ *
+ * @experimental
+ */
+export interface DurableInboxEntry {
+    event: AnyEventObject;
+    source: SerializedActorRef | undefined;
+}
+/**
+ * Everything needed to resume an execution: the persisted snapshot, the next
+ * transition index and the events received but not yet processed. Persist
+ * the whole object atomically and pass it to `restore()`.
+ *
+ * @experimental
+ */
+export interface DurableCheckpoint {
+    snapshot: Snapshot<unknown>;
+    nextTransitionIndex: number;
+    inbox: DurableInboxEntry[];
+}
 /** @experimental */
 export interface DurableEffect<TEffect> extends DurableEffectMetadata {
     effect: TEffect;
@@ -148,13 +170,26 @@ export interface DurableExecution<TLogic extends AnyActorLogic> {
     /** Index assigned to the next transition. Persist this with checkpoints. */
     readonly nextTransitionIndex: number;
     /**
-     * Restores a checkpoint on a fresh execution. Returns effects that start
-     * active embedded children and re-arm pending root timers; execute them
-     * with `executeEffects` before waiting or processing the next event.
-     * Does not send a machine event, replay entry actions, or advance the
-     * transition index. Restoration effect IDs use `restore:<index>:<effect>`.
+     * Returns a checkpoint of `snapshot`: its persisted form, the next
+     * transition index and the inbox of root events captured by settled
+     * `executeEffects` batches but not yet taken by `waitForEvent()`. Call it
+     * after `executeEffects` resolves. Inbox event payloads are stored as they
+     * are, so they must be serializable data, like timer events in persisted
+     * snapshots. Lifecycle events for children no longer in `snapshot` are
+     * dropped, and child snapshot updates are not stored: a restored child
+     * reports its current snapshot when it starts.
+     */
+    checkpoint(snapshot: SnapshotFrom<TLogic>, options?: unknown): DurableCheckpoint;
+    /**
+     * Restores a checkpoint on a fresh execution. Accepts a `checkpoint()`
+     * result, whose inbox `waitForEvent()` hands out first, or a bare persisted
+     * snapshot. Returns effects that start active embedded children and re-arm
+     * pending root timers; execute them with `executeEffects` before waiting or
+     * processing the next event. Does not send a machine event, replay entry
+     * actions, or advance the transition index. Restoration effect IDs use
+     * `restore:<index>:<effect>`.
      */
-    restore(persistedSnapshot: Snapshot<unknown>): [
+    restore(checkpoint: DurableCheckpoint | Snapshot<unknown>): [
         snapshot: DurableSnapshot<TLogic>,
         effects: DurableEffect<ExecutableEffectFrom<TLogic>>[]
     ];
@@ -196,7 +231,7 @@ export interface DurableExecution<TLogic extends AnyActorLogic> {
      * an event a prior `executeEffects` batch captured (an invoked actor
      * completing, a child reporting up), or — once none are queued — whatever
      * the adapter's durable wait produces. With `captureRootEvents: false`,
-     * always delegates to the adapter's wait.
+     * delegates to the adapter's wait once a restored inbox is empty.
      */
     waitForEvent(): Promise<EventFromLogic<TLogic>>;
     run(...[input]: undefined extends InputFrom<TLogic> ? [input?: InputFrom<TLogic>] : [input: InputFrom<TLogic>]): Promise<OutputFrom<TLogic>>;

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

@@ -1,7 +1,7 @@
 import type { EventObject, ExecutableEffect, SerializedActorRef } from "./types.js";
 /**
  * A serializable view of an executable effect. Actor references are replaced
- * by `{ $actor: address, incarnation? }` and actor sources by their registered
+ * by `{ "@actor": address, incarnation? }` and actor sources by their registered
  * source keys, so a durable host can journal, deduplicate, and route effects without
  * holding live actor references. Payload fields (`event`, `input`, `params`,
  * `output`, `error`) pass through by reference and are only as serializable
@@ -87,7 +87,7 @@ export type ExecutableEffectDescriptor = {
 /**
  * Returns the serializable descriptor for an executable effect: the same
  * discriminants (`kind`, `type`) with actor references replaced by
- * `{ $actor: address, incarnation? }` and actor sources by source keys. Payload fields pass through by
+ * `{ "@actor": address, incarnation? }` and actor sources by source keys. Payload fields pass through by
  * reference.
  *
  * @experimental

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

@@ -1,5 +1,8 @@
 import type { EventObject, InferEvents, MachineContext, SetupSchemas, SetupStateSchema } from "./base.types.js";
 import type { StandardSchemaV1 } from "./schema.types.js";
+type FSMInitEvent = {
+    type: 'xstate.init';
+};
 /** @public */
 export type FSMArgs<TContext extends MachineContext, TEvent extends EventObject> = {
     context: TContext;
@@ -22,13 +25,14 @@ type EventForType<TEvent extends EventObject, TType extends string> = [
     type: TType;
 }>;
 /** @public */
-export type FSMTransition<TContext extends MachineContext, TEvent extends EventObject, TState extends string, TTransitionContext extends MachineContext = TContext> = TState | FSMTransitionConfig<TTransitionContext, TState> | FSMTransitionFunction<TContext, TEvent, TState, TTransitionContext>;
+export type FSMTransition<TContext extends MachineContext, TEvent extends EventObject, TState extends string, TTransitionContext extends MachineContext = TContext> = FSMTransitionConfig<TTransitionContext, TState> | FSMTransitionFunction<TContext, TEvent, TState, TTransitionContext>;
 type FSMOn<TContext extends MachineContext, TEvent extends EventObject, TState extends string, TTransitionContext extends MachineContext = TContext> = {
     [TType in TEvent['type'] & string]?: FSMTransition<TContext, EventForType<TEvent, TType>, TState, TTransitionContext>;
 };
 /** @public */
 export type FSMStateConfig<TContext extends MachineContext, TEvent extends EventObject, TState extends string, TTransitionContext extends MachineContext = TContext> = {
     on?: FSMOn<TContext, TEvent, TState, TTransitionContext>;
+    always?: FSMTransition<TContext, TEvent | FSMInitEvent, TState, TTransitionContext>;
 };
 type FSMContextConfig<TContext extends MachineContext> = string extends keyof TContext ? {
     context?: TContext;
@@ -134,14 +138,10 @@ type FSMSetupTransitionConfig<TSourceContext extends MachineContext, TStates ext
 } | {
     [TTarget in keyof TStates & string]: FSMSetupTargetTransitionConfig<TSourceContext, TTarget, FSMSetupStateContext<TTarget, TStates, TGlobalContext>>;
 }[keyof TStates & string];
-type FSMSetupStringTransition<TSourceContext extends MachineContext, TStates extends FSMSetupStates, TGlobalContext extends MachineContext> = {
-    [TTarget in keyof TStates & string]: [TSourceContext] extends [
-        FSMSetupStateContext<TTarget, TStates, TGlobalContext>
-    ] ? TTarget : never;
-}[keyof TStates & string];
 type FSMSetupTransitionFunction<TSourceContext extends MachineContext, TEvent extends EventObject, TStates extends FSMSetupStates, TGlobalContext extends MachineContext> = (args: FSMArgs<TSourceContext, TEvent>) => FSMSetupTransitionConfig<TSourceContext, TStates, TGlobalContext> | undefined;
-type FSMSetupTransition<TSourceContext extends MachineContext, TEvent extends EventObject, TStates extends FSMSetupStates, TGlobalContext extends MachineContext, TMachineStates extends Record<string, unknown>> = [keyof TStates] extends [never] ? FSMTransition<TSourceContext, TEvent, keyof TMachineStates & string> : FSMSetupStringTransition<TSourceContext, TStates, TGlobalContext> | FSMSetupTransitionConfig<TSourceContext, TStates, TGlobalContext> | FSMSetupTransitionFunction<TSourceContext, TEvent, TStates, TGlobalContext>;
+type FSMSetupTransition<TSourceContext extends MachineContext, TEvent extends EventObject, TStates extends FSMSetupStates, TGlobalContext extends MachineContext, TMachineStates extends Record<string, unknown>> = [keyof TStates] extends [never] ? FSMTransition<TSourceContext, TEvent, keyof TMachineStates & string> : FSMSetupTransitionConfig<TSourceContext, TStates, TGlobalContext> | FSMSetupTransitionFunction<TSourceContext, TEvent, TStates, TGlobalContext>;
 type FSMSetupStateConfig<TSourceContext extends MachineContext, TEvent extends EventObject, TStates extends FSMSetupStates, TGlobalContext extends MachineContext, TMachineStates extends Record<string, unknown>> = {
+    always?: FSMSetupTransition<TSourceContext, TEvent | FSMInitEvent, TStates, TGlobalContext, TMachineStates>;
     on?: {
         [TType in TEvent['type'] & string]?: FSMSetupTransition<TSourceContext, EventForType<TEvent, TType>, TStates, TGlobalContext, TMachineStates>;
     };

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

@@ -15,8 +15,8 @@ export type PersistedMachineSnapshot = {
     historyValue: Record<string, unknown>;
     timers: readonly unknown[];
     _nextActorId?: number;
-    _nextActorIds?: Record<string, number>;
-    _nextTimerId?: number;
+    nextActorIds?: Record<string, number>;
+    nextTimerId?: number;
     stateInputs?: Record<string, Record<string, unknown>>;
     machine?: {
         id: string;

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

@@ -9,7 +9,7 @@ import { AnyActorSystem } from "./system.js";
 import { InspectionEvent } from "./inspection.js";
 import type { MachineSnapshot } from "./State.js";
 import { type AsyncActorLogic, type AsyncSnapshot, type AsyncLogicFunction } from "./actors/promise.js";
-import { ActionSchemas, DelayMapFromNames, DelaySourceMap, GuardSourceMap, GuardSchemas, InferChildren, InferActions, InferGuards, Sources, InferMachineInput, InferOutput, InferEvents, InferInternalEvents, Next_MachineConfig, Next_InvokeConfig, Next_InvokeConfigBase, InvokeInputArgs, Next_StateNodeConfig, Next_TransitionConfigOrTarget, type createdInvokeConfig, FinalStateConfigOutput, OutputFromConfig, ChildCompletionEvents, DelayDurationKey, ValidateDelayNames, ValidateEventDescriptors, ValidateHistoryDefaults, ValidateInvokeInputs, ValidateVersionedMachineId, ValidateStateTargets, WithDefault } from "./types.v6.js";
+import { ActionSchemas, DelayMapFromNames, DelaySourceMap, GuardSourceMap, GuardSchemas, InferChildren, InferredInvokeChildren, InferActions, InferGuards, Sources, InferMachineInput, InferOutput, InferEvents, InferInternalEvents, Next_MachineConfig, Next_InvokeConfig, Next_InvokeConfigBase, InvokeInputArgs, Next_StateNodeConfig, Next_TransitionConfigOrTarget, type createdInvokeConfig, FinalStateConfigOutput, OutputFromConfig, ChildCompletionEvents, DelayDurationKey, ValidateDelayNames, ValidateEventDescriptors, ValidateHistoryDefaults, ValidateInvokeInputs, ValidateVersionedMachineId, ValidateStateTargets, WithDefault } from "./types.v6.js";
 /** @public */
 export type SetupConfig<TSchemas extends SetupSchemas, TStates extends Record<string, SetupStateSchema>, TActionMap extends Sources['actions'], TActorMap extends Sources['actors'], TGuardMap extends Sources['guards'], TDelayMap extends Sources['delays'], TValidator extends ActorLogicValidator | undefined = ActorLogicValidator | undefined> = {
     validator?: TValidator;
@@ -1220,7 +1220,7 @@ export interface SetupReturn<TStates extends Record<string, SetupStateSchema> =
     ] extends [never] ? never : {
         type: 'xstate.route';
         to: RoutableStateId<SetupMachineStateSchema<TConfig, TStates>>;
-    }), Cast<MergeChildren<SetupChildren<TSchemas, TChildrenSchemaMap>, TActor>, Record<string, AnyActorRef | undefined>>, StateValueFromStateSchema<SetupMachineStateSchema<TConfig, TStates>>, TTag & string, SetupInput<TSchemas, TInputSchema>, SetupOrConfigOutput<TSchemas, TOutputSchema, TConfig, TStates>, SetupEmitted<TSchemas, TEmittedSchemaMap>, SetupMeta<TSchemas, TMetaSchema>, PublicStateSchema<SetupMachineStateSchema<TConfig, TStates>> & {
+    }), Cast<MergeChildren<SetupChildren<TSchemas, TChildrenSchemaMap>, TActor> & InferredInvokeChildren<TConfig, MergeSourceMaps<TSetupActorMap, TActorMap>>, Record<string, AnyActorRef | undefined>>, StateValueFromStateSchema<SetupMachineStateSchema<TConfig, TStates>>, TTag & string, SetupInput<TSchemas, TInputSchema>, SetupOrConfigOutput<TSchemas, TOutputSchema, TConfig, TStates>, SetupEmitted<TSchemas, TEmittedSchemaMap>, SetupMeta<TSchemas, TMetaSchema>, PublicStateSchema<SetupMachineStateSchema<TConfig, TStates>> & {
         schemas: MergedSetupSchemas<SetupConfigSchemas<TConfig>, TSchemas>;
     }, MergeSourceMaps<SetupActions<TSchemas, TSetupActionMap>, MergeSourceMaps<InferActions<TActionSchemaMap>, TActionMap>>, MergeSourceMaps<TSetupActorMap, TActorMap>, MergeSourceMaps<SetupGuards<TSchemas, TSetupGuardMap>, MergeSourceMaps<InferGuards<TGuardSchemaMap>, TGuardMap>>, DelayMapFromNames<TSetupDelays | TDelays, MergeSourceMaps<TSetupDelayMap, TDelayMap>>, SetupInternalEvents<TSchemas, TInternalEventSchemaMap>, SetupTransitionMeta<TSchemas, TMetaSchema, TTransitionMetaSchema>> & MachineIdentity<TConfig>;
     /**

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

@@ -11,7 +11,7 @@ export interface SystemLogic<TLogic extends AnyActorLogic = AnyActorLogic> {
 }
 /** An actor identity, without a live actor or runtime. @experimental */
 export interface SystemActorReference {
-    readonly $actor: string;
+    readonly '@actor': string;
     readonly incarnation: string;
 }
 /** Actor state and topology in a system snapshot. @experimental */

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

@@ -40,7 +40,9 @@ export type UnifiedArg<TContext extends MachineContext, TExpressionEvent extends
 } & OutputArg<TExpressionEvent>;
 type DoneEventType = 'xstate.done.actor' | 'xstate.done.state';
 /** @public */
-export type OutputArg<TEvent extends EventObject> = TEvent extends {
+export type OutputArg<TEvent extends EventObject> = [TEvent] extends [never] ? {
+    output: undefined;
+} : TEvent extends {
     type: DoneEventType;
     output: infer TOutput;
 } ? {
@@ -941,7 +943,7 @@ export interface ActorLike<TCurrent, TEvent extends EventObject> extends Subscri
  */
 export interface SerializedActorRef {
     /** The actor's logical address. */
-    $actor: string;
+    '@actor': string;
     /** The incarnation token, when the serializer knows it. */
     incarnation?: string;
 }

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

@@ -4,7 +4,7 @@ import { SetupStateSchemas, StandardSchemaV1 } from "./schema.types.js";
 import type { ActionSchemas, GuardSchemas, InferEvents, InferInternalEvents } from "./base.types.js";
 export type { ActionSchemas, GuardSchemas, InferEvents, InferInternalEvents };
 import { MachineSnapshot } from "./State.js";
-import { Action, ActorTimeoutEvent, AfterEvent, ActorLogic, ActorRef, ActorRefFrom, ActorSelf, AnyActorLogic, AnyActorRef, DoneActorEvent, ErrorFrom, ErrorActorEvent, EnqueueObject, EventDescriptor, ReservedEventDescriptor, ReservedMachineEvent, ReservedEventFromDescriptor, ErrorEvent, EventObject, EventPayloadPattern, ExtractEvent, InitialContext, InputFrom, MetaObject, OutputFrom, SnapshotEvent, StateValue, TransitionContextMapper, TransitionContextPatch, TransitionConfigFunction, Values, AnyStateNode, SystemRegistry, TimeoutEvent, RequiredLogicInput } from "./types.js";
+import { Action, ActorTimeoutEvent, AfterEvent, ActorLogic, ActorRef, ActorRefFrom, ActorFromLogic, ActorSelf, AnyActorLogic, AnyActorRef, DoneActorEvent, ErrorFrom, ErrorActorEvent, EnqueueObject, EventDescriptor, ReservedEventDescriptor, ReservedMachineEvent, ReservedEventFromDescriptor, ErrorEvent, EventObject, EventPayloadPattern, ExtractEvent, InitialContext, InputFrom, MetaObject, OutputFrom, SnapshotEvent, StateValue, TransitionContextMapper, TransitionContextPatch, TransitionConfigFunction, Values, AnyStateNode, SystemRegistry, TimeoutEvent, RequiredLogicInput } from "./types.js";
 import type { Compute, DoNotInfer, IsNever, NonReducibleUnknown, SingleOrArray } from "./typeUtils.js";
 import { MachineContext, Mapper } from "./types.js";
 import type { LowInfer } from "./typeUtils.js";
@@ -58,6 +58,41 @@ export type SchemaOrConfigOutput<TOutputSchema extends StandardSchemaV1, TConfig
 export type InferChildren<TChildrenSchemaMap extends Record<string, StandardSchemaV1>> = string extends keyof TChildrenSchemaMap ? {} : {
     [K in keyof TChildrenSchemaMap & string]?: StandardSchemaV1.InferOutput<TChildrenSchemaMap[K]> extends AnyActorRef ? NormalizeActorRef<StandardSchemaV1.InferOutput<TChildrenSchemaMap[K]>> : never;
 };
+type InvokeSourceLogic<TSrc, TActors extends Sources['actors']> = [0] extends [
+    1 & TSrc
+] ? never : TSrc extends keyof TActors ? TActors[TSrc] : TSrc extends AnyActorLogic ? TSrc : TSrc extends (...args: any[]) => infer TResult ? InvokeSourceLogic<TResult, TActors> : never;
+type InvokedChild<TInvoke, TActors extends Sources['actors']> = TInvoke extends readonly (infer TItem)[] ? InvokedChild<TItem, TActors> : TInvoke extends {
+    readonly [createdInvokeConfig]: infer TConfig;
+    src: infer TLogic;
+} ? TConfig extends {
+    id: infer TId extends string;
+} ? string extends TId ? never : TLogic extends AnyActorLogic ? {
+    id: TId;
+    ref: ActorFromLogic<TLogic>;
+} : never : never : TInvoke extends {
+    id: infer TId extends string;
+    src: infer TSrc;
+} ? string extends TId ? never : InvokeSourceLogic<TSrc, TActors> extends infer TLogic extends AnyActorLogic ? {
+    id: TId;
+    ref: ActorFromLogic<TLogic>;
+} : never : never;
+type InvokedChildren<TConfig, TActors extends Sources['actors']> = (TConfig extends {
+    invoke: infer TInvoke;
+} ? InvokedChild<TInvoke, TActors> : never) | (TConfig extends {
+    states: infer TStates;
+} ? {
+    [K in keyof TStates]: InvokedChildren<TStates[K], TActors>;
+}[keyof TStates] : never);
+/** Type-level plumbing for children inferred from literal invoke IDs. */
+export type InferredInvokeChildren<TConfig, TActors extends Sources['actors'], TChild extends {
+    id: string;
+    ref: AnyActorRef;
+} = InvokedChildren<TConfig, TActors>> = [TChild] extends [never] ? {} : {
+    [K in TChild['id']]?: TChild extends {
+        id: string;
+        ref: AnyActorRef;
+    } ? K extends TChild['id'] ? TChild['ref'] : never : never;
+};
 export type InferActions<TActionSchemaMap extends ActionSchemas> = string extends keyof TActionSchemaMap ? {} : {
     [K in keyof TActionSchemaMap & string]: (params: StandardSchemaV1.InferOutput<TActionSchemaMap[K]['params']>) => void | {
         context?: any;
@@ -224,7 +259,7 @@ type LogicForChildRef<TActorRef> = NonNullable<TActorRef> extends ActorRef<infer
  * With no registered sources (empty or permissive maps) there is no competing
  * branch, so the full transition config is allowed.
  */
-type InlineInvokeOnDone<TContext extends MachineContext, TEvent extends EventObject, TEmitted extends EventObject, TActionMap extends Sources['actions'], TActorMap extends Sources['actors'], TGuardMap extends Sources['guards'], TDelayMap extends Sources['delays'], TMeta extends MetaObject, TChildren extends Record<string, AnyActorRef | undefined>> = [keyof TActorMap & string] extends [never] ? Next_TransitionConfigOrTarget<TContext, DoneActorEvent<any>, TEvent, TEmitted, TActionMap, TActorMap, TGuardMap, TDelayMap, TMeta, undefined, TChildren> : string extends keyof TActorMap ? Next_TransitionConfigOrTarget<TContext, DoneActorEvent<OutputFrom<TActorMap[keyof TActorMap & string]>>, TEvent, TEmitted, TActionMap, TActorMap, TGuardMap, TDelayMap, TMeta, undefined, TChildren> : undefined | {
+type InlineInvokeOnDone<TContext extends MachineContext, TEvent extends EventObject, TEmitted extends EventObject, TActionMap extends Sources['actions'], TActorMap extends Sources['actors'], TGuardMap extends Sources['guards'], TDelayMap extends Sources['delays'], TMeta extends MetaObject, TChildren extends Record<string, AnyActorRef | undefined>> = [keyof TActorMap & string] extends [never] ? Next_TransitionConfigOrTarget<TContext, DoneActorEvent<unknown>, TEvent, TEmitted, TActionMap, TActorMap, TGuardMap, TDelayMap, TMeta, undefined, TChildren> : string extends keyof TActorMap ? Next_TransitionConfigOrTarget<TContext, DoneActorEvent<OutputFrom<TActorMap[keyof TActorMap & string]>>, TEvent, TEmitted, TActionMap, TActorMap, TGuardMap, TDelayMap, TMeta, undefined, TChildren> : undefined | {
     matches?: EventPayloadPattern<DoneActorEvent>;
     target?: string | string[];
     context?: TransitionContextPatch<TContext>;

package/dist/{effectDescriptor-2fa27c54.cjs.js → effectDescriptor-3402f63e.cjs.js}

@@ -1,6 +1,6 @@
 'use strict';
 
-var createActor = require('./createActor-25900f76.cjs.js');
+var createActor = require('./createActor-73aa92ba.cjs.js');
 
 function attachMicrostepActorRefs(microsteps, actorScope, inputSnapshot) {
   const result = microsteps.map(([snapshot, actions, transitions]) => [snapshot, actions, transitions ?? []]);
@@ -202,7 +202,7 @@ function getNextTransitions(state) {
 
 /**
  * A serializable view of an executable effect. Actor references are replaced
- * by `{ $actor: address, incarnation? }` and actor sources by their registered
+ * by `{ "@actor": address, incarnation? }` and actor sources by their registered
  * source keys, so a durable host can journal, deduplicate, and route effects without
  * holding live actor references. Payload fields (`event`, `input`, `params`,
  * `output`, `error`) pass through by reference and are only as serializable
@@ -224,9 +224,9 @@ function toRef(actor) {
   }
   const incarnation = createActor.isRemoteActorRef(actor) ? actor.sessionId : undefined;
   return incarnation === undefined ? {
-    $actor: actor.address
+    '@actor': actor.address
   } : {
-    $actor: actor.address,
+    '@actor': actor.address,
     incarnation
   };
 }
@@ -234,7 +234,7 @@ function toRef(actor) {
 /**
  * Returns the serializable descriptor for an executable effect: the same
  * discriminants (`kind`, `type`) with actor references replaced by
- * `{ $actor: address, incarnation? }` and actor sources by source keys. Payload fields pass through by
+ * `{ "@actor": address, incarnation? }` and actor sources by source keys. Payload fields pass through by
  * reference.
  *
  * @experimental

package/dist/{effectDescriptor-d8b0f749.esm.js → effectDescriptor-65821048.development.esm.js}

@@ -1,4 +1,4 @@
-import { ai as createInertActorScope, aj as setInertActorScopeSnapshot, l as finalizeTransitionResult, al as attachSnapshotActorRef, Q as createInitEvent, aF as hasAmbientInspector, ak as beginSpawnAllocation, am as macrostep, az as createSpawnEffect, aA as initialMicrostep, i as isAtomicStateNode, aG as getProperAncestors, q as readTimerKey, k as getActorIdPrefix, o as isSerializedActorRef, aH as isRemoteActorRef } from './createActor-cbe3abac.esm.js';
+import { ai as createInertActorScope, aj as setInertActorScopeSnapshot, l as finalizeTransitionResult, al as attachSnapshotActorRef, Q as createInitEvent, aH as hasAmbientInspector, ak as beginSpawnAllocation, am as macrostep, aA as createSpawnEffect, aB as initialMicrostep, i as isAtomicStateNode, aI as getProperAncestors, q as readTimerKey, k as getActorIdPrefix, o as isSerializedActorRef, aJ as isRemoteActorRef } from './createActor-a085b20b.development.esm.js';
 
 function attachMicrostepActorRefs(microsteps, actorScope, inputSnapshot) {
   const result = microsteps.map(([snapshot, actions, transitions]) => [snapshot, actions, transitions ?? []]);
@@ -200,7 +200,7 @@ function getNextTransitions(state) {
 
 /**
  * A serializable view of an executable effect. Actor references are replaced
- * by `{ $actor: address, incarnation? }` and actor sources by their registered
+ * by `{ "@actor": address, incarnation? }` and actor sources by their registered
  * source keys, so a durable host can journal, deduplicate, and route effects without
  * holding live actor references. Payload fields (`event`, `input`, `params`,
  * `output`, `error`) pass through by reference and are only as serializable
@@ -222,9 +222,9 @@ function toRef(actor) {
   }
   const incarnation = isRemoteActorRef(actor) ? actor.sessionId : undefined;
   return incarnation === undefined ? {
-    $actor: actor.address
+    '@actor': actor.address
   } : {
-    $actor: actor.address,
+    '@actor': actor.address,
     incarnation
   };
 }
@@ -232,7 +232,7 @@ function toRef(actor) {
 /**
  * Returns the serializable descriptor for an executable effect: the same
  * discriminants (`kind`, `type`) with actor references replaced by
- * `{ $actor: address, incarnation? }` and actor sources by source keys. Payload fields pass through by
+ * `{ "@actor": address, incarnation? }` and actor sources by source keys. Payload fields pass through by
  * reference.
  *
  * @experimental

package/dist/{effectDescriptor-321a8ce9.development.esm.js → effectDescriptor-72c62058.esm.js}

@@ -1,4 +1,4 @@
-import { ah as createInertActorScope, ai as setInertActorScopeSnapshot, l as finalizeTransitionResult, ak as attachSnapshotActorRef, O as createInitEvent, aG as hasAmbientInspector, aj as beginSpawnAllocation, al as macrostep, az as createSpawnEffect, aA as initialMicrostep, i as isAtomicStateNode, aH as getProperAncestors, q as readTimerKey, k as getActorIdPrefix, o as isSerializedActorRef, aI as isRemoteActorRef } from './createActor-551369be.development.esm.js';
+import { aj as createInertActorScope, ak as setInertActorScopeSnapshot, l as finalizeTransitionResult, am as attachSnapshotActorRef, R as createInitEvent, aG as hasAmbientInspector, al as beginSpawnAllocation, an as macrostep, aA as createSpawnEffect, aB as initialMicrostep, i as isAtomicStateNode, aH as getProperAncestors, q as readTimerKey, k as getActorIdPrefix, o as isSerializedActorRef, aI as isRemoteActorRef } from './createActor-49ea55ba.esm.js';
 
 function attachMicrostepActorRefs(microsteps, actorScope, inputSnapshot) {
   const result = microsteps.map(([snapshot, actions, transitions]) => [snapshot, actions, transitions ?? []]);
@@ -200,7 +200,7 @@ function getNextTransitions(state) {
 
 /**
  * A serializable view of an executable effect. Actor references are replaced
- * by `{ $actor: address, incarnation? }` and actor sources by their registered
+ * by `{ "@actor": address, incarnation? }` and actor sources by their registered
  * source keys, so a durable host can journal, deduplicate, and route effects without
  * holding live actor references. Payload fields (`event`, `input`, `params`,
  * `output`, `error`) pass through by reference and are only as serializable
@@ -222,9 +222,9 @@ function toRef(actor) {
   }
   const incarnation = isRemoteActorRef(actor) ? actor.sessionId : undefined;
   return incarnation === undefined ? {
-    $actor: actor.address
+    '@actor': actor.address
   } : {
-    $actor: actor.address,
+    '@actor': actor.address,
     incarnation
   };
 }
@@ -232,7 +232,7 @@ function toRef(actor) {
 /**
  * Returns the serializable descriptor for an executable effect: the same
  * discriminants (`kind`, `type`) with actor references replaced by
- * `{ $actor: address, incarnation? }` and actor sources by source keys. Payload fields pass through by
+ * `{ "@actor": address, incarnation? }` and actor sources by source keys. Payload fields pass through by
  * reference.
  *
  * @experimental

package/dist/{effectDescriptor-f73da4ec.development.cjs.js → effectDescriptor-d0ea44ad.development.cjs.js}

@@ -1,6 +1,6 @@
 'use strict';
 
-var createActor = require('./createActor-a49ae0ce.development.cjs.js');
+var createActor = require('./createActor-dfb6b790.development.cjs.js');
 
 function attachMicrostepActorRefs(microsteps, actorScope, inputSnapshot) {
   const result = microsteps.map(([snapshot, actions, transitions]) => [snapshot, actions, transitions ?? []]);
@@ -202,7 +202,7 @@ function getNextTransitions(state) {
 
 /**
  * A serializable view of an executable effect. Actor references are replaced
- * by `{ $actor: address, incarnation? }` and actor sources by their registered
+ * by `{ "@actor": address, incarnation? }` and actor sources by their registered
  * source keys, so a durable host can journal, deduplicate, and route effects without
  * holding live actor references. Payload fields (`event`, `input`, `params`,
  * `output`, `error`) pass through by reference and are only as serializable
@@ -224,9 +224,9 @@ function toRef(actor) {
   }
   const incarnation = createActor.isRemoteActorRef(actor) ? actor.sessionId : undefined;
   return incarnation === undefined ? {
-    $actor: actor.address
+    '@actor': actor.address
   } : {
-    $actor: actor.address,
+    '@actor': actor.address,
     incarnation
   };
 }
@@ -234,7 +234,7 @@ function toRef(actor) {
 /**
  * Returns the serializable descriptor for an executable effect: the same
  * discriminants (`kind`, `type`) with actor references replaced by
- * `{ $actor: address, incarnation? }` and actor sources by source keys. Payload fields pass through by
+ * `{ "@actor": address, incarnation? }` and actor sources by source keys. Payload fields pass through by
  * reference.
  *
  * @experimental

package/dist/{machineSchemas-b5736804.development.esm.js → legacySnapshot-11aba2d2.development.esm.js}

@@ -1,4 +1,4 @@
-import { _ as resolveRegisteredActorSource, $ as allocateChildId, a0 as assertChildIdFree, a1 as reserveChildId, a2 as hasUnescapedDot, a3 as STATE_DELIMITER, a4 as mapValues, t as toArray, a5 as createInvokeId, a6 as getDelayedTransitions, a7 as getCandidates, a8 as evaluateCandidate, a9 as formatTransition, aa as NULL_EVENT, ab as toTransitionConfigArray, ac as matchesActorSession, ad as describeMachine, g as getAllStateNodes, b as getStateNodes, r as resolveInvokedActorLogic, o as isSerializedActorRef, a as assertUnreservedSourceName, ae as formatRouteTransitions, af as resolveStateValue, e as createMachineSnapshot, ag as isInFinalState, ah as createInertActorScope, ai as setInertActorScopeSnapshot, Q as createDeadLetterEffect, aj as beginSpawnAllocation, ak as attachSnapshotActorRef, al as macrostep, am as isInertActorScope, an as setSnapshotActorRef, ao as cloneMachineSnapshot, ap as transitionNode, aq as XSTATE_TIMER, m as matchesEventDescriptor, ar as getTransitionResult, as as hasEffect, at as createErrorPlatformEvent, au as withActorSelf, av as resolveActionsWithContext, aw as freezeContext, ax as takeSpawnAllocationCounters, ay as mergeActorIdCounters, O as createInitEvent, az as createSpawnEffect, aA as initialMicrostep, aB as createStartEffect, aC as isStateId, aD as getPersistedSnapshot, aE as detachedScopes, aF as toStatePath, h as createActor } from './createActor-551369be.development.esm.js';
+import { $ as resolveRegisteredActorSource, a0 as allocateChildId, a1 as assertChildIdFree, a2 as reserveChildId, a3 as hasUnescapedDot, a4 as STATE_DELIMITER, a5 as mapValues, t as toArray, a6 as createInvokeId, a7 as getDelayedTransitions, a8 as getCandidates, a9 as evaluateCandidate, aa as formatTransition, ab as NULL_EVENT, ac as toTransitionConfigArray, ad as matchesActorSession, ae as describeMachine, g as getAllStateNodes, b as getStateNodes, r as resolveInvokedActorLogic, o as isSerializedActorRef, a as assertUnreservedSourceName, af as formatRouteTransitions, ag as resolveStateValue, e as createMachineSnapshot, ah as isInFinalState, ai as createInertActorScope, aj as setInertActorScopeSnapshot, R as createDeadLetterEffect, ak as beginSpawnAllocation, al as attachSnapshotActorRef, am as macrostep, an as isInertActorScope, ao as setSnapshotActorRef, ap as cloneMachineSnapshot, aq as transitionNode, ar as XSTATE_TIMER, m as matchesEventDescriptor, as as getTransitionResult, at as hasEffect, au as createErrorPlatformEvent, av as withActorSelf, aw as resolveActionsWithContext, ax as freezeContext, ay as takeSpawnAllocationCounters, az as mergeActorIdCounters, Q as createInitEvent, aA as createSpawnEffect, aB as initialMicrostep, aC as createStartEffect, aD as isStateId, aE as getPersistedSnapshot, aF as detachedScopes, aG as toStatePath, h as createActor } from './createActor-a085b20b.development.esm.js';
 import { a as assertValid } from './validation-e69470ad.development.esm.js';
 
 var isDevelopment = true;
@@ -129,7 +129,7 @@ class StateNode {
     this.machine = options._machine;
     if (this.parent && hasUnescapedDot(this.key)) {
       throw new Error(// The suggestion is written as a JS string literal.
-      `State key "${this.key}" contains "." — nest the states or escape it as "${this.key.replaceAll(/(?<!\\)\./g, '\\\\.')}".` );
+      `State key "${this.key}" contains ".". Nest the states or escape it as "${this.key.replaceAll(/(?<!\\)\./g, '\\\\.')}".` );
     }
     this.path = this.parent ? this.parent.path.concat(this.key) : [];
     const firstStateKey = this.config.states ? Object.keys(this.config.states)[0] : undefined;
@@ -672,6 +672,15 @@ class StateMachine {
     /** @internal */
     this.idMap = new Map();
     this.root = void 0;
+    /**
+     * Returns the machine itself, never a Proxy wrapped around it (a function
+     * member is not wrapped by reactive proxies, so it still closes over the raw
+     * instance). Persistence resolves state nodes through it, matching the
+     * bound `transition` / `getInitialSnapshot`.
+     *
+     * @internal
+     */
+    this._raw = () => this;
     /**
      * The machine's `id`, or the empty string when the config declares none.
      * The root state node has this id; a machine without one has no `#id` root.
@@ -1368,4 +1377,109 @@ function eventSchema(machine) {
   }));
 }
 
-export { InvalidSnapshotError as I, StateMachine as S, StateNode as a, eventSchema as e, historicalEventSchema as h, snapshotSchema as s, validatePersistedSnapshot as v };
+// TODO(v7): remove this module and its callers. It reads snapshots written by
+// 6.0.0-beta.1, which used `$`- and `_`-prefixed field names that stores such
+// as Convex reject. Snapshots are written with the new names only.
+
+// Legacy marker key -> [new key, other keys the marker object may have].
+const markers = {
+  $actor: ['@actor', ['incarnation']],
+  $error: ['@error', ['message']],
+  $stateNode: ['@stateNode', []],
+  $systemMapper: ['@systemMapper', []]
+};
+const fields = {
+  _stateInputs: 'stateInputs',
+  _nextTimerId: 'nextTimerId',
+  _nextActorIds: 'nextActorIds'
+};
+
+// Persisted snapshots are JSON; live objects (actors, state nodes, errors)
+// are left alone.
+function isPlain(value) {
+  if (!value || typeof value !== 'object') return false;
+  const proto = Object.getPrototypeOf(value);
+  return proto === Object.prototype || proto === null || Array.isArray(value);
+}
+function renameMarkers(value, allowed) {
+  if (!isPlain(value)) return value;
+  if (Array.isArray(value)) {
+    const items = value.map(item => renameMarkers(item, allowed));
+    return items.some((item, i) => item !== value[i]) ? items : value;
+  }
+  const keys = Object.keys(value);
+  const legacy = keys.find(key => allowed.includes(key));
+  if (legacy && typeof value[legacy] === 'string' && keys.every(key => key === legacy || markers[legacy][1].includes(key))) {
+    const {
+      [legacy]: name,
+      ...rest
+    } = value;
+    return {
+      [markers[legacy][0]]: name,
+      ...rest
+    };
+  }
+  let copy;
+  for (const key of keys) {
+    const item = renameMarkers(value[key], allowed);
+    if (item !== value[key]) (copy ??= {
+      ...value
+    })[key] = item;
+  }
+  return copy ?? value;
+}
+
+// beta.1 always wrote `_nextTimerId` on machine snapshots. Current snapshots
+// write `nextTimerId`, so marker-shaped data in them is left alone.
+function isLegacyEnvelope(envelope) {
+  return isPlain(envelope) && '_nextTimerId' in envelope && !('nextTimerId' in envelope);
+}
+function renameFields(envelope) {
+  // A live machine snapshot keeps its `_`-prefixed in-memory fields.
+  if (!isPlain(envelope) || typeof envelope.matches === 'function') return envelope;
+  let copy;
+  for (const [legacy, name] of Object.entries(fields)) {
+    if (legacy in envelope && !(name in envelope)) {
+      const {
+        [legacy]: value,
+        ...rest
+      } = copy ?? envelope;
+      copy = {
+        ...rest,
+        [name]: value
+      };
+    }
+  }
+  return copy ?? envelope;
+}
+
+/** Upgrades a persisted machine snapshot written by 6.0.0-beta.1. */
+function upgradeLegacyPersistedSnapshot(snapshot) {
+  if (snapshot?.machine && typeof snapshot.matches === 'function') return snapshot;
+  if (!isLegacyEnvelope(snapshot)) return snapshot;
+  return renameMarkers(renameFields(snapshot), ['$actor']);
+}
+
+/** Upgrades a `systemTransition` snapshot written by 6.0.0-beta.1. */
+function upgradeLegacySystemSnapshot(snapshot) {
+  const actors = Object.values(snapshot?.actors ?? {});
+  if (!actors.some(actor => isLegacyEnvelope(actor?.snapshot))) return snapshot;
+  const upgraded = renameMarkers(snapshot, Object.keys(markers));
+  if (!upgraded?.actors) return upgraded;
+  let renamed;
+  for (const [address, actor] of Object.entries(upgraded.actors)) {
+    const data = renameFields(actor?.snapshot);
+    if (data !== actor?.snapshot) (renamed ??= {
+      ...upgraded.actors
+    })[address] = {
+      ...actor,
+      snapshot: data
+    };
+  }
+  return renamed ? {
+    ...upgraded,
+    actors: renamed
+  } : upgraded;
+}
+
+export { InvalidSnapshotError as I, StateMachine as S, StateNode as a, upgradeLegacyPersistedSnapshot as b, eventSchema as e, historicalEventSchema as h, snapshotSchema as s, upgradeLegacySystemSnapshot as u, validatePersistedSnapshot as v };