xstate 6.0.0-beta.0 → 6.0.0-beta.2

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/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

@@ -3,13 +3,13 @@ import type { SetupSchemas, SetupStateSchema, SetupStateType } from "./base.type
 import type { ActorLogicValidator } from "./validation.types.js";
 import { StateMachine, type CompatibleProvidedActorSource, type ProvidedActionContracts } from "./StateMachine.js";
 import { type Actor, type RequiredActorOptionsFor, type RequiredActorOptionsKeys } from "./createActor.js";
-import { AnyActorRef, AnyStateMachine, AnyActorLogic, ActorRefFrom, ActorSelf, AnyStateNode, EventObject, AnyEventObject, EventDescriptor, ReservedMachineEvent, ReservedEventFromDescriptor, ExtractEvent, MachineContext, ProvidedActor, RoutableStateId, StateSchema, StateValue, StateValueFromStateSchema, ToChildren, MetaObject, EnqueueObject, DoneActorEvent, DoneStateEvent, ErrorFrom, ErrorActorEvent, SystemRegistry, RegistryKeyForLogic, ActorOptions, Observer, Subscription, OutputArg, SnapshotEvent, AfterEvent, TimeoutEvent, ErrorEvent, CallbackActors, InputFrom, OutputFrom, SnapshotFrom, ActorTimeoutEvent } from "./types.js";
+import { AnyActorRef, AnyStateMachine, AnyActorLogic, ActorRefFrom, ActorSelf, AnyStateNode, EventObject, AnyEventObject, EventDescriptor, ReservedMachineEvent, ReservedEventFromDescriptor, ExtractEvent, MachineContext, ProvidedActor, RoutableStateId, StateSchema, StateValue, StateValueFromStateSchema, ToChildren, MetaObject, EnqueueObject, DoneActorEvent, DoneStateEvent, ErrorFrom, ErrorActorEvent, SystemRegistry, RegistryKeyForLogic, ActorOptions, Observer, Subscription, OutputArg, SnapshotEvent, AfterEvent, TimeoutEvent, ErrorEvent, CallbackActors, InputFrom, OutputFrom, SnapshotFrom, ActorTimeoutEvent, TransitionTargetString } from "./types.js";
 import type { Cast, Compute, SingleOrArray, NonReducibleUnknown } from "./typeUtils.js";
 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;
@@ -211,7 +211,7 @@ type UncheckedSetupStateSchemas = Record<string, UncheckedSetupStateSchema>;
 type SetupStateKey<TStateSchemas extends Record<string, SetupStateSchema>> = string extends SetupStateKeys<TStateSchemas> ? string : [SetupStateKeys<TStateSchemas>] extends [never] ? string : SetupStateKeys<TStateSchemas>;
 type StrictSetupStatePaths<TStateSchemas extends Record<string, SetupStateSchema>> = [SetupStateKeys<TStateSchemas>] extends [never] ? never : StatePaths<TStateSchemas>;
 type SetupRelativeStateTarget<TStateSchemas extends Record<string, SetupStateSchema>> = string extends SetupStateKeys<TStateSchemas> ? `.${string}` : [SetupStateKeys<TStateSchemas>] extends [never] ? '.' : '.' | `.${StatePaths<TStateSchemas> & string}`;
-type SetupStateTarget<TStateSchemas extends Record<string, SetupStateSchema>> = TStateSchemas extends StrictSetupStateTargetsMarker ? StrictSetupStatePaths<TStateSchemas> | SetupRelativeStateTarget<RelativeSetupStateSchemas<TStateSchemas>> | `#${string}` : string extends SetupStateKeys<TStateSchemas> ? string : [SetupStateKeys<TStateSchemas>] extends [never] ? string : StatePaths<TStateSchemas> | `.${string}` | `#${string}`;
+type SetupStateTarget<TStateSchemas extends Record<string, SetupStateSchema>> = TStateSchemas extends StrictSetupStateTargetsMarker ? StrictSetupStatePaths<TStateSchemas> | SetupRelativeStateTarget<RelativeSetupStateSchemas<TStateSchemas>> | `#${string}` : string extends SetupStateKeys<TStateSchemas> ? TransitionTargetString : [SetupStateKeys<TStateSchemas>] extends [never] ? TransitionTargetString : StatePaths<TStateSchemas> | `.${string}` | `#${string}`;
 type KnownSetupStateTarget<TStateSchemas extends Record<string, SetupStateSchema>> = string extends StatePaths<TStateSchemas> ? string extends StatePaths<RelativeSetupStateSchemas<TStateSchemas>> ? never : SetupRelativeStateTarget<RelativeSetupStateSchemas<TStateSchemas>> | RootSetupStateIdTarget<RootSetupStateSchemas<TStateSchemas>> : (StrictSetupStatePaths<TStateSchemas> & string) | SetupRelativeStateTarget<RelativeSetupStateSchemas<TStateSchemas>> | RootSetupStateIdTarget<RootSetupStateSchemas<TStateSchemas>>;
 declare const strictSetupStateTargets: unique symbol;
 declare const relativeSetupStateSchemas: unique symbol;
@@ -625,7 +625,7 @@ type SetupStateNodeTargetArrayInputConstraint<TConfig, TSiblingStateSchemas exte
     };
 } : unknown);
 type ValidateSetupTargetArrayInputs<TConfig, TRootStateSchemas extends Record<string, SetupStateSchema>> = SetupStateNodeTargetArrayInputConstraint<TConfig, TRootStateSchemas, SetupStateSchema, TRootStateSchemas>;
-type ValidateSetupStateContracts<TConfig, TStateSchemas extends Record<string, SetupStateSchema>> = HasExplicitSetupStateContracts<TStateSchemas> extends true ? ValidateSetupHistoryInputs<TConfig, TStateSchemas> & ValidateHistoryDefaults<MergeSetupConfig<TConfig, TStateSchemas>> & ValidateStateTargets<MergeSetupConfig<TConfig, TStateSchemas>> & NoInfer<ValidateSetupTargetArrayInputs<TConfig, TStateSchemas>> : unknown;
+type ValidateSetupStateContracts<TConfig, TStateSchemas extends Record<string, SetupStateSchema>> = ValidateStateTargets<MergeSetupConfig<TConfig, TStateSchemas>> & (HasExplicitSetupStateContracts<TStateSchemas> extends true ? ValidateSetupHistoryInputs<TConfig, TStateSchemas> & ValidateHistoryDefaults<MergeSetupConfig<TConfig, TStateSchemas>> & NoInfer<ValidateSetupTargetArrayInputs<TConfig, TStateSchemas>> : unknown);
 type SetupInitialTransitionConfig<TStateSchema extends SetupStateSchema, TTarget extends string, TConfig, TContext extends MachineContext, TEvent extends EventObject> = Extract<SetupConfigInitial<TConfig>, {
     target: TTarget;
 }> extends infer TInitial ? [TInitial] extends [never] ? {
@@ -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;
 } ? {
@@ -178,11 +180,17 @@ export type StateNodesConfig<TContext extends MachineContext, TEvent extends Eve
 /** @public */
 export type TransitionConfigTarget = string | undefined;
 export type TransitionConfigOrTarget<TContext extends MachineContext, TExpressionEvent extends EventObject, TEvent extends EventObject, TEmitted extends EventObject, TMeta extends MetaObject, TActionMap extends Sources['actions'], TActorMap extends Sources['actors'], TGuardMap extends Sources['guards'], TDelayMap extends Sources['delays']> = SingleOrArray<TransitionConfigTarget | TransitionConfig<TContext, TExpressionEvent, TEvent, TEmitted, TMeta, TActionMap, TActorMap, TGuardMap, TDelayMap> | TransitionConfigFunction<TContext, TExpressionEvent, TEvent, TEmitted, TActionMap, TActorMap, TGuardMap, TDelayMap, TMeta>>;
+/**
+ * @public A contextual type containing a literal ('.') keeps a returned
+ * literal target from widening to `string`, so `ValidateStateTargets` can
+ * check it; `string & {}` still accepts dynamic targets.
+ */
+export type TransitionTargetString = '.' | (string & {});
 /** @public */
 export type TransitionConfigFunction<TContext extends MachineContext, TCurrentEvent extends EventObject, 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, TInput = undefined, _TCtx extends MachineContext = [TContext] extends [never] ? any : TContext, TChildren extends Record<string, AnyActorRef | undefined> = {}> = (args: TransitionFunctionArgs<_TCtx, TCurrentEvent, TEvent, TActionMap, TActorMap, TGuardMap, TDelayMap, TChildren> & {
     input: TInput;
 }, enq: EnqueueObject<TEvent, TEmitted, SystemRegistry, Compute<CallbackActors<TActorMap>>, TChildren>) => {
-    target?: string | string[];
+    target?: TransitionTargetString | TransitionTargetString[];
     context?: TransitionContextPatch<_TCtx>;
     reenter?: boolean;
     meta?: TMeta;
@@ -935,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-f73da4ec.development.cjs.js → effectDescriptor-3fff5c51.development.cjs.js}

@@ -1,6 +1,6 @@
 'use strict';
 
-var createActor = require('./createActor-a49ae0ce.development.cjs.js');
+var createActor = require('./createActor-c029d29f.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/{effectDescriptor-2fa27c54.cjs.js → effectDescriptor-47f73e7e.cjs.js}

@@ -1,6 +1,6 @@
 'use strict';
 
-var createActor = require('./createActor-25900f76.cjs.js');
+var createActor = require('./createActor-c91c9ffe.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-321a8ce9.development.esm.js → effectDescriptor-5ac7dccb.development.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 { 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-0250284a.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-d8b0f749.esm.js → effectDescriptor-e93df910.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, 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-20a97166.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/{machineSchemas-88d01821.cjs.js → legacySnapshot-8d595687.cjs.js}

@@ -1,6 +1,6 @@
 'use strict';
 
-var createActor = require('./createActor-25900f76.cjs.js');
+var createActor = require('./createActor-c91c9ffe.cjs.js');
 var validation = require('./validation-4561b43c.cjs.js');
 
 var isDevelopment = false;
@@ -605,6 +605,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.
@@ -1291,10 +1300,117 @@ function eventSchema(machine) {
   }));
 }
 
+// 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;
+}
+
 exports.InvalidSnapshotError = InvalidSnapshotError;
 exports.StateMachine = StateMachine;
 exports.StateNode = StateNode;
 exports.eventSchema = eventSchema;
 exports.historicalEventSchema = historicalEventSchema;
 exports.snapshotSchema = snapshotSchema;
+exports.upgradeLegacyPersistedSnapshot = upgradeLegacyPersistedSnapshot;
+exports.upgradeLegacySystemSnapshot = upgradeLegacySystemSnapshot;
 exports.validatePersistedSnapshot = validatePersistedSnapshot;

package/dist/{machineSchemas-45c21bc2.esm.js → legacySnapshot-9e06feb4.esm.js}

@@ -1,4 +1,4 @@
-import { $ as resolveRegisteredActorSource, a0 as allocateChildId, a1 as assertChildIdFree, a2 as reserveChildId, a3 as hasUnescapedDot, x as xstateError, 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, g as getAllStateNodes, b as getStateNodes, r as resolveInvokedActorLogic, ae as describeMachine, o as isSerializedActorRef, 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 takeSpawnAllocationCounters, ay as mergeActorIdCounters, Q as createInitEvent, az as createSpawnEffect, aA as initialMicrostep, aB as createStartEffect, aC as isStateId, aD as getPersistedSnapshot, aE as detachedScopes, h as createActor } from './createActor-cbe3abac.esm.js';
+import { $ as resolveRegisteredActorSource, a0 as allocateChildId, a1 as assertChildIdFree, a2 as reserveChildId, a3 as hasUnescapedDot, x as xstateError, 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, g as getAllStateNodes, b as getStateNodes, r as resolveInvokedActorLogic, ae as describeMachine, o as isSerializedActorRef, 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 takeSpawnAllocationCounters, ay as mergeActorIdCounters, Q as createInitEvent, az as createSpawnEffect, aA as initialMicrostep, aB as createStartEffect, aC as isStateId, aD as getPersistedSnapshot, aE as detachedScopes, h as createActor } from './createActor-20a97166.esm.js';
 import { a as assertValid } from './validation-05f1d517.esm.js';
 
 var isDevelopment = false;
@@ -603,6 +603,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.
@@ -1289,4 +1298,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 };