xstate 6.0.0-alpha.25 → 6.0.0-alpha.27

package/dist/{StateMachine-bf4ec0f1.development.esm.js → StateMachine-24c5e3f9.development.esm.js}

@@ -1,4 +1,4 @@
-import { M as setSnapshotActorRef, N as getSnapshotActorRef, O as createSnapshotSystem, q as isMachineSnapshot, h as createActor, S as STATE_DELIMITER, P as mapValues, t as toArray, Q as createInvokeId, R as getDelayedTransitions, U as getEventDescriptorKey, V as evaluateCandidate, W as formatTransition, Y as NULL_EVENT, Z as toTransitionConfigArray, _ as createInvokeTimeoutEventId, $ as getCandidates, a0 as matchesActorSession, a1 as formatRouteTransitions, a2 as resolveStateValue, a3 as getAllStateNodes, s as getStateNodes, a4 as createMachineSnapshot, a5 as isInFinalState, j as macrostep, a6 as cloneMachineSnapshot, a7 as transitionNode, e as XSTATE_TIMER, m as matchesEventDescriptor, a8 as getTransitionResult, a9 as hasEffect, aa as createErrorPlatformEvent, r as resolveActionsWithContext, k as createInitEvent, l as createSpawnEffect, n as initialMicrostep, ab as toStatePath, ac as isStateId, ad as getStateNodeByPath, ae as getPersistedSnapshot, af as resolveReferencedActor, ag as createInvokeTimeoutEvent, ah as $$ACTOR_TYPE } from './index-b90ebcd4.development.esm.js';
+import { M as setSnapshotActorRef, N as getSnapshotActorRef, O as createSnapshotSystem, q as isMachineSnapshot, h as createActor, S as STATE_DELIMITER, P as mapValues, t as toArray, Q as createInvokeId, R as getDelayedTransitions, U as getEventDescriptorKey, V as evaluateCandidate, W as formatTransition, Y as NULL_EVENT, Z as toTransitionConfigArray, _ as createInvokeTimeoutEventId, $ as getCandidates, a0 as matchesActorSession, a1 as formatRouteTransitions, a2 as resolveStateValue, a3 as getAllStateNodes, s as getStateNodes, a4 as createMachineSnapshot, a5 as isInFinalState, j as macrostep, a6 as cloneMachineSnapshot, a7 as transitionNode, e as XSTATE_TIMER, m as matchesEventDescriptor, a8 as getTransitionResult, a9 as hasEffect, aa as createErrorPlatformEvent, r as resolveActionsWithContext, k as createInitEvent, l as createSpawnEffect, n as initialMicrostep, ab as toStatePath, ac as isStateId, ad as getStateNodeByPath, ae as getPersistedSnapshot, af as resolveReferencedActor, ag as createInvokeTimeoutEvent, ah as $$ACTOR_TYPE } from './index-41508d62.development.esm.js';
 
 function createSpawner(actorScope, actors, spawnedChildren) {
   return (src, options) => {
@@ -194,6 +194,7 @@ class StateNode {
      */
     this.order = -1;
     this.description = void 0;
+    this.schemas = void 0;
     this.tags = [];
     this.transitions = void 0;
     this.always = void 0;
@@ -210,6 +211,7 @@ class StateNode {
     this.id = this.config.id || [this.machine.id, ...this.path].join(STATE_DELIMITER);
     this.type = this.config.type || (firstStateKey !== undefined ? 'compound' : this.config.history ? 'history' : 'atomic');
     this.description = this.config.description;
+    this.schemas = this.config.schemas;
     validateStateNodeConfig(this);
     this.order = this.machine.idMap.size;
     this.machine.idMap.set(this.id, this);
@@ -314,6 +316,9 @@ class StateNode {
 }
 function validateStateNodeConfig(stateNode) {
   const config = stateNode.config;
+  if (stateNode.type === 'history' && !(typeof config.target === 'string' && config.target.trim().length > 0 || Array.isArray(config.target) && config.target.length > 0 && config.target.every(target => typeof target === 'string' && target.trim().length > 0))) {
+    throw new Error(`History state "${stateNode.id}" must declare a non-empty \`target\`.` );
+  }
   if (stateNode.type !== 'choice') {
     if (config.choice !== undefined) {
       throw new Error(`State "${stateNode.id}" has \`choice\`, but \`choice\` can only be used with \`type: 'choice'\`.`);

package/dist/{StateMachine-ac1167f3.development.cjs.js → StateMachine-673e9a91.development.cjs.js}

@@ -1,6 +1,6 @@
 'use strict';
 
-var dist_xstateActors = require('./index-1ad8a761.development.cjs.js');
+var dist_xstateActors = require('./index-c55fff73.development.cjs.js');
 
 function createSpawner(actorScope, actors, spawnedChildren) {
   return (src, options) => {
@@ -196,6 +196,7 @@ class StateNode {
      */
     this.order = -1;
     this.description = void 0;
+    this.schemas = void 0;
     this.tags = [];
     this.transitions = void 0;
     this.always = void 0;
@@ -212,6 +213,7 @@ class StateNode {
     this.id = this.config.id || [this.machine.id, ...this.path].join(dist_xstateActors.STATE_DELIMITER);
     this.type = this.config.type || (firstStateKey !== undefined ? 'compound' : this.config.history ? 'history' : 'atomic');
     this.description = this.config.description;
+    this.schemas = this.config.schemas;
     validateStateNodeConfig(this);
     this.order = this.machine.idMap.size;
     this.machine.idMap.set(this.id, this);
@@ -316,6 +318,9 @@ class StateNode {
 }
 function validateStateNodeConfig(stateNode) {
   const config = stateNode.config;
+  if (stateNode.type === 'history' && !(typeof config.target === 'string' && config.target.trim().length > 0 || Array.isArray(config.target) && config.target.length > 0 && config.target.every(target => typeof target === 'string' && target.trim().length > 0))) {
+    throw new Error(`History state "${stateNode.id}" must declare a non-empty \`target\`.` );
+  }
   if (stateNode.type !== 'choice') {
     if (config.choice !== undefined) {
       throw new Error(`State "${stateNode.id}" has \`choice\`, but \`choice\` can only be used with \`type: 'choice'\`.`);

package/dist/{StateMachine-69278d2c.esm.js → StateMachine-7daabf24.esm.js}

@@ -1,4 +1,4 @@
-import { M as setSnapshotActorRef, N as getSnapshotActorRef, O as createSnapshotSystem, q as isMachineSnapshot, h as createActor, S as STATE_DELIMITER, P as mapValues, t as toArray, Q as createInvokeId, R as getDelayedTransitions, U as getEventDescriptorKey, V as evaluateCandidate, W as formatTransition, Y as NULL_EVENT, Z as toTransitionConfigArray, _ as createInvokeTimeoutEventId, $ as getCandidates, a0 as matchesActorSession, a1 as formatRouteTransitions, a2 as resolveStateValue, a3 as getAllStateNodes, s as getStateNodes, a4 as createMachineSnapshot, a5 as isInFinalState, j as macrostep, a6 as cloneMachineSnapshot, a7 as transitionNode, e as XSTATE_TIMER, m as matchesEventDescriptor, a8 as getTransitionResult, a9 as hasEffect, aa as createErrorPlatformEvent, r as resolveActionsWithContext, k as createInitEvent, l as createSpawnEffect, n as initialMicrostep, ab as toStatePath, ac as isStateId, ad as getStateNodeByPath, ae as getPersistedSnapshot, af as resolveReferencedActor, ag as createInvokeTimeoutEvent, ah as $$ACTOR_TYPE } from './index-036a773f.esm.js';
+import { M as setSnapshotActorRef, N as getSnapshotActorRef, O as createSnapshotSystem, q as isMachineSnapshot, h as createActor, S as STATE_DELIMITER, P as mapValues, t as toArray, Q as createInvokeId, R as getDelayedTransitions, U as getEventDescriptorKey, V as evaluateCandidate, W as formatTransition, Y as NULL_EVENT, Z as toTransitionConfigArray, _ as createInvokeTimeoutEventId, $ as getCandidates, a0 as matchesActorSession, a1 as formatRouteTransitions, a2 as resolveStateValue, a3 as getAllStateNodes, s as getStateNodes, a4 as createMachineSnapshot, a5 as isInFinalState, j as macrostep, a6 as cloneMachineSnapshot, a7 as transitionNode, e as XSTATE_TIMER, m as matchesEventDescriptor, a8 as getTransitionResult, a9 as hasEffect, aa as createErrorPlatformEvent, r as resolveActionsWithContext, k as createInitEvent, l as createSpawnEffect, n as initialMicrostep, ab as toStatePath, ac as isStateId, ad as getStateNodeByPath, ae as getPersistedSnapshot, af as resolveReferencedActor, ag as createInvokeTimeoutEvent, ah as $$ACTOR_TYPE } from './index-d33c7b85.esm.js';
 
 function createSpawner(actorScope, actors, spawnedChildren) {
   return (src, options) => {
@@ -193,6 +193,7 @@ class StateNode {
      */
     this.order = -1;
     this.description = void 0;
+    this.schemas = void 0;
     this.tags = [];
     this.transitions = void 0;
     this.always = void 0;
@@ -209,6 +210,7 @@ class StateNode {
     this.id = this.config.id || [this.machine.id, ...this.path].join(STATE_DELIMITER);
     this.type = this.config.type || (firstStateKey !== undefined ? 'compound' : this.config.history ? 'history' : 'atomic');
     this.description = this.config.description;
+    this.schemas = this.config.schemas;
     validateStateNodeConfig(this);
     this.order = this.machine.idMap.size;
     this.machine.idMap.set(this.id, this);
@@ -313,6 +315,9 @@ class StateNode {
 }
 function validateStateNodeConfig(stateNode) {
   const config = stateNode.config;
+  if (stateNode.type === 'history' && !(typeof config.target === 'string' && config.target.trim().length > 0 || Array.isArray(config.target) && config.target.length > 0 && config.target.every(target => typeof target === 'string' && target.trim().length > 0))) {
+    throw new Error(`Missing history target on "${stateNode.id}"`);
+  }
   if (stateNode.type !== 'choice') {
     return;
   }

package/dist/{StateMachine-b20d5a53.cjs.js → StateMachine-bcb27183.cjs.js}

@@ -1,6 +1,6 @@
 'use strict';
 
-var dist_xstateActors = require('./index-f58cc498.cjs.js');
+var dist_xstateActors = require('./index-b228b8b6.cjs.js');
 
 function createSpawner(actorScope, actors, spawnedChildren) {
   return (src, options) => {
@@ -195,6 +195,7 @@ class StateNode {
      */
     this.order = -1;
     this.description = void 0;
+    this.schemas = void 0;
     this.tags = [];
     this.transitions = void 0;
     this.always = void 0;
@@ -211,6 +212,7 @@ class StateNode {
     this.id = this.config.id || [this.machine.id, ...this.path].join(dist_xstateActors.STATE_DELIMITER);
     this.type = this.config.type || (firstStateKey !== undefined ? 'compound' : this.config.history ? 'history' : 'atomic');
     this.description = this.config.description;
+    this.schemas = this.config.schemas;
     validateStateNodeConfig(this);
     this.order = this.machine.idMap.size;
     this.machine.idMap.set(this.id, this);
@@ -315,6 +317,9 @@ class StateNode {
 }
 function validateStateNodeConfig(stateNode) {
   const config = stateNode.config;
+  if (stateNode.type === 'history' && !(typeof config.target === 'string' && config.target.trim().length > 0 || Array.isArray(config.target) && config.target.length > 0 && config.target.every(target => typeof target === 'string' && target.trim().length > 0))) {
+    throw new Error(`Missing history target on "${stateNode.id}"`);
+  }
   if (stateNode.type !== 'choice') {
     return;
   }

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

@@ -1,3 +1,4 @@
+import type { SetupStateSchemas } from "./schema.types.js";
 import type { DelayedTransitionDefinition, EventObject, InitialTransitionDefinition, MachineContext, Mapper, StateNodesConfig, TransitionDefinitionMap, AnyStateMachine, AnyStateNodeConfig, NonReducibleUnknown, EventDescriptor, AnyAction, AnyTransitionDefinition, AnyInvokeDefinition } from "./types.js";
 interface StateNodeOptions<TContext extends MachineContext, TEvent extends EventObject> {
     _key: string;
@@ -60,6 +61,7 @@ export declare class StateNode<TContext extends MachineContext = MachineContext,
      */
     order: number;
     description?: string;
+    schemas: SetupStateSchemas | undefined;
     tags: string[];
     transitions: Map<string, AnyTransitionDefinition[]>;
     always?: Array<AnyTransitionDefinition>;

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

@@ -1,7 +1,7 @@
 import { StandardSchemaV1 } from "./schema.types.js";
 import { StateMachine } from "./StateMachine.js";
 import { AnyActorRef, EventObject, AnyEventObject, Cast, MachineContext, ProvidedActor, StateValue, ToChildren, MetaObject, StateSchema, DoNotInfer, RoutableStateId, Compute } from "./types.js";
-import { Sources, DelayMapFromNames, InferChildren, InferOutput, InferEvents, Next_MachineConfig, Next_StateNodeConfig, ValidateDelayReferences, ValidateTopLevelFinalOutputs, WidenLiterals, WithDefault } from "./types.v6.js";
+import { Sources, DelayMapFromNames, InferChildren, InferOutput, InferEvents, Next_MachineConfig, Next_StateNodeConfig, ValidateDelayReferences, ValidateHistoryDefaults, ValidateStateTargets, ValidateTopLevelFinalOutputs, WidenLiterals, WithDefault } from "./types.v6.js";
 type MergeChildren<TChildren extends Record<string, AnyActorRef | undefined>, TActor extends ProvidedActor> = [keyof TChildren] extends [never] ? Compute<ToChildren<TActor>> : Compute<TChildren>;
 /**
  * Creates a state machine (statechart) with the given configuration.
@@ -45,7 +45,7 @@ type MergeChildren<TChildren extends Record<string, AnyActorRef | undefined>, TA
  * @param options DEPRECATED: use `setup({ ... })` or `machine.provide({ ... })`
  *   to provide machine sources instead.
  */
-export declare function createMachine<TContextSchema extends StandardSchemaV1, const TEventSchemaMap extends Record<string, StandardSchemaV1>, TEmittedSchemaMap extends Record<string, StandardSchemaV1>, TInputSchema extends StandardSchemaV1, const TOutputSchema extends StandardSchemaV1, TMetaSchema extends StandardSchemaV1, TTagSchema extends StandardSchemaV1, const TChildrenSchemaMap extends Record<string, StandardSchemaV1>, _TEvent extends EventObject, TActor extends ProvidedActor, TActionMap extends Sources['actions'], TActorMap extends Sources['actors'], TGuardMap extends Sources['guards'], TDelayMap extends Sources['delays'], TDelays extends string, TTag extends StandardSchemaV1.InferOutput<TTagSchema> & string, TInput, const TSS extends StateSchema>(config: TSS & ValidateDelayReferences<TSS> & Next_MachineConfig<TContextSchema, TEventSchemaMap, TEmittedSchemaMap, TInputSchema, TOutputSchema, TMetaSchema, TTagSchema, TChildrenSchemaMap, InferOutput<TContextSchema, MachineContext>, InferEvents<TEventSchemaMap>, Cast<MergeChildren<InferChildren<TChildrenSchemaMap>, TActor>, Record<string, AnyActorRef | undefined>>, TDelays, TTag, TActionMap, TActorMap, TGuardMap, TDelayMap> & {
+export declare function createMachine<TContextSchema extends StandardSchemaV1, const TEventSchemaMap extends Record<string, StandardSchemaV1>, TEmittedSchemaMap extends Record<string, StandardSchemaV1>, TInputSchema extends StandardSchemaV1, const TOutputSchema extends StandardSchemaV1, TMetaSchema extends StandardSchemaV1, TTagSchema extends StandardSchemaV1, const TChildrenSchemaMap extends Record<string, StandardSchemaV1>, _TEvent extends EventObject, TActor extends ProvidedActor, TActionMap extends Sources['actions'], TActorMap extends Sources['actors'], TGuardMap extends Sources['guards'], TDelayMap extends Sources['delays'], TDelays extends string, TTag extends StandardSchemaV1.InferOutput<TTagSchema> & string, TInput, const TSS extends StateSchema>(config: TSS & ValidateDelayReferences<TSS> & ValidateHistoryDefaults<TSS> & ValidateStateTargets<TSS> & Next_MachineConfig<TContextSchema, TEventSchemaMap, TEmittedSchemaMap, TInputSchema, TOutputSchema, TMetaSchema, TTagSchema, TChildrenSchemaMap, InferOutput<TContextSchema, MachineContext>, InferEvents<TEventSchemaMap>, Cast<MergeChildren<InferChildren<TChildrenSchemaMap>, TActor>, Record<string, AnyActorRef | undefined>>, TDelays, TTag, TActionMap, TActorMap, TGuardMap, TDelayMap> & {
     schemas: {
         context: TContextSchema;
         children?: TChildrenSchemaMap;
@@ -58,7 +58,7 @@ TSS, // TStateSchema
 TActionMap, TActorMap, TGuardMap, DelayMapFromNames<TDelays, TDelayMap>> & {
     states: TSS;
 };
-export declare function createMachine<TContext extends MachineContext = never, const TEventSchemaMap extends Record<string, StandardSchemaV1> = Record<string, StandardSchemaV1>, TEmittedSchemaMap extends Record<string, StandardSchemaV1> = Record<string, StandardSchemaV1>, TInputSchema extends StandardSchemaV1 = StandardSchemaV1, const TOutputSchema extends StandardSchemaV1 = StandardSchemaV1, TMetaSchema extends StandardSchemaV1 = StandardSchemaV1, TTagSchema extends StandardSchemaV1 = StandardSchemaV1, const TChildrenSchemaMap extends Record<string, StandardSchemaV1> = Record<string, StandardSchemaV1>, _TEvent extends EventObject = EventObject, TActor extends ProvidedActor = ProvidedActor, TActionMap extends Sources['actions'] = Sources['actions'], TActorMap extends Sources['actors'] = Sources['actors'], TGuardMap extends Sources['guards'] = Sources['guards'], TDelayMap extends Sources['delays'] = Sources['delays'], TDelays extends string = string, TTag extends StandardSchemaV1.InferOutput<TTagSchema> & string = StandardSchemaV1.InferOutput<TTagSchema> & string, TInput = unknown, const TSS extends StateSchema = StateSchema>(config: TSS & ValidateDelayReferences<TSS> & Next_MachineConfig<StandardSchemaV1, TEventSchemaMap, TEmittedSchemaMap, TInputSchema, TOutputSchema, TMetaSchema, TTagSchema, TChildrenSchemaMap, WidenLiterals<TContext>, InferEvents<TEventSchemaMap>, Cast<MergeChildren<InferChildren<TChildrenSchemaMap>, TActor>, Record<string, AnyActorRef | undefined>>, TDelays, TTag, TActionMap, TActorMap, TGuardMap, TDelayMap, false> & {
+export declare function createMachine<TContext extends MachineContext = never, const TEventSchemaMap extends Record<string, StandardSchemaV1> = Record<string, StandardSchemaV1>, TEmittedSchemaMap extends Record<string, StandardSchemaV1> = Record<string, StandardSchemaV1>, TInputSchema extends StandardSchemaV1 = StandardSchemaV1, const TOutputSchema extends StandardSchemaV1 = StandardSchemaV1, TMetaSchema extends StandardSchemaV1 = StandardSchemaV1, TTagSchema extends StandardSchemaV1 = StandardSchemaV1, const TChildrenSchemaMap extends Record<string, StandardSchemaV1> = Record<string, StandardSchemaV1>, _TEvent extends EventObject = EventObject, TActor extends ProvidedActor = ProvidedActor, TActionMap extends Sources['actions'] = Sources['actions'], TActorMap extends Sources['actors'] = Sources['actors'], TGuardMap extends Sources['guards'] = Sources['guards'], TDelayMap extends Sources['delays'] = Sources['delays'], TDelays extends string = string, TTag extends StandardSchemaV1.InferOutput<TTagSchema> & string = StandardSchemaV1.InferOutput<TTagSchema> & string, TInput = unknown, const TSS extends StateSchema = StateSchema>(config: TSS & ValidateDelayReferences<TSS> & ValidateHistoryDefaults<TSS> & ValidateStateTargets<TSS> & Next_MachineConfig<StandardSchemaV1, TEventSchemaMap, TEmittedSchemaMap, TInputSchema, TOutputSchema, TMetaSchema, TTagSchema, TChildrenSchemaMap, WidenLiterals<TContext>, InferEvents<TEventSchemaMap>, Cast<MergeChildren<InferChildren<TChildrenSchemaMap>, TActor>, Record<string, AnyActorRef | undefined>>, TDelays, TTag, TActionMap, TActorMap, TGuardMap, TDelayMap, false> & {
     schemas?: {
         context?: never;
     };

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

@@ -172,7 +172,7 @@ export interface StateNodeJSON {
     timeout?: number | string | ResolvableJSON;
     onTimeout?: TransitionConfigJSON | TransitionConfigJSON[];
     history?: 'shallow' | 'deep';
-    target?: string;
+    target?: string | [string, ...string[]];
     output?: unknown;
     context?: Record<string, unknown>;
     _scxmlDonedata?: ScxmlDonedataJSON;

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

@@ -3,6 +3,11 @@ export interface StandardSchemaV1<Input = unknown, Output = Input> {
     /** The Standard Schema properties. */
     readonly '~standard': StandardSchemaV1.Props<Input, Output>;
 }
+/** Schemas that can be declared for an individual state node. */
+export type SetupStateSchemas = {
+    context?: StandardSchemaV1;
+    input?: StandardSchemaV1;
+};
 /** A type-only Standard Schema produced by {@link types}. */
 export interface TypeSchema<T> extends StandardSchemaV1<T, T> {
     readonly '~standard': StandardSchemaV1.Props<T, T> & {

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

@@ -1,10 +1,10 @@
-import { StandardSchemaV1 } from "./schema.types.js";
+import { SetupStateSchemas, StandardSchemaV1 } from "./schema.types.js";
 import { StateMachine } from "./StateMachine.js";
 import { type Actor, type RequiredActorOptionsKeys } from "./createActor.js";
-import { AnyActorRef, AnyActorLogic, ActorRefFromLogic, AnyStateNode, EventObject, AnyEventObject, EventDescriptor, ExtractEvent, MachineContext, ProvidedActor, RoutableStateId, StateSchema, StateValue, ToChildren, MetaObject, Cast, Compute, EnqueueObject, DoneActorEvent, DoneStateEvent, ErrorActorEvent, SystemRegistry, RegistryKeyForLogic, ActorOptions, Observer, Subscription, OutputArg, SnapshotEvent, SingleOrArray } from "./types.js";
+import { AnyActorRef, AnyActorLogic, ActorRefFromLogic, AnyStateNode, EventObject, AnyEventObject, EventDescriptor, ExtractEvent, MachineContext, ProvidedActor, RoutableStateId, StateSchema, StateValue, ToChildren, MetaObject, Cast, Compute, EnqueueObject, DoneActorEvent, DoneStateEvent, ErrorActorEvent, SystemRegistry, RegistryKeyForLogic, ActorOptions, Observer, Subscription, OutputArg, SnapshotEvent, SingleOrArray, AfterEvent, TimeoutEvent, ErrorEvent } from "./types.js";
 import { AnyActorSystem } from "./system.js";
 import { InspectionEvent } from "./inspection.js";
-import { ActionSchemas, DelayMapFromNames, GuardSchemas, InferChildren, InferActions, InferGuards, Sources, InferOutput, InferEvents, Next_MachineConfig, Next_InvokeConfig, Next_StateNodeConfig, Next_TransitionConfigOrTarget, WithDefault } from "./types.v6.js";
+import { ActionSchemas, DelayMapFromNames, GuardSchemas, InferChildren, InferActions, InferGuards, Sources, InferOutput, InferEvents, Next_MachineConfig, Next_InvokeConfig, Next_StateNodeConfig, Next_TransitionConfigOrTarget, ValidateHistoryDefaults, ValidateStateTargets, WithDefault } from "./types.v6.js";
 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']> = {
     schemas?: TSchemas & SetupSchemas;
     states?: TStates;
@@ -50,10 +50,7 @@ type ValidateRegistryKeys<TConfig, TSystemRegistry extends SystemRegistry, TActo
         [K in keyof TStates]: TStates[K] & ValidateRegistryKeys<TStates[K], TSystemRegistry, TActorMap>;
     };
 } : unknown);
-export type SetupStateSchemas = {
-    context?: StandardSchemaV1;
-    input?: StandardSchemaV1;
-};
+export type { SetupStateSchemas };
 export type SetupSchemas = {
     context?: StandardSchemaV1;
     events?: Record<string, StandardSchemaV1>;
@@ -245,7 +242,7 @@ type StatesWithInput<TRootStateSchemas extends Record<string, SetupStateSchema>,
     [K in TStateKeys]?: StateNodeConfigWithNestedInput<StateSchemasWithKeys<TRootStateSchemas, TStateKeys>, K extends keyof TStateSchemas ? TStateSchemas[K] : {}, TContext, TContextShape, TEvent, TChildren, TDelays, TTag, TOutput, TEmitted, TMeta, TActionMap, TActorMap, TGuardMap, TDelayMap, TSystemRegistry>;
 };
 /** State node config that recursively applies typed input for nested states */
-type StateNodeConfigWithNestedInput<TSiblingStateSchemas extends Record<string, SetupStateSchema>, TStateSchema extends SetupStateSchema, TContext extends MachineContext, TContextShape, TEvent extends EventObject, TChildren extends Record<string, AnyActorRef | undefined>, TDelays extends string, TTag extends string, TOutput, TEmitted extends EventObject, TMeta extends MetaObject, TActionMap extends Sources['actions'], TActorMap extends Sources['actors'], TGuardMap extends Sources['guards'], TDelayMap extends Sources['delays'], TSystemRegistry extends SystemRegistry> = WithNestedStates<Omit<Next_StateNodeConfig<StateContext<TStateSchema, TContext>, TEvent, TDelays, TTag, TOutput, TEmitted, TMeta, TChildren, TActionMap, TActorMap, TGuardMap, TDelayMap, StateInput<TStateSchema>, Record<string, unknown>, TSystemRegistry>, 'on' | 'always' | 'initial' | 'invoke' | 'onDone'> & {
+type StateNodeConfigWithNestedInput<TSiblingStateSchemas extends Record<string, SetupStateSchema>, TStateSchema extends SetupStateSchema, TContext extends MachineContext, TContextShape, TEvent extends EventObject, TChildren extends Record<string, AnyActorRef | undefined>, TDelays extends string, TTag extends string, TOutput, TEmitted extends EventObject, TMeta extends MetaObject, TActionMap extends Sources['actions'], TActorMap extends Sources['actors'], TGuardMap extends Sources['guards'], TDelayMap extends Sources['delays'], TSystemRegistry extends SystemRegistry> = WithNestedStates<Omit<Next_StateNodeConfig<StateContext<TStateSchema, TContext>, TEvent, TDelays, TTag, TOutput, TEmitted, TMeta, TChildren, TActionMap, TActorMap, TGuardMap, TDelayMap, StateInput<TStateSchema>, Record<string, unknown>, TSystemRegistry>, 'on' | 'always' | 'initial' | 'invoke' | 'onDone' | 'onError' | 'onTimeout' | 'after'> & {
     initial?: TStateSchema['states'] extends Record<string, SetupStateSchema> ? SetupStateKey<TStateSchema['states']> | (string & {}) | InitialTransitionWithInput<TStateSchema['states'], StateContext<TStateSchema, TContext>, TEvent> : string | {
         target: string;
         input?: Record<string, unknown>;
@@ -254,6 +251,11 @@ type StateNodeConfigWithNestedInput<TSiblingStateSchemas extends Record<string,
     always?: StateTransitionConfigOrTarget<TSiblingStateSchemas, StateContext<TStateSchema, TContext>, StateContextShape<TStateSchema, TContextShape>, TEvent, TEvent, TEmitted, TChildren, TMeta, TActionMap, TActorMap, TGuardMap, TDelayMap, TSystemRegistry, StateInput<TStateSchema>>;
     invoke?: SingleOrArray<SetupInvokeConfig<TSiblingStateSchemas, StateContext<TStateSchema, TContext>, StateContextShape<TStateSchema, TContextShape>, TEvent, TEmitted, TChildren, TMeta, TActionMap, TActorMap, TGuardMap, TDelayMap, TSystemRegistry>>;
     onDone?: StateTransitionConfigOrTarget<TSiblingStateSchemas, StateContext<TStateSchema, TContext>, StateContextShape<TStateSchema, TContextShape>, DoneStateEvent, TEvent, TEmitted, TChildren, TMeta, TActionMap, TActorMap, TGuardMap, TDelayMap, TSystemRegistry, StateInput<TStateSchema>>;
+    onError?: StateTransitionConfigOrTarget<TSiblingStateSchemas, StateContext<TStateSchema, TContext>, StateContextShape<TStateSchema, TContextShape>, ErrorEvent, TEvent, TEmitted, TChildren, TMeta, TActionMap, TActorMap, TGuardMap, TDelayMap, TSystemRegistry, StateInput<TStateSchema>>;
+    onTimeout?: StateTransitionConfigOrTarget<TSiblingStateSchemas, StateContext<TStateSchema, TContext>, StateContextShape<TStateSchema, TContextShape>, TimeoutEvent, TEvent, TEmitted, TChildren, TMeta, TActionMap, TActorMap, TGuardMap, TDelayMap, TSystemRegistry, StateInput<TStateSchema>>;
+    after?: {
+        [K in NoInfer<TDelays> | number]?: StateTransitionConfigOrTarget<TSiblingStateSchemas, StateContext<TStateSchema, TContext>, StateContextShape<TStateSchema, TContextShape>, AfterEvent, TEvent, TEmitted, TChildren, TMeta, TActionMap, TActorMap, TGuardMap, TDelayMap, TSystemRegistry, StateInput<TStateSchema>>;
+    };
 }, TStateSchema['states'] extends Record<string, SetupStateSchema> ? StatesWithInput<TStateSchema['states'], TStateSchema['states'], TContext, StateContextShape<TStateSchema, TContextShape>, TEvent, TChildren, TDelays, TTag, TOutput, TEmitted, TMeta, TActionMap, TActorMap, TGuardMap, TDelayMap, TSystemRegistry> : {
     [K in string]?: Next_StateNodeConfig<TContext, TEvent, TDelays, TTag, TOutput, TEmitted, TMeta, TChildren, TActionMap, TActorMap, TGuardMap, TDelayMap, undefined, Record<string, unknown>, TSystemRegistry>;
 }>;
@@ -380,7 +382,7 @@ export interface SetupReturn<TStates extends Record<string, SetupStateSchema> =
         guards?: TGuardMap;
         delays?: TDelayMap;
         states?: Record<TStateKeys, unknown>;
-    } & TConfig & ValidateSetupDelayReferences<TConfig, TSetupDelays> & ValidateRegistryKeys<TConfig, TSystemRegistry, MergeSourceMaps<TSetupActorMap, TActorMap>>): StateMachine<SetupContext<TSchemas, TContextSchema>, SetupEvents<TSchemas, TEventSchemaMap> | ([RoutableStateId<Cast<TConfig, StateSchema>>] extends [never] ? never : {
+    } & TConfig & ValidateSetupDelayReferences<TConfig, TSetupDelays> & ValidateHistoryDefaults<TConfig> & ValidateStateTargets<TConfig> & ValidateRegistryKeys<TConfig, TSystemRegistry, MergeSourceMaps<TSetupActorMap, TActorMap>>): StateMachine<SetupContext<TSchemas, TContextSchema>, SetupEvents<TSchemas, TEventSchemaMap> | ([RoutableStateId<Cast<TConfig, StateSchema>>] extends [never] ? never : {
         type: 'xstate.route';
         to: RoutableStateId<Cast<TConfig, StateSchema>>;
     }), Cast<MergeChildren<SetupChildren<TSchemas, TChildrenSchemaMap>, TActor>, Record<string, AnyActorRef | undefined>>, StateValue, TTag & string, [
@@ -469,4 +471,3 @@ type SystemBuilder<TSystemRegistry extends SystemRegistry> = {
     setup<const TSchemas extends SetupSchemas = {}, const TStates extends Record<string, SetupStateSchema> = Record<string, SetupStateSchema>, TActionMap extends Sources['actions'] = {}, TActorMap extends Sources['actors'] = {}, TGuardMap extends Sources['guards'] = {}, TDelayMap extends Sources['delays'] = {}>(config?: SetupConfig<TSchemas, TStates, TActionMap, TActorMap, TGuardMap, TDelayMap>): SetupReturn<TStates, TSchemas, TActionMap, TActorMap, TGuardMap, TDelayMap, Extract<keyof TDelayMap, string>, TSystemRegistry>;
 };
 export declare function createSystem<const TSystemRegistry extends SystemRegistry = {}>(_config?: SystemConfig<TSystemRegistry>): SystemBuilder<TSystemRegistry>;
-export {};

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

@@ -956,6 +956,8 @@ export type StateSchema = {
     contextSchema?: StandardSchemaV1;
     input?: unknown;
     type?: unknown;
+    history?: unknown;
+    target?: unknown;
     invoke?: unknown;
     on?: unknown;
     entry?: unknown;

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

@@ -1,4 +1,4 @@
-import { StandardSchemaV1 } from "./schema.types.js";
+import { SetupStateSchemas, StandardSchemaV1 } from "./schema.types.js";
 import { MachineSnapshot } from "./State.js";
 import { Action, ActorTimeoutEvent, AfterEvent, ActorLogic, ActorRef, ActorRefFromLogic, ActorSelf, AnyActorLogic, AnyActorRef, Compute, DoneActorEvent, DoNotInfer, ErrorActorEvent, EventDescriptor, ErrorEvent, EventObject, EventPayloadPattern, ExtractEvent, InitialContext, InputFrom, IsNever, MetaObject, NonReducibleUnknown, OutputFrom, SingleOrArray, SnapshotEvent, StateValue, TODO, TransitionContextMapper, TransitionContextPatch, TransitionConfigFunction, Values, AnyStateNode, SystemRegistry, TimeoutEvent } from "./types.js";
 import { MachineContext, Mapper } from "./types.js";
@@ -102,7 +102,7 @@ type MachineSchemas<TContextSchema extends StandardSchemaV1, TEventSchemaMap ext
     children?: TChildrenSchemaMap;
 };
 export type AnyMachineSchemas = MachineSchemas<StandardSchemaV1, Record<string, StandardSchemaV1>, Record<string, StandardSchemaV1>, StandardSchemaV1, StandardSchemaV1, StandardSchemaV1, StandardSchemaV1, Record<string, 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, TChildrenSchemaMap extends Record<string, StandardSchemaV1>, TContext extends MachineContext = InferOutput<TContextSchema, MachineContext>, TEvent extends EventObject = InferEvents<TEventSchemaMap>, TChildren extends Record<string, AnyActorRef | undefined> = InferChildren<TChildrenSchemaMap>, TDelays extends string = string, _TTag extends string = string, TActionMap extends Sources['actions'] = Sources['actions'], TActorMap extends Sources['actors'] = Sources['actors'], TGuardMap extends Sources['guards'] = Sources['guards'], TDelayMap extends Sources['delays'] = Sources['delays'], TContextRequired extends boolean = IsNever<TContext> extends true ? false : true, TSystemRegistry extends SystemRegistry = SystemRegistry> = (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<TChildren>, DoNotInfer<TActionMap>, DoNotInfer<TActorMap>, DoNotInfer<TGuardMap>, DoNotInfer<TDelayMap>, Record<string, unknown> | undefined, Record<string, unknown>, DoNotInfer<TSystemRegistry>, DoNotInfer<InferOutput<TOutputSchema, unknown>>>, 'output'> & {
+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, TChildrenSchemaMap extends Record<string, StandardSchemaV1>, TContext extends MachineContext = InferOutput<TContextSchema, MachineContext>, TEvent extends EventObject = InferEvents<TEventSchemaMap>, TChildren extends Record<string, AnyActorRef | undefined> = InferChildren<TChildrenSchemaMap>, TDelays extends string = string, _TTag extends string = string, TActionMap extends Sources['actions'] = Sources['actions'], TActorMap extends Sources['actors'] = Sources['actors'], TGuardMap extends Sources['guards'] = Sources['guards'], TDelayMap extends Sources['delays'] = Sources['delays'], TContextRequired extends boolean = IsNever<TContext> extends true ? false : true, TSystemRegistry extends SystemRegistry = SystemRegistry> = (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<TChildren>, DoNotInfer<TActionMap>, DoNotInfer<TActorMap>, DoNotInfer<TGuardMap>, DoNotInfer<TDelayMap>, Record<string, unknown> | undefined, Record<string, unknown>, DoNotInfer<TSystemRegistry>, DoNotInfer<InferOutput<TOutputSchema, unknown>>>, 'output' | 'schemas'> & {
     internalEvents?: readonly InternalEventDescriptorFor<InferEvents<TEventSchemaMap>>[];
     schemas?: MachineSchemas<TContextSchema, TEventSchemaMap, TEmittedSchemaMap, TInputSchema, TOutputSchema, TMetaSchema, TTagSchema, TChildrenSchemaMap>;
     actions?: TActionMap;
@@ -264,6 +264,7 @@ type Next_ChoiceConfigFunction<TContext extends MachineContext, TCurrentEvent ex
 export type Next_StateNodeConfig<TContext extends MachineContext, TEvent extends EventObject, TDelays extends string, TTag extends string, _TOutput, TEmitted extends EventObject, TMeta extends MetaObject, TChildren extends Record<string, AnyActorRef | undefined>, TActionMap extends Sources['actions'], TActorMap extends Sources['actors'], TGuardMap extends Sources['guards'], TDelayMap extends Sources['delays'], TInput = Record<string, unknown> | undefined, TInputMap extends Record<string, unknown> = Record<string, unknown>, TSystemRegistry extends SystemRegistry = SystemRegistry, TChildOutput = unknown> = Next_RegularStateNodeConfig<TContext, TEvent, TDelays, TTag, _TOutput, TEmitted, TMeta, TChildren, TActionMap, TActorMap, TGuardMap, TDelayMap, TInput, TInputMap, TSystemRegistry, TChildOutput> | Next_ChoiceStateNodeConfig<TContext, TEvent, TTag, TMeta, TActionMap, TActorMap, TGuardMap, TDelayMap>;
 interface Next_ChoiceStateNodeConfig<TContext extends MachineContext, TEvent extends EventObject, TTag extends string, TMeta extends MetaObject, TActionMap extends Sources['actions'], TActorMap extends Sources['actors'], TGuardMap extends Sources['guards'], TDelayMap extends Sources['delays']> {
     contextSchema?: StandardSchemaV1;
+    schemas?: SetupStateSchemas;
     type: 'choice';
     /** Function that resolves this choice state to a target. */
     choice: Next_ChoiceConfigFunction<TContext, TEvent, TEvent, TActionMap, TActorMap, TGuardMap, TDelayMap, TMeta>;
@@ -291,6 +292,7 @@ interface Next_ChoiceStateNodeConfig<TContext extends MachineContext, TEvent ext
 }
 interface Next_RegularStateNodeConfig<TContext extends MachineContext, TEvent extends EventObject, TDelays extends string, TTag extends string, TOutput, TEmitted extends EventObject, TMeta extends MetaObject, TChildren extends Record<string, AnyActorRef | undefined>, TActionMap extends Sources['actions'], TActorMap extends Sources['actors'], TGuardMap extends Sources['guards'], TDelayMap extends Sources['delays'], TInput = Record<string, unknown> | undefined, TInputMap extends Record<string, unknown> = Record<string, unknown>, TSystemRegistry extends SystemRegistry = SystemRegistry, TChildOutput = unknown> {
     contextSchema?: StandardSchemaV1;
+    schemas?: SetupStateSchemas;
     /** The initial state transition. */
     initial?: string | {
         target: string;
@@ -416,9 +418,9 @@ interface Next_RegularStateNodeConfig<TContext extends MachineContext, TEvent ex
     /** A text description of the state node */
     description?: string;
     /** A default target for a history state */
-    target?: string | undefined;
+    target?: string | string[] | undefined;
 }
-export type Next_TransitionConfigOrTarget<TContext extends MachineContext, TExpressionEvent 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> = SingleOrArray<undefined | {
+export type Next_TransitionConfigOrTarget<TContext extends MachineContext, TExpressionEvent 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> = undefined | {
     matches?: EventPayloadPattern<TExpressionEvent>;
     target?: string | string[];
     context?: TransitionContextPatch<TContext> | TransitionContextMapper<TContext, TExpressionEvent, TEvent, TActionMap, TActorMap, TGuardMap, TDelayMap>;
@@ -440,7 +442,7 @@ export type Next_TransitionConfigOrTarget<TContext extends MachineContext, TExpr
         context: any;
         event: any;
     }) => Record<string, unknown>);
-} | TransitionConfigFunction<TContext, TExpressionEvent, TEvent, TEmitted, TActionMap, TActorMap, TGuardMap, TDelayMap, TMeta, TInput>>;
+} | TransitionConfigFunction<TContext, TExpressionEvent, TEvent, TEmitted, TActionMap, TActorMap, TGuardMap, TDelayMap, TMeta, TInput>;
 export type WithDefault<T, Default> = IsNever<T> extends true ? Default : T;
 export interface Sources {
     actions: Record<string, (...args: any[]) => void | {
@@ -465,4 +467,164 @@ type InvalidDelayReferences<TConfig, TDelays extends string> = (TConfig extends
     [K in keyof TStates]: InvalidDelayReferences<TStates[K], TDelays>;
 }[keyof TStates] : never : never);
 export type ValidateDelayReferences<TConfig> = string extends DelayNamesFromConfig<TConfig> ? unknown : InvalidDelayReferences<TConfig, DelayNamesFromConfig<TConfig>> extends never ? unknown : never;
+type IsHistoryStateConfig<TConfig> = TConfig extends {
+    type: 'history';
+} ? true : TConfig extends {
+    history: false | undefined;
+} ? false : TConfig extends {
+    history: unknown;
+} ? true : false;
+type MissingHistoryDefault<TConfig> = 0 extends 1 & TConfig ? never : IsHistoryStateConfig<TConfig> extends true ? TConfig extends {
+    target: string | readonly [string, ...string[]];
+} ? never : true : TConfig extends {
+    states: infer TStates;
+} ? TStates extends Record<string, unknown> ? {
+    [K in keyof TStates]: MissingHistoryDefault<TStates[K]>;
+}[keyof TStates] : never : never;
+/**
+ * Rejects authored machines containing a history state without its SCXML
+ * default target.
+ */
+export type ValidateHistoryDefaults<TConfig> = MissingHistoryDefault<TConfig> extends never ? unknown : never;
+type StatePath = readonly string[];
+type AppendStatePath<TPrefix extends StatePath, TKey extends string> = [
+    ...TPrefix,
+    TKey
+];
+type EscapeStatePathDots<TValue extends string> = TValue extends `${infer THead}.${infer TTail}` ? `${THead}\\.${EscapeStatePathDots<TTail>}` : TValue;
+type ProtectEscapedStatePathDots<TValue extends string> = TValue extends `${infer THead}\\.${infer TTail}` ? `${THead}__XSTATE_ESCAPED_DOT__${ProtectEscapedStatePathDots<TTail>}` : TValue;
+type RestoreEscapedStatePathDots<TValue extends string> = TValue extends `${infer THead}__XSTATE_ESCAPED_DOT__${infer TTail}` ? `${THead}.${RestoreEscapedStatePathDots<TTail>}` : TValue;
+type SplitStatePath<TPath extends string> = ProtectEscapedStatePathDots<TPath> extends infer TProtected extends string ? TProtected extends '' ? [] : TProtected extends `${infer THead}.${infer TTail}` ? [RestoreEscapedStatePathDots<THead>, ...SplitStatePath<TTail>] : [RestoreEscapedStatePathDots<TProtected>] : never;
+type ParentStatePath<TPath extends StatePath> = TPath extends readonly [
+    ...infer TParent extends string[],
+    string
+] ? TParent : [];
+type StatePathsFromStates<TStates, TPrefix extends StatePath = []> = TStates extends Record<string, unknown> ? {
+    [K in keyof TStates & string]: AppendStatePath<TPrefix, K> | (0 extends 1 & TStates[K] ? never : TStates[K] extends {
+        states: infer TChildren;
+    } ? StatePathsFromStates<TChildren, AppendStatePath<TPrefix, K>> : never);
+}[keyof TStates & string] : never;
+type AuthoredStatePaths<TConfig> = TConfig extends {
+    states: infer TStates;
+} ? StatePathsFromStates<TStates> : never;
+type OpaqueStatePathsFromStates<TStates, TPrefix extends StatePath = []> = TStates extends Record<string, unknown> ? {
+    [K in keyof TStates & string]: 0 extends 1 & TStates[K] ? AppendStatePath<TPrefix, K> : TStates[K] extends {
+        states: infer TChildren;
+    } ? OpaqueStatePathsFromStates<TChildren, AppendStatePath<TPrefix, K>> : never;
+}[keyof TStates & string] : never;
+type OpaqueStatePaths<TConfig> = TConfig extends {
+    states: infer TStates;
+} ? OpaqueStatePathsFromStates<TStates> : never;
+type IsWithinStatePath<TPath extends StatePath, TAncestor> = TAncestor extends StatePath ? TPath extends readonly [...TAncestor, ...string[]] ? true : false : false;
+type JoinStateTargetString<TPrefix extends string, TKey extends string> = TPrefix extends '' ? TKey : `${TPrefix}.${TKey}`;
+type StateTargetStringsFromStates<TStates, TPrefix extends string = ''> = TStates extends Record<string, unknown> ? {
+    [K in keyof TStates & string]: JoinStateTargetString<TPrefix, EscapeStatePathDots<K>> | (0 extends 1 & TStates[K] ? never : TStates[K] extends {
+        states: infer TChildren;
+    } ? StateTargetStringsFromStates<TChildren, JoinStateTargetString<TPrefix, EscapeStatePathDots<K>>> : never);
+}[keyof TStates & string] : never;
+type IdTargetsForNode<TNode> = TNode extends {
+    id: infer TId extends string;
+} ? string extends TId ? never : TNode extends {
+    states: infer TStates;
+} ? `#${EscapeStatePathDots<TId>}` | `#${EscapeStatePathDots<TId>}.${StateTargetStringsFromStates<TStates>}` : `#${EscapeStatePathDots<TId>}` : never;
+type IdTargetsFromStates<TStates> = TStates extends Record<string, unknown> ? {
+    [K in keyof TStates & string]: IdTargetsForNode<TStates[K]> | (0 extends 1 & TStates[K] ? never : TStates[K] extends {
+        states: infer TChildren;
+    } ? IdTargetsFromStates<TChildren> : never);
+}[keyof TStates & string] : never;
+type AuthoredIdTargets<TConfig> = IdTargetsForNode<TConfig> | (TConfig extends {
+    states: infer TStates;
+} ? IdTargetsFromStates<TStates> : never);
+type ResolveIdTargetAtNode<TNode, TNodePath extends StatePath, TTarget extends string> = TNode extends {
+    id: infer TId extends string;
+} ? string extends TId ? never : TTarget extends `#${EscapeStatePathDots<TId>}` ? TNodePath : TTarget extends `#${EscapeStatePathDots<TId>}.${infer TDescendant}` ? [...TNodePath, ...SplitStatePath<TDescendant>] : never : never;
+type ResolveIdTargetInStates<TStates, TTarget extends string, TPrefix extends StatePath = []> = TStates extends Record<string, unknown> ? {
+    [K in keyof TStates & string]: ResolveIdTargetAtNode<TStates[K], AppendStatePath<TPrefix, K>, TTarget> | (0 extends 1 & TStates[K] ? never : TStates[K] extends {
+        states: infer TChildren;
+    } ? ResolveIdTargetInStates<TChildren, TTarget, AppendStatePath<TPrefix, K>> : never);
+}[keyof TStates & string] : never;
+type ResolveIdTargetPath<TConfig, TTarget extends string> = ResolveIdTargetAtNode<TConfig, [], TTarget> | (TConfig extends {
+    states: infer TStates;
+} ? ResolveIdTargetInStates<TStates, TTarget> : never);
+type ResolveAuthoredTarget<TSourcePath extends StatePath, TTarget extends string> = TTarget extends `#${string}` ? never : TTarget extends '.' ? TSourcePath : TTarget extends `.${infer TDescendant}` ? [...TSourcePath, ...SplitStatePath<TDescendant>] : [...ParentStatePath<TSourcePath>, ...SplitStatePath<TTarget>];
+type StateNodeAtPath<TConfig, TPath extends StatePath> = TConfig extends {
+    states: infer TStates;
+} ? TPath extends readonly [
+    infer THead extends string,
+    ...infer TTail extends string[]
+] ? THead extends keyof TStates ? TTail extends [] ? TStates[THead] : StateNodeAtPath<TStates[THead], TTail> : never : TConfig : never;
+type CommonStatePathSegments<TLeft extends readonly string[], TRight extends readonly string[], TCommon extends readonly string[] = []> = TLeft extends readonly [
+    infer TLeftHead extends string,
+    ...infer TLeftTail extends string[]
+] ? TRight extends readonly [
+    infer TRightHead extends string,
+    ...infer TRightTail extends string[]
+] ? TLeftHead extends TRightHead ? CommonStatePathSegments<TLeftTail, TRightTail, [...TCommon, TLeftHead]> : TCommon : TCommon : TCommon;
+type NearestCommonStatePath<TLeft extends StatePath, TRight extends StatePath> = CommonStatePathSegments<TLeft, TRight>;
+type IsAncestorStatePath<TAncestor extends StatePath, TDescendant extends StatePath> = TDescendant extends readonly [...TAncestor, ...infer TRest] ? TRest extends [] ? false : true : false;
+type IsParallelStatePath<TConfig, TPath extends StatePath> = TPath extends readonly [] ? TConfig extends {
+    type: 'parallel';
+} ? true : false : StateNodeAtPath<TConfig, TPath> extends {
+    type: 'parallel';
+} ? true : false;
+type ResolvedAuthoredTargetPath<TRootConfig, TSourcePath extends StatePath, TTarget> = TTarget extends string ? TTarget extends `#${string}` ? ResolveIdTargetPath<TRootConfig, TTarget> : ResolveAuthoredTarget<TSourcePath, TTarget> : never;
+type InvalidTargetPair<TRootConfig, TLeftPath extends StatePath, TRightPath extends StatePath> = TLeftPath extends TRightPath ? TRightPath extends TLeftPath ? true : never : IsAncestorStatePath<TLeftPath, TRightPath> extends true ? true : IsAncestorStatePath<TRightPath, TLeftPath> extends true ? true : IsParallelStatePath<TRootConfig, NearestCommonStatePath<TLeftPath, TRightPath>> extends true ? never : true;
+type InvalidTargetPairsWithHead<TRootConfig, TSourcePath extends StatePath, THead, TRest extends readonly unknown[]> = TRest extends readonly [infer TNext, ...infer TTail] ? (ResolvedAuthoredTargetPath<TRootConfig, TSourcePath, THead> extends infer THeadPath extends StatePath ? ResolvedAuthoredTargetPath<TRootConfig, TSourcePath, TNext> extends infer TNextPath extends StatePath ? InvalidTargetPair<TRootConfig, THeadPath, TNextPath> : never : never) | InvalidTargetPairsWithHead<TRootConfig, TSourcePath, THead, TTail> : never;
+type InvalidTargetSet<TRootConfig, TSourcePath extends StatePath, TTargets> = TTargets extends readonly [infer THead, ...infer TRest] ? InvalidTargetPairsWithHead<TRootConfig, TSourcePath, THead, TRest> | InvalidTargetSet<TRootConfig, TSourcePath, TRest> : never;
+type InvalidTargetValue<TRootConfig, TSourcePath extends StatePath, TTarget> = TTarget extends string ? string extends TTarget ? never : TTarget extends `#${string}` ? TTarget extends AuthoredIdTargets<TRootConfig> ? never : TTarget : ResolveAuthoredTarget<TSourcePath, TTarget> extends infer TResolvedTarget extends StatePath ? TResolvedTarget extends AuthoredStatePaths<TRootConfig> ? never : true extends IsWithinStatePath<TResolvedTarget, OpaqueStatePaths<TRootConfig>> ? never : TTarget : TTarget : TTarget extends readonly unknown[] ? InvalidTargetValue<TRootConfig, TSourcePath, TTarget[number]> : never;
+type InvalidTransitionTarget<TRootConfig, TSourcePath extends StatePath, TTransition> = 0 extends 1 & TTransition ? never : TTransition extends (...args: any[]) => any ? InvalidTransitionTarget<TRootConfig, TSourcePath, ReturnType<TTransition>> : TTransition extends readonly unknown[] ? InvalidTransitionTarget<TRootConfig, TSourcePath, TTransition[number]> : TTransition extends {
+    target: infer TTarget;
+} ? InvalidTargetValue<TRootConfig, TSourcePath, TTarget> | InvalidTargetSet<TRootConfig, TSourcePath, TTarget> : never;
+type InvalidTransitionMapTargets<TRootConfig, TSourcePath extends StatePath, TTransitionMap> = 0 extends 1 & TTransitionMap ? never : TTransitionMap extends Record<string, unknown> ? {
+    [K in keyof TTransitionMap]: InvalidTransitionTarget<TRootConfig, TSourcePath, TTransitionMap[K]>;
+}[keyof TTransitionMap] : never;
+type InvalidInvokeTargets<TRootConfig, TSourcePath extends StatePath, TInvoke> = 0 extends 1 & TInvoke ? never : TInvoke extends readonly unknown[] ? InvalidInvokeTargets<TRootConfig, TSourcePath, TInvoke[number]> : TInvoke extends Record<string, unknown> ? (TInvoke extends {
+    onDone: infer TOnDone;
+} ? InvalidTransitionTarget<TRootConfig, TSourcePath, TOnDone> : never) | (TInvoke extends {
+    onError: infer TOnError;
+} ? InvalidTransitionTarget<TRootConfig, TSourcePath, TOnError> : never) | (TInvoke extends {
+    onSnapshot: infer TOnSnapshot;
+} ? InvalidTransitionTarget<TRootConfig, TSourcePath, TOnSnapshot> : never) | (TInvoke extends {
+    onTimeout: infer TOnTimeout;
+} ? InvalidTransitionTarget<TRootConfig, TSourcePath, TOnTimeout> : never) : never;
+type InvalidNodeTargets<TRootConfig, TNode, TSourcePath extends StatePath> = 0 extends 1 & TNode ? never : (TNode extends {
+    initial: infer TInitial;
+    states: infer TChildStates;
+} ? (TInitial extends {
+    target: infer TInitialTarget;
+} ? TInitialTarget : TInitial) extends infer TInitialTarget ? TInitialTarget extends string ? string extends TInitialTarget ? never : TInitialTarget extends keyof TChildStates ? never : TInitialTarget : never : never : never) | (TNode extends {
+    on: infer TOn;
+} ? InvalidTransitionMapTargets<TRootConfig, TSourcePath, TOn> : never) | (TNode extends {
+    always: infer TAlways;
+} ? InvalidTransitionTarget<TRootConfig, TSourcePath, TAlways> : never) | (TNode extends {
+    choice: infer TChoice;
+} ? InvalidTransitionTarget<TRootConfig, TSourcePath, TChoice> : never) | (TNode extends {
+    after: infer TAfter;
+} ? InvalidTransitionMapTargets<TRootConfig, TSourcePath, TAfter> : never) | (TNode extends {
+    onDone: infer TOnDone;
+} ? InvalidTransitionTarget<TRootConfig, TSourcePath, TOnDone> : never) | (TNode extends {
+    onError: infer TOnError;
+} ? InvalidTransitionTarget<TRootConfig, TSourcePath, TOnError> : never) | (TNode extends {
+    onTimeout: infer TOnTimeout;
+} ? InvalidTransitionTarget<TRootConfig, TSourcePath, TOnTimeout> : never) | (TNode extends {
+    invoke: infer TInvoke;
+} ? InvalidInvokeTargets<TRootConfig, TSourcePath, TInvoke> : never) | (TNode extends {
+    target: infer THistoryTarget;
+} ? InvalidTargetValue<TRootConfig, TSourcePath, THistoryTarget> : never);
+type InvalidTargetsInStates<TRootConfig, TStates, TPrefix extends StatePath = []> = TStates extends Record<string, unknown> ? {
+    [K in keyof TStates & string]: 0 extends 1 & TStates[K] ? never : InvalidNodeTargets<TRootConfig, TStates[K], AppendStatePath<TPrefix, K>> | (TStates[K] extends {
+        states: infer TChildren;
+    } ? InvalidTargetsInStates<TRootConfig, TChildren, AppendStatePath<TPrefix, K>> : never);
+}[keyof TStates & string] : never;
+/**
+ * Rejects authored literal transition targets that do not resolve in the
+ * machine topology.
+ */
+export type ValidateStateTargets<TConfig> = 0 extends 1 & TConfig ? unknown : TConfig extends {
+    states: infer TStates;
+} ? (TConfig extends {
+    initial: infer TInitial;
+} ? (TInitial extends {
+    target: infer TInitialTarget;
+} ? TInitialTarget : TInitial) extends infer TInitialTarget ? TInitialTarget extends string ? string extends TInitialTarget ? never : TInitialTarget extends keyof TStates ? never : TInitialTarget : never : never : never) | InvalidNodeTargets<TConfig, TConfig, []> | InvalidTargetsInStates<TConfig, TStates> extends never ? unknown : never : unknown;
 export {};

package/dist/{index-b90ebcd4.development.esm.js → index-41508d62.development.esm.js}

@@ -1285,6 +1285,7 @@ function formatTransition(stateNode, descriptor, transitionConfig) {
   const normalizedTarget = normalizeTarget(transitionConfig.target);
   const reenter = transitionConfig.reenter ?? false;
   const target = resolveTarget(stateNode, normalizedTarget);
+  assertLegalTargetSet(stateNode, target);
   const transition = {
     ...transitionConfig,
     target,
@@ -1299,6 +1300,41 @@ function formatTransition(stateNode, descriptor, transitionConfig) {
   };
   return transition;
 }
+function isStateNodeDescendantOf(stateNode, ancestor) {
+  for (let current = stateNode.parent; current; current = current.parent) {
+    if (current === ancestor) {
+      return true;
+    }
+  }
+  return false;
+}
+function getLeastCommonStateNodeAncestor(left, right) {
+  const leftAncestors = new Set();
+  for (let current = left; current; current = current.parent) {
+    leftAncestors.add(current);
+  }
+  for (let current = right; current; current = current.parent) {
+    if (leftAncestors.has(current)) {
+      return current;
+    }
+  }
+  return undefined;
+}
+function assertLegalTargetSet(source, targets) {
+  if (!targets || targets.length < 2) {
+    return;
+  }
+  for (let leftIndex = 0; leftIndex < targets.length; leftIndex++) {
+    for (let rightIndex = leftIndex + 1; rightIndex < targets.length; rightIndex++) {
+      const left = targets[leftIndex];
+      const right = targets[rightIndex];
+      const commonAncestor = getLeastCommonStateNodeAncestor(left, right);
+      if (left === right || isStateNodeDescendantOf(left, right) || isStateNodeDescendantOf(right, left) || commonAncestor?.type !== 'parallel') {
+        throw new Error(`Invalid transition definition for state node '${source.id}': target set is not a legal SCXML configuration.` );
+      }
+    }
+  }
+}
 
 /**
  * Collects route transitions from all descendants with explicit IDs. Called
@@ -1401,8 +1437,10 @@ function resolveHistoryDefaultTransition(stateNode) {
     }
     return stateNode.parent.initial;
   }
+  const target = normalizedTarget.map(t => typeof t === 'string' ? getStateNodeByPath(stateNode.parent, t) : t);
+  assertLegalTargetSet(stateNode, target);
   return {
-    target: normalizedTarget.map(t => typeof t === 'string' ? getStateNodeByPath(stateNode.parent, t) : t),
+    target,
     source: stateNode,
     reenter: false,
     eventType: ''