xstate 6.0.0-alpha.56 → 6.0.0-alpha.58

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

@@ -5,5 +5,5 @@ export { createLogic, type LogicActorLogic, type LogicActorRef, type LogicArgs,
 export { createAsyncLogic, type AsyncActorLogic, type AsyncActorRef, type AsyncSnapshot, type LogicArgs as AsyncLogicArgs, type LogicConfig as AsyncLogicConfig, type LogicEnqueue as AsyncLogicEnqueue, type LogicFunction as AsyncLogicFunction, TimeoutError } from "./promise.js";
 export { createListenerLogic, listenerLogic, type ListenerActorLogic, type ListenerActorRef, type ListenerSnapshot, type ListenerInput } from "./listener.js";
 export { createSubscriptionLogic, subscriptionLogic, type SubscriptionActorLogic, type SubscriptionActorRef, type SubscriptionSnapshot, type SubscriptionInput, type SubscriptionMappers } from "./subscription.js";
-declare const emptyLogic: import("./logic.js").LogicActorLogic<undefined, undefined, import("../types.js").EventObject, import("../types.js").NonReducibleUnknown, import("../types.js").EventObject>;
+declare const emptyLogic: import("./logic.js").LogicActorLogic<undefined, undefined, import("../base.types.js").EventObject, import("../types.js").NonReducibleUnknown, import("../base.types.js").EventObject>;
 export declare function createEmptyActor(): ActorFromLogic<typeof emptyLogic>;

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

@@ -0,0 +1,87 @@
+/**
+ * Lean type primitives shared by the main `xstate` entry and the compact
+ * `xstate/fsm` entry. This module (plus `schema.types.ts`) must stay free of
+ * imports from the rest of the package so that `xstate/fsm` consumers do not
+ * pull the full type surface into their program.
+ */
+import type { SetupStateSchemas, StandardSchemaV1, TypeSchema } from "./schema.types.js";
+declare global {
+    interface SymbolConstructor {
+        readonly observable: symbol;
+    }
+}
+/** The full definition of an event, with a string `type`. */
+export type EventObject = {
+    /** The type of event that is sent. */
+    type: string;
+};
+export type MachineContext = Record<string, any>;
+export type Values<T> = T[keyof T];
+export type ActionSchemas = Record<string, {
+    params: StandardSchemaV1;
+}>;
+export type GuardSchemas = Record<string, {
+    params: StandardSchemaV1;
+}>;
+/** State node types that can be declared in a setup state contract. */
+export type SetupStateType = 'atomic' | 'compound' | 'parallel' | 'final' | 'history' | 'choice';
+export type SetupSchemas = {
+    context?: StandardSchemaV1;
+    events?: Record<string, StandardSchemaV1>;
+    internalEvents?: Record<string, StandardSchemaV1>;
+    actions?: ActionSchemas;
+    guards?: GuardSchemas;
+    emitted?: Record<string, StandardSchemaV1>;
+    input?: StandardSchemaV1;
+    output?: StandardSchemaV1;
+    meta?: StandardSchemaV1;
+    transitionMeta?: StandardSchemaV1;
+    tags?: StandardSchemaV1;
+    children?: Record<string, StandardSchemaV1>;
+};
+/**
+ * State schema with optional input/output schemas, structural metadata, and
+ * nested states.
+ *
+ * Structural fields are contracts/defaults for `createMachine(...)`; machine
+ * behavior remains authored in the machine config.
+ */
+export interface SetupStateSchema {
+    type?: SetupStateType;
+    id?: string;
+    initial?: string;
+    history?: 'shallow' | 'deep' | true;
+    target?: string | readonly [string, ...string[]];
+    route?: true;
+    schemas?: SetupStateSchemas;
+    states?: Record<string, SetupStateSchema>;
+}
+/**
+ * Event payloads from schemas (e.g. Zod) are often inferred as optional in
+ * output types. Wrapping in Required<> ensures properties defined in the schema
+ * are required on the event. Type-only schemas created with the `types()`
+ * helper are exempt: their declared type is authoritative, so optional
+ * properties stay optional.
+ */
+export type InferEvents<TEventSchemaMap extends Record<string, StandardSchemaV1>> = Values<{
+    [K in keyof TEventSchemaMap & string]: StandardSchemaV1.InferOutput<TEventSchemaMap[K]> extends infer O ? [O] extends [never] ? never : unknown extends O ? O & {
+        type: K;
+    } : [O] extends [void] ? {
+        type: K;
+    } : string extends keyof O ? [O[string]] extends [never] ? {
+        type: EventTypeFromSchemaKey<K>;
+    } : NormalizeEventPayload<TEventSchemaMap[K], O> & {
+        type: EventTypeFromSchemaKey<K>;
+    } : NormalizeEventPayload<TEventSchemaMap[K], O> & {
+        type: EventTypeFromSchemaKey<K>;
+    } : never;
+}>;
+/** Infers internal events only from explicitly declared schema keys. */
+export type InferInternalEvents<TEventSchemaMap extends Record<string, StandardSchemaV1>> = string extends keyof TEventSchemaMap ? never : InferEvents<TEventSchemaMap>;
+type EventTypeFromSchemaKey<TKey extends string> = TKey extends '*' ? string : TKey extends `${infer TLeading}.*` ? `${TLeading}.${string}` : TKey;
+/**
+ * Keeps a type-only schema's payload verbatim; applies Required<> to payloads
+ * from validator libraries (see {@link InferEvents}).
+ */
+type NormalizeEventPayload<TSchema extends StandardSchemaV1, O> = TSchema extends TypeSchema<any> ? O : Required<O>;
+export {};

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

@@ -1,7 +1,5 @@
-import type { EventObject, MachineContext } from "./types.js";
+import type { EventObject, InferEvents, MachineContext, SetupSchemas, SetupStateSchema } from "./base.types.js";
 import type { StandardSchemaV1 } from "./schema.types.js";
-import type { SetupSchemas, SetupStateSchema } from "./setup.js";
-import type { InferEvents } from "./types.v6.js";
 export type FSMArgs<TContext extends MachineContext, TEvent extends EventObject> = {
     context: TContext;
     event: TEvent;

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

@@ -11,7 +11,7 @@ export { machineVersions, type AdaptEventsOptions, type EventAdapterHandlers, ty
 export { types, isTypeSchema, type StandardSchemaV1, type TypeSchema } from "./schema.types.js";
 export type { ActorValidationBoundary, ActorValidationEventOrigin, ActorValidationRequest, ActorLogicValidator } from "./validation.types.js";
 export { createSystem, setup } from "./setup.js";
-export type { AnySetupConfig, SetupConfig, SetupReturn, SetupReturnFromConfig, SetupSchemas, SystemActorMap, SystemConfig, SystemRuntime, SetupStateSchema, SetupStateSchemas, SetupStateType } from "./setup.js";
+export type { ActiveStateContext, AnySetupConfig, RootContextMarker, StrictSetupStateSchemas, StrictSetupStateTargetsFlag, StrictSetupStateTargetsMarker, RelativeSetupStateSchemasMarker, CurrentSetupStateSchemaMarker, SetupStateParentTypeMarker, SetupStateSchemasWithParentType, RootSetupStateSchemasMarker, WithRootSetupStateSchemas, SetupConfig, SetupReturn, SetupReturnFromConfig, SetupSchemas, SystemActorMap, SystemConfig, SystemRuntime, SetupStateSchema, SetupStateSchemas, SetupStateType } from "./setup.js";
 export { getInitialSnapshot, getNextSnapshot } from "./getNextSnapshot.js";
 export type { InspectionEvent, ActorInspectionEvent, DeadLetterInspectionEvent, TransitionInspectionEvent, ActionRecord, SentRecord } from "./inspection.js";
 export { SimulatedClock } from "./SimulatedClock.js";
@@ -24,15 +24,10 @@ export type { ActorSystem, ActorSystemRuntime, AnyActorSystem, DeadLetterDetail,
 export { toPromise } from "./toPromise.js";
 export type * from "./types.js";
 export { SpecialTargets } from "./types.js";
-export type { Next_MachineConfig as MachineConfig, Next_StateNodeConfig as StateNodeConfig, Next_InvokeConfig as InvokeConfig, Next_TransitionConfigOrTarget as TransitionConfigOrTarget, Sources, InferEvents, WidenLiterals } from "./types.v6.js";
+export type { Next_MachineConfig as MachineConfig, Next_StateNodeConfig as StateNodeConfig, Next_ChoiceStateNodeConfig as ChoiceStateNodeConfig, Next_RegularStateNodeConfig as RegularStateNodeConfig, Next_InvokeConfig as InvokeConfig, Next_TransitionConfigOrTarget as TransitionConfigOrTarget, Sources, InferEvents, WidenLiterals } from "./types.v6.js";
 export { getAllOwnEventDescriptors as __unsafe_getAllOwnEventDescriptors, matchesState, checkStateIn, pathToStateValue, toObserver } from "./utils.js";
 export { transition, initialTransition, getMicrosteps, getInitialMicrosteps, getNextTransitions } from "./transition.js";
 export { executeEffects, isBuiltInExecutableAction } from "./transitionActions.js";
 export { getEffectDescriptor, type EffectDescriptor } from "./effectDescriptor.js";
 export { deliverEvent, runStep, stopActor, terminateActor } from "./runtimeHelpers.js";
 export { waitFor } from "./waitFor.js";
-declare global {
-    interface SymbolConstructor {
-        readonly observable: symbol;
-    }
-}

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

@@ -1,11 +1,12 @@
 import { SetupStateSchemas, StandardSchemaV1 } from "./schema.types.js";
+import type { SetupSchemas, SetupStateSchema, SetupStateType } from "./base.types.js";
 import type { ActorLogicValidator } from "./validation.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, StateValueFromStateSchema, ToChildren, MetaObject, Cast, Compute, EnqueueObject, DoneActorEvent, DoneStateEvent, ErrorFrom, 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, DelaySourceMap, GuardSourceMap, GuardSchemas, InferChildren, InferActions, InferGuards, Sources, InferOutput, InferEvents, InferInternalEvents, Next_MachineConfig, Next_InvokeConfig, Next_StateNodeConfig, Next_TransitionConfigOrTarget, OutputFromConfig, ValidateHistoryDefaults, ValidateStateTargets, WithDefault } from "./types.v6.js";
+import { ActionSchemas, DelayMapFromNames, DelaySourceMap, GuardSourceMap, GuardSchemas, InferChildren, InferActions, InferGuards, Sources, InferOutput, InferEvents, InferInternalEvents, Next_MachineConfig, Next_InvokeConfig, Next_StateNodeConfig, Next_TransitionConfigOrTarget, FinalStateConfigOutput, OutputFromConfig, 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'], TValidator extends ActorLogicValidator | undefined = ActorLogicValidator | undefined> = {
     validator?: TValidator;
     schemas?: TSchemas;
@@ -157,39 +158,7 @@ type ValidateRegistryKeys<TConfig, TSystemRegistry extends SystemRegistry, TActo
     };
 } : unknown);
 export type { SetupStateSchemas };
-/** State node types that can be declared in a setup state contract. */
-export type SetupStateType = 'atomic' | 'compound' | 'parallel' | 'final' | 'history' | 'choice';
-export type SetupSchemas = {
-    context?: StandardSchemaV1;
-    events?: Record<string, StandardSchemaV1>;
-    internalEvents?: Record<string, StandardSchemaV1>;
-    actions?: ActionSchemas;
-    guards?: GuardSchemas;
-    emitted?: Record<string, StandardSchemaV1>;
-    input?: StandardSchemaV1;
-    output?: StandardSchemaV1;
-    meta?: StandardSchemaV1;
-    transitionMeta?: StandardSchemaV1;
-    tags?: StandardSchemaV1;
-    children?: Record<string, StandardSchemaV1>;
-};
-/**
- * State schema with optional input/output schemas, structural metadata, and
- * nested states.
- *
- * Structural fields are contracts/defaults for `createMachine(...)`; machine
- * behavior remains authored in the machine config.
- */
-export interface SetupStateSchema {
-    type?: SetupStateType;
-    id?: string;
-    initial?: string;
-    history?: 'shallow' | 'deep' | true;
-    target?: string | readonly [string, ...string[]];
-    route?: true;
-    schemas?: SetupStateSchemas;
-    states?: Record<string, SetupStateSchema>;
-}
+export type { SetupSchemas, SetupStateSchema, SetupStateType } from "./base.types.js";
 type SetupSchema<TSchemas, TKey extends keyof SetupSchemas> = TKey extends keyof TSchemas ? TSchemas[TKey] extends StandardSchemaV1 ? TSchemas[TKey] : never : never;
 type SetupSchemaMap<TSchemas, TKey extends 'events' | 'internalEvents' | 'emitted' | 'children'> = TKey extends keyof TSchemas ? TSchemas[TKey] extends Record<string, StandardSchemaV1> ? TSchemas[TKey] : never : never;
 type SetupActionSchemaMap<TSchemas> = 'actions' extends keyof TSchemas ? TSchemas['actions'] extends ActionSchemas ? TSchemas['actions'] : never : never;
@@ -206,48 +175,54 @@ 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 {
-    readonly [strictSetupStateTargets]: true;
-} ? 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 StrictSetupStateTargetsFlag ? StrictSetupStatePaths<TStateSchemas> | SetupRelativeStateTarget<RelativeSetupStateSchemas<TStateSchemas>> | `#${string}` : string extends SetupStateKeys<TStateSchemas> ? string : [SetupStateKeys<TStateSchemas>] extends [never] ? string : 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;
 declare const rootSetupStateSchemas: unique symbol;
 declare const currentSetupStateSchema: unique symbol;
 declare const parentSetupStateType: unique symbol;
-type StrictSetupStateSchemas<TStateSchemas extends Record<string, SetupStateSchema>, TRelativeStateSchemas extends Record<string, SetupStateSchema> = Record<string, SetupStateSchema>, TRootStateSchemas extends Record<string, SetupStateSchema> = RootSetupStateSchemas<TStateSchemas>, TCurrentStateSchema extends SetupStateSchema = never> = TStateSchemas & {
+/** @public Referenced by emitted declarations of strict transition targets. */
+export type StrictSetupStateTargetsFlag = {
     readonly [strictSetupStateTargets]: true;
+};
+/** @public Referenced by emitted declarations of strict transition targets. */
+export type RelativeSetupStateSchemasMarker<TRelativeStateSchemas extends Record<string, SetupStateSchema>> = {
     readonly [relativeSetupStateSchemas]: TRelativeStateSchemas;
-    readonly [rootSetupStateSchemas]: TRootStateSchemas;
+};
+/** @public Referenced by emitted declarations of strict transition targets. */
+export type CurrentSetupStateSchemaMarker<TCurrentStateSchema extends SetupStateSchema> = {
     readonly [currentSetupStateSchema]: TCurrentStateSchema;
 };
-type RelativeSetupStateSchemas<TStateSchemas extends Record<string, SetupStateSchema>> = TStateSchemas extends {
-    readonly [relativeSetupStateSchemas]: infer TRelativeStateSchemas extends Record<string, SetupStateSchema>;
-} ? TRelativeStateSchemas : TStateSchemas;
-type RootSetupStateSchemas<TStateSchemas extends Record<string, SetupStateSchema>> = TStateSchemas extends {
-    readonly [rootSetupStateSchemas]: infer TRootStateSchemas extends Record<string, SetupStateSchema>;
-} ? TRootStateSchemas : TStateSchemas;
-type CurrentSetupStateSchema<TStateSchemas extends Record<string, SetupStateSchema>> = TStateSchemas extends {
-    readonly [currentSetupStateSchema]: infer TCurrentStateSchema extends SetupStateSchema;
-} ? TCurrentStateSchema : never;
+/** @public Referenced by emitted declarations of strict transition targets. */
+export type StrictSetupStateTargetsMarker<TRelativeStateSchemas extends Record<string, SetupStateSchema>, TRootStateSchemas extends Record<string, SetupStateSchema>, TCurrentStateSchema extends SetupStateSchema> = StrictSetupStateTargetsFlag & RelativeSetupStateSchemasMarker<TRelativeStateSchemas> & RootSetupStateSchemasMarker<TRootStateSchemas> & CurrentSetupStateSchemaMarker<TCurrentStateSchema>;
+/** @public Referenced by emitted declarations of strict transition targets. */
+export type StrictSetupStateSchemas<TStateSchemas extends Record<string, SetupStateSchema>, TRelativeStateSchemas extends Record<string, SetupStateSchema> = Record<string, SetupStateSchema>, TRootStateSchemas extends Record<string, SetupStateSchema> = RootSetupStateSchemas<TStateSchemas>, TCurrentStateSchema extends SetupStateSchema = never> = TStateSchemas & StrictSetupStateTargetsMarker<TRelativeStateSchemas, TRootStateSchemas, TCurrentStateSchema>;
+type RelativeSetupStateSchemas<TStateSchemas extends Record<string, SetupStateSchema>> = TStateSchemas extends RelativeSetupStateSchemasMarker<infer TRelativeStateSchemas> ? TRelativeStateSchemas : TStateSchemas;
+type RootSetupStateSchemas<TStateSchemas extends Record<string, SetupStateSchema>> = TStateSchemas extends RootSetupStateSchemasMarker<infer TRootStateSchemas> ? TRootStateSchemas : TStateSchemas;
+type CurrentSetupStateSchema<TStateSchemas extends Record<string, SetupStateSchema>> = TStateSchemas extends CurrentSetupStateSchemaMarker<infer TCurrentStateSchema> ? TCurrentStateSchema : never;
 type SetupStateSelfSchema<TStateSchema extends SetupStateSchema> = TStateSchema extends {
     schemas: infer TSchemas extends SetupStateSchemas;
 } ? {
     schemas: TSchemas;
 } : {};
-type SetupStateSchemasWithParentType<TStateSchemas extends Record<string, SetupStateSchema>, TParentStateType extends SetupStateType | never> = TStateSchemas & {
+/** @public Referenced by emitted declarations of strict transition targets. */
+export type SetupStateParentTypeMarker<TParentStateType extends SetupStateType | never> = {
     readonly [parentSetupStateType]: TParentStateType;
 };
-type SetupStateParentType<TStateSchemas extends Record<string, SetupStateSchema>> = TStateSchemas extends {
-    readonly [parentSetupStateType]: infer TParentStateType;
-} ? TParentStateType : never;
+/** @public Referenced by emitted declarations of strict transition targets. */
+export type SetupStateSchemasWithParentType<TStateSchemas extends Record<string, SetupStateSchema>, TParentStateType extends SetupStateType | never> = TStateSchemas & SetupStateParentTypeMarker<TParentStateType>;
+type SetupStateParentType<TStateSchemas extends Record<string, SetupStateSchema>> = TStateSchemas extends SetupStateParentTypeMarker<infer TParentStateType> ? TParentStateType : never;
 type IsParallelSetupStateParent<TStateSchemas extends Record<string, SetupStateSchema>> = [SetupStateParentType<TStateSchemas>] extends [never] ? false : SetupStateParentType<TStateSchemas> extends 'parallel' ? true : false;
 type ResolveStateSiblingsForPath<TStates extends Record<string, SetupStateSchema>, TPath extends string> = SetupStateParentAtPath<TStates, TPath> extends infer TParent ? [TParent] extends [SetupStateSchema] ? SetupStateSchemasWithParentType<ResolveStateSiblings<TStates, TPath>, TParent extends {
     type: infer TType extends SetupStateType;
 } ? TType : never> : ResolveStateSiblings<TStates, TPath> : never;
-type WithRootSetupStateSchemas<TStateSchemas extends Record<string, SetupStateSchema>, TRootStateSchemas extends Record<string, SetupStateSchema>> = TStateSchemas & {
+/** @public Referenced by emitted declarations of strict transition targets. */
+export type RootSetupStateSchemasMarker<TRootStateSchemas extends Record<string, SetupStateSchema>> = {
     readonly [rootSetupStateSchemas]: TRootStateSchemas;
 };
+/** @public Referenced by emitted declarations of strict transition targets. */
+export type WithRootSetupStateSchemas<TStateSchemas extends Record<string, SetupStateSchema>, TRootStateSchemas extends Record<string, SetupStateSchema>> = TStateSchemas & RootSetupStateSchemasMarker<TRootStateSchemas>;
 type RootSetupStateTransitionSchemas<TStateSchemas extends Record<string, SetupStateSchema>> = StrictSetupStateSchemas<{}, TStateSchemas, TStateSchemas>;
 type RootSetupStateTarget<TStateSchemas extends Record<string, SetupStateSchema>> = SetupRelativeStateTarget<TStateSchemas> | RootSetupStateIdTarget<TStateSchemas>;
 type SetupStateTransitionChildSchemas<TStateSchema extends SetupStateSchema> = TStateSchema extends {
@@ -445,12 +420,35 @@ type SetupOutput<TSchemas, TOutputSchema extends StandardSchemaV1> = [
 type HasOutputSchema<TSchemas, TOutputSchema extends StandardSchemaV1> = [
     SetupSchema<TSchemas, 'output'>
 ] extends [never] ? StandardSchemaV1 extends TOutputSchema ? false : true : true;
+/**
+ * Whether a state is final, per the authored config or the setup-declared
+ * state contract.
+ */
+type IsFinalState<TStateConfig, TStateSchema> = TStateConfig extends {
+    type: 'final';
+} ? true : TStateSchema extends {
+    type: 'final';
+} ? true : false;
+/**
+ * The union of output types across the config's top-level final states, or
+ * `never` when it has none. A setup-declared per-state `schemas.output` wins
+ * over the state's inline `schemas.output`, which wins over the state's
+ * `output` mapper; a final state with none of these contributes `undefined`.
+ */
+type SetupTopLevelFinalOutput<TConfig, TStates extends Record<string, SetupStateSchema>> = TConfig extends {
+    states: infer TConfigStates;
+} ? {
+    [K in keyof TConfigStates]: IsFinalState<TConfigStates[K], K extends keyof TStates ? TStates[K] : never> extends true ? K extends keyof TStates ? StateOutput<TStates[K], FinalStateConfigOutput<TConfigStates[K]>> : FinalStateConfigOutput<TConfigStates[K]> : never;
+}[keyof TConfigStates] : never;
 /**
  * The machine's output type. A declared output schema wins; otherwise the type
  * is inferred from the config's `output` property (a mapper's return type, or
- * the static value's type).
+ * the static value's type), falling back to the union of top-level
+ * final-state output types.
  */
-type SetupOrConfigOutput<TSchemas, TOutputSchema extends StandardSchemaV1, TConfig> = HasOutputSchema<TSchemas, TOutputSchema> extends true ? SetupOutput<TSchemas, TOutputSchema> : OutputFromConfig<TConfig, SetupOutput<TSchemas, TOutputSchema>>;
+type SetupOrConfigOutput<TSchemas, TOutputSchema extends StandardSchemaV1, TConfig, TStates extends Record<string, SetupStateSchema>> = HasOutputSchema<TSchemas, TOutputSchema> extends true ? SetupOutput<TSchemas, TOutputSchema> : OutputFromConfig<TConfig, [
+    SetupTopLevelFinalOutput<TConfig, TStates>
+] extends [never] ? SetupOutput<TSchemas, TOutputSchema> : SetupTopLevelFinalOutput<TConfig, TStates>>;
 type SetupEmitted<TSchemas, TEmittedSchemaMap extends Record<string, StandardSchemaV1>> = [SetupSchemaMap<TSchemas, 'emitted'>] extends [never] ? WithDefault<InferEvents<TEmittedSchemaMap>, AnyEventObject> : WithDefault<InferEvents<SetupSchemaMap<TSchemas, 'emitted'>>, AnyEventObject>;
 type SetupMeta<TSchemas, TMetaSchema extends StandardSchemaV1> = [
     SetupSchema<TSchemas, 'meta'>
@@ -515,7 +513,8 @@ type RootContext<TContext> = typeof rootContext extends keyof TContext ? TContex
 type StateContextShape<TStateSchema extends SetupStateSchema, TFallbackContext> = TStateSchema['schemas'] extends {
     context: infer TContextSchema;
 } ? TContextSchema extends StandardSchemaV1 ? StandardSchemaV1.InferOutput<TContextSchema> & RootContext<TFallbackContext> & RootContextMarker<TFallbackContext> : RootContext<TFallbackContext> : RootContext<TFallbackContext>;
-type ActiveStateContext<TStateSchema extends SetupStateSchema, TRootContext extends MachineContext, TAncestorContext> = StateContext<TStateSchema, TRootContext> & TAncestorContext & MachineContext;
+/** @public Referenced by emitted declarations of narrowed state contexts. */
+export type ActiveStateContext<TStateSchema extends SetupStateSchema, TRootContext extends MachineContext, TAncestorContext> = StateContext<TStateSchema, TRootContext> & TAncestorContext & MachineContext;
 type ActiveStateContextShape<TStateSchema extends SetupStateSchema, TAncestorContext> = StateContextShape<TStateSchema, TAncestorContext> & TAncestorContext;
 type WithNestedStates<TConfig, TNestedStates> = TConfig extends {
     type: 'choice';
@@ -547,9 +546,7 @@ type SetupChoiceTargetConfig<TStateSchemas extends Record<string, SetupStateSche
     [K in KnownSetupStateTarget<TStateSchemas>]: {
         target: K;
     } & SetupStateInputConfig<SetupStateSchemaAtTarget<TStateSchemas, K>, TContext, TEvent>;
-}[KnownSetupStateTarget<TStateSchemas>] | (TStateSchemas extends {
-    readonly [strictSetupStateTargets]: true;
-} ? {
+}[KnownSetupStateTarget<TStateSchemas>] | (TStateSchemas extends StrictSetupStateTargetsFlag ? {
     target: KnownSetupStateTarget<TStateSchemas>[];
     input?: Record<string, unknown>;
 } : {
@@ -980,9 +977,7 @@ type StateTransitionResult<TStateSchemas extends Record<string, SetupStateSchema
         context: StateTransitionContext<TAllowContextMapper, TContext, TContextShape, StateContextShape<SetupStateSchemaAtTarget<TStateSchemas, K>, TContextShape>, StateContext<SetupStateSchemaAtTarget<TStateSchemas, K>, TContext>, TExpressionEvent, TChildren, TActionMap, TActorMap, TGuardMap, TDelayMap, TSystemRegistry>;
     });
 }[TKnownTarget] | {
-    target: TStateSchemas extends {
-        readonly [strictSetupStateTargets]: true;
-    } ? never : Exclude<TTarget, TKnownTarget>;
+    target: TStateSchemas extends StrictSetupStateTargetsFlag ? never : Exclude<TTarget, TKnownTarget>;
     context?: StateTransitionContext<TAllowContextMapper, TContext, TContextShape, TContextShape, TContext, TExpressionEvent, TChildren, TActionMap, TActorMap, TGuardMap, TDelayMap, TSystemRegistry>;
     reenter?: boolean;
     meta?: TMeta;
@@ -1047,7 +1042,7 @@ export interface SetupReturn<TStates extends Record<string, SetupStateSchema> =
         to: RoutableStateId<SetupMachineStateSchema<TConfig, TStates>>;
     }), Cast<MergeChildren<SetupChildren<TSchemas, TChildrenSchemaMap>, TActor>, Record<string, AnyActorRef | undefined>>, StateValueFromStateSchema<SetupMachineStateSchema<TConfig, TStates>>, TTag & string, [
         SetupSchema<TSchemas, 'input'>
-    ] extends [never] ? TInput : SetupInput<TSchemas, TInputSchema>, SetupOrConfigOutput<TSchemas, TOutputSchema, TConfig>, SetupEmitted<TSchemas, TEmittedSchemaMap>, SetupMeta<TSchemas, TMetaSchema>, SetupMachineStateSchema<TConfig, TStates>, 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>;
+    ] extends [never] ? TInput : SetupInput<TSchemas, TInputSchema>, SetupOrConfigOutput<TSchemas, TOutputSchema, TConfig, TStates>, SetupEmitted<TSchemas, TEmittedSchemaMap>, SetupMeta<TSchemas, TMetaSchema>, SetupMachineStateSchema<TConfig, TStates>, 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>;
     /**
      * Creates a state node config bound to a specific setup-declared state,
      * addressed by a dotted path (e.g. `'loading'` or `'parent.child'`). The

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

@@ -9,6 +9,8 @@ import type { ActorSystemRuntime, AnyActorSystem, Clock, DeadLetterDetail, Event
 import { Sources, Next_StateNodeConfig } from "./types.v6.js";
 import { StandardSchemaV1 } from "./schema.types.js";
 import { builtInActions } from "./actions.js";
+import type { EventObject, MachineContext, Values } from "./base.types.js";
+export type { EventObject, MachineContext, Values };
 export type Identity<T> = {
     [K in keyof T]: T[K];
 };
@@ -47,7 +49,6 @@ export type Compute<A> = {
     [K in keyof A]: A[K];
 } & unknown;
 export type Prop<T, K> = K extends keyof T ? T[K] : never;
-export type Values<T> = T[keyof T];
 export type Elements<T> = T[keyof T & `${number}`];
 export type Merge<M, N> = Omit<M, keyof N> & N;
 export type IndexByProp<T extends Record<P, string>, P extends keyof T> = {
@@ -67,11 +68,6 @@ export type LowInfer<T> = T & NonNullable<unknown>;
 export type MetaObject = Record<string, any>;
 export type Lazy<T> = () => T;
 export type MaybeLazy<T> = T | Lazy<T>;
-/** The full definition of an event, with a string `type`. */
-export type EventObject = {
-    /** The type of event that is sent. */
-    type: string;
-};
 export type EventPayloadPattern<TEvent extends EventObject> = TEvent extends any ? Partial<Omit<TEvent, 'type'>> : never;
 export interface AnyEventObject extends EventObject {
     [key: string]: any;
@@ -88,7 +84,6 @@ export type UnifiedArg<TContext extends MachineContext, TExpressionEvent extends
     TODO>, TEvent, AnyEventObject>;
     system: AnyActorSystem;
 } & OutputArg<TExpressionEvent>;
-export type MachineContext = Record<string, any>;
 type DoneEventType = 'xstate.done.actor' | 'xstate.done.state';
 export type OutputArg<TEvent extends EventObject> = TEvent extends {
     type: DoneEventType;
@@ -1384,4 +1379,3 @@ export type AnyAction = Action<MachineContext, EventObject, EventObject, Sources
     action: (...args: any[]) => any;
     args: any[];
 } | AnyEventObject;
-export {};

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

@@ -1,4 +1,6 @@
-import { SetupStateSchemas, StandardSchemaV1, TypeSchema } from "./schema.types.js";
+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, ActorRefFromLogic, ActorSelf, AnyActorLogic, AnyActorRef, Compute, DoneActorEvent, DoNotInfer, ErrorFrom, ErrorActorEvent, EnqueueObject, 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";
@@ -14,48 +16,40 @@ export type OutputFromConfig<TConfig, TFallback> = TConfig extends {
     output: infer TOutput;
 } ? TOutput extends (...args: never[]) => infer TResult ? TResult : TOutput : TFallback;
 /**
- * The machine's output type when no output schema is declared in `setup()`: a
- * declared `schemas.output` is authoritative, otherwise the output type is
- * inferred from the config's `output` property.
+ * The output type contributed by a single top-level final state: its
+ * `schemas.output` if declared, otherwise its `output` mapper's return type
+ * (or static value), otherwise `undefined` (a final state with no `output`
+ * completes the machine with `undefined` output).
  */
-export type SchemaOrConfigOutput<TOutputSchema extends StandardSchemaV1, TConfig> = StandardSchemaV1 extends TOutputSchema ? OutputFromConfig<TConfig, InferOutput<TOutputSchema, unknown>> : InferOutput<TOutputSchema, unknown>;
+export type FinalStateConfigOutput<TStateConfig> = TStateConfig extends {
+    schemas: {
+        output: infer TOutputSchema extends StandardSchemaV1;
+    };
+} ? StandardSchemaV1.InferOutput<TOutputSchema> : OutputFromConfig<TStateConfig, undefined>;
 /**
- * Event payloads from schemas (e.g. Zod) are often inferred as optional in
- * output types. Wrapping in Required<> ensures properties defined in the schema
- * are required on the event. Type-only schemas created with the `types()`
- * helper are exempt: their declared type is authoritative, so optional
- * properties stay optional.
+ * The union of output types across the config's top-level final states, or
+ * `never` when it has none. Reaching a top-level final state completes the
+ * machine with that state's output when no root `output` mapper is declared.
  */
-export type InferEvents<TEventSchemaMap extends Record<string, StandardSchemaV1>> = Values<{
-    [K in keyof TEventSchemaMap & string]: StandardSchemaV1.InferOutput<TEventSchemaMap[K]> extends infer O ? [O] extends [never] ? never : unknown extends O ? O & {
-        type: K;
-    } : [O] extends [void] ? {
-        type: K;
-    } : string extends keyof O ? [O[string]] extends [never] ? {
-        type: EventTypeFromSchemaKey<K>;
-    } : NormalizeEventPayload<TEventSchemaMap[K], O> & {
-        type: EventTypeFromSchemaKey<K>;
-    } : NormalizeEventPayload<TEventSchemaMap[K], O> & {
-        type: EventTypeFromSchemaKey<K>;
-    } : never;
-}>;
-/** Infers internal events only from explicitly declared schema keys. */
-export type InferInternalEvents<TEventSchemaMap extends Record<string, StandardSchemaV1>> = string extends keyof TEventSchemaMap ? never : InferEvents<TEventSchemaMap>;
-type EventTypeFromSchemaKey<TKey extends string> = TKey extends '*' ? string : TKey extends `${infer TLeading}.*` ? `${TLeading}.${string}` : TKey;
+type TopLevelFinalOutput<TConfig> = TConfig extends {
+    states: infer TStates;
+} ? {
+    [K in keyof TStates]: TStates[K] extends {
+        type: 'final';
+    } ? FinalStateConfigOutput<TStates[K]> : never;
+}[keyof TStates] : never;
 /**
- * Keeps a type-only schema's payload verbatim; applies Required<> to payloads
- * from validator libraries (see {@link InferEvents}).
+ * The machine's output type when no output schema is declared in `setup()`: a
+ * declared `schemas.output` is authoritative, otherwise the output type is
+ * inferred from the config's `output` property, falling back to the union of
+ * top-level final-state output types.
  */
-type NormalizeEventPayload<TSchema extends StandardSchemaV1, O> = TSchema extends TypeSchema<any> ? O : Required<O>;
+export type SchemaOrConfigOutput<TOutputSchema extends StandardSchemaV1, TConfig> = StandardSchemaV1 extends TOutputSchema ? OutputFromConfig<TConfig, [
+    TopLevelFinalOutput<TConfig>
+] extends [never] ? InferOutput<TOutputSchema, unknown> : TopLevelFinalOutput<TConfig>> : InferOutput<TOutputSchema, unknown>;
 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;
 };
-export type ActionSchemas = Record<string, {
-    params: StandardSchemaV1;
-}>;
-export type GuardSchemas = Record<string, {
-    params: StandardSchemaV1;
-}>;
 export type InferActions<TActionSchemaMap extends ActionSchemas> = string extends keyof TActionSchemaMap ? {} : {
     [K in keyof TActionSchemaMap & string]: (params: StandardSchemaV1.InferOutput<TActionSchemaMap[K]['params']>) => void | {
         context?: any;
@@ -319,7 +313,8 @@ type Next_RouteConfig<TContext extends MachineContext, TEvent extends EventObjec
 });
 type Next_ChoiceConfigFunction<TContext extends MachineContext, TCurrentEvent extends EventObject, TEvent extends EventObject, TActionMap extends Sources['actions'], TActorMap extends Sources['actors'], TGuardMap extends Sources['guards'], TDelayMap extends Sources['delays'], TMeta extends MetaObject, _TCtx extends MachineContext = [TContext] extends [never] ? any : TContext> = (args: Next_ChoiceArgs<TContext, TCurrentEvent, TEvent, TActionMap, TActorMap, TGuardMap, TDelayMap, _TCtx>) => Next_ChoiceTarget<TMeta>;
 export type Next_StateNodeConfig<TContext extends MachineContext, TEvent extends EventObject, TDelays extends string, TTag extends string, _TOutput, TEmitted extends EventObject, TStateMeta 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, TTransitionMeta extends MetaObject = TStateMeta> = Next_RegularStateNodeConfig<TContext, TEvent, TDelays, TTag, _TOutput, TEmitted, TStateMeta, TTransitionMeta, TChildren, TActionMap, TActorMap, TGuardMap, TDelayMap, TInput, TInputMap, TSystemRegistry, TChildOutput> | Next_ChoiceStateNodeConfig<TContext, TEvent, TTag, TStateMeta, TTransitionMeta, TActionMap, TActorMap, TGuardMap, TDelayMap>;
-interface Next_ChoiceStateNodeConfig<TContext extends MachineContext, TEvent extends EventObject, TTag extends string, TStateMeta extends MetaObject, TTransitionMeta extends MetaObject, TActionMap extends Sources['actions'], TActorMap extends Sources['actors'], TGuardMap extends Sources['guards'], TDelayMap extends Sources['delays']> {
+/** @public Referenced by emitted declarations of `Next_StateNodeConfig`. */
+export interface Next_ChoiceStateNodeConfig<TContext extends MachineContext, TEvent extends EventObject, TTag extends string, TStateMeta extends MetaObject, TTransitionMeta extends MetaObject, TActionMap extends Sources['actions'], TActorMap extends Sources['actors'], TGuardMap extends Sources['guards'], TDelayMap extends Sources['delays']> {
     contextSchema?: StandardSchemaV1;
     schemas?: SetupStateSchemas;
     type: 'choice';
@@ -347,7 +342,8 @@ interface Next_ChoiceStateNodeConfig<TContext extends MachineContext, TEvent ext
     output?: never;
     target?: never;
 }
-interface Next_RegularStateNodeConfig<TContext extends MachineContext, TEvent extends EventObject, TDelays extends string, TTag extends string, TOutput, TEmitted extends EventObject, TStateMeta extends MetaObject, TTransitionMeta 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> {
+/** @public Referenced by emitted declarations of `Next_StateNodeConfig`. */
+export interface Next_RegularStateNodeConfig<TContext extends MachineContext, TEvent extends EventObject, TDelays extends string, TTag extends string, TOutput, TEmitted extends EventObject, TStateMeta extends MetaObject, TTransitionMeta 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. */
@@ -707,4 +703,3 @@ export type ValidateStateTargets<TConfig> = 0 extends 1 & TConfig ? unknown : TC
 } ? (TInitial extends {
     target: infer TInitialTarget;
 } ? TInitialTarget : TInitial) extends infer TInitialTarget ? InvalidInitialTarget<TConfig, TStates, TInitialTarget> : never : never) | InvalidNodeTargets<TConfig, TConfig, []> | InvalidTargetsInStates<TConfig, TStates> extends never ? unknown : never : unknown;
-export {};

package/dist/{types-69f39448.esm.js → types-1378f0fa.esm.js}

@@ -1327,8 +1327,6 @@ function createStateConfig(config) {
 
 /** @deprecated Use the built-in `NoInfer` type instead */
 
-/** The full definition of an event, with a string `type`. */
-
 /**
  * The string or object representing the state value relative to the parent
  * state node.

package/dist/{types-802dc45c.cjs.js → types-91238aab.cjs.js}

@@ -1329,8 +1329,6 @@ function createStateConfig(config) {
 
 /** @deprecated Use the built-in `NoInfer` type instead */
 
-/** The full definition of an event, with a string `type`. */
-
 /**
  * The string or object representing the state value relative to the parent
  * state node.

package/dist/{types-ec6c763a.development.cjs.js → types-939a97c6.development.cjs.js}

@@ -1361,8 +1361,6 @@ function createStateConfig(config) {
 
 /** @deprecated Use the built-in `NoInfer` type instead */
 
-/** The full definition of an event, with a string `type`. */
-
 /**
  * The string or object representing the state value relative to the parent
  * state node.

package/dist/{types-33de9b3d.development.esm.js → types-94ac7819.development.esm.js}

@@ -1359,8 +1359,6 @@ function createStateConfig(config) {
 
 /** @deprecated Use the built-in `NoInfer` type instead */
 
-/** The full definition of an event, with a string `type`. */
-
 /**
  * The string or object representing the state value relative to the parent
  * state node.