xstate 5.0.0-beta.43 → 5.0.0-beta.45

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

@@ -5,13 +5,62 @@ export type TransitionSnapshot<TContext> = Snapshot<undefined> & {
 export type TransitionActorLogic<TContext, TEvent extends EventObject, TInput> = ActorLogic<TransitionSnapshot<TContext>, TEvent, TInput, AnyActorSystem>;
 export type TransitionActorRef<TContext, TEvent extends EventObject> = ActorRefFrom<TransitionActorLogic<TransitionSnapshot<TContext>, TEvent, unknown>>;
 /**
- * Returns actor logic from a transition function and its initial state.
+ * Returns actor logic given a transition function and its initial state.
  *
- * A transition function is a function that takes the current state and an event and returns the next state.
+ * A “transition function” is a function that takes the current `state` and received `event` object as arguments, and returns the next state, similar to a reducer.
  *
- * @param transition The transition function that returns the next state given the current state and event.
- * @param initialContext The initial state of the transition function.
+ * Actors created from transition logic (“transition actors”) can:
+ *
+ * - Receive events
+ * - Emit snapshots of its state
+ *
+ * The transition function’s `state` is used as its transition actor’s `context`.
+ *
+ * Note that the "state" for a transition function is provided by the initial state argument, and is not the same as the State object of an actor or a state within a machine configuration.
+ *
+ * @param transition The transition function used to describe the transition logic. It should return the next state given the current state and event. It receives the following arguments:
+ * - `state` - the current state.
+ * - `event` - the received event.
+ * - `actorScope` - the actor scope object, with properties like `self` and `system`.
+ * @param initialContext The initial state of the transition function, either an object representing the state, or a function which returns a state object. If a function, it will receive as its only argument an object with the following properties:
+ * - `input` - the `input` provided to its parent transition actor.
+ * - `self` - a reference to its parent transition actor.
+ * @see {@link https://stately.ai/docs/input | Input docs} for more information about how input is passed
  * @returns Actor logic
+ *
+ * @example
+ * ```ts
+ * const transitionLogic = fromTransition(
+ *   (state, event) => {
+ *     if (event.type === 'increment') {
+ *       return {
+ *         ...state,
+ *         count: state.count + 1,
+ *       };
+ *     }
+ *     return state;
+ *   },
+ *   { count: 0 },
+ * );
+ *
+ * const transitionActor = createActor(transitionLogic);
+ * transitionActor.subscribe((snapshot) => {
+ *   console.log(snapshot);
+ * });
+ * transitionActor.start();
+ * // => {
+ * //   status: 'active',
+ * //   context: { count: 0 },
+ * //   ...
+ * // }
+ *
+ * transitionActor.send({ type: 'increment' });
+ * // => {
+ * //   status: 'active',
+ * //   context: { count: 1 },
+ * //   ...
+ * // }
+ * ```
  */
 export declare function fromTransition<TContext, TEvent extends EventObject, TSystem extends ActorSystem<any>, TInput>(transition: (state: TContext, event: TEvent, actorScope: ActorScope<TransitionSnapshot<TContext>, TEvent, TSystem>) => TContext, initialContext: TContext | (({ input, self }: {
     input: TInput;

package/dist/declarations/src/{Machine.d.ts → createMachine.d.ts}

@@ -2,4 +2,4 @@ import { MachineConfig, MachineContext, InternalMachineImplementations, Paramete
 import { TypegenConstraint, ResolveTypegenMeta, TypegenDisabled } from "./typegenTypes.js";
 import { StateMachine } from "./StateMachine.js";
 export declare function createMachine<TContext extends MachineContext, TEvent extends AnyEventObject, // TODO: consider using a stricter `EventObject` here
-TActor extends ProvidedActor, TAction extends ParameterizedObject, TGuard extends ParameterizedObject, TDelay extends string, TTag extends string, TInput, TOutput extends NonReducibleUnknown, TTypesMeta extends TypegenConstraint = TypegenDisabled>(config: MachineConfig<TContext, TEvent, TActor, TAction, TGuard, TDelay, TTag, TInput, TOutput, TTypesMeta>, implementations?: InternalMachineImplementations<TContext, TEvent, TActor, TAction, TDelay, ResolveTypegenMeta<TTypesMeta, TEvent, TActor, TAction, TGuard, TDelay, TTag>>): StateMachine<TContext, TEvent, TActor, TAction, TGuard, TDelay, Prop<ResolveTypegenMeta<TTypesMeta, TEvent, TActor, TAction, TGuard, TDelay, TTag>['resolved'], 'tags'> & string, TInput, TOutput, ResolveTypegenMeta<TTypesMeta, TEvent, TActor, TAction, TGuard, TDelay, TTag>>;
+TActor extends ProvidedActor, TAction extends ParameterizedObject, TGuard extends ParameterizedObject, TDelay extends string, TTag extends string, TInput, TOutput extends NonReducibleUnknown, TTypesMeta extends TypegenConstraint = TypegenDisabled>(config: MachineConfig<TContext, TEvent, TActor, TAction, TGuard, TDelay, TTag, TInput, TOutput, TTypesMeta>, implementations?: InternalMachineImplementations<TContext, ResolveTypegenMeta<TTypesMeta, TEvent, TActor, TAction, TGuard, TDelay, TTag>>): StateMachine<TContext, TEvent, TActor, TAction, TGuard, TDelay, Prop<ResolveTypegenMeta<TTypesMeta, TEvent, TActor, TAction, TGuard, TDelay, TTag>['resolved'], 'tags'> & string, TInput, TOutput, ResolveTypegenMeta<TTypesMeta, TEvent, TActor, TAction, TGuard, TDelay, TTag>>;

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

@@ -1,4 +1,18 @@
-import type { EventObject, StateValue, MachineContext, ParameterizedObject, AnyState, NoRequiredParams, NoInfer, WithDynamicParams } from "./types.js";
+import type { EventObject, StateValue, MachineContext, ParameterizedObject, AnyMachineSnapshot, NoRequiredParams, NoInfer, WithDynamicParams, Identity, Elements } from "./types.js";
+type SingleGuardArg<TContext extends MachineContext, TExpressionEvent extends EventObject, TParams extends ParameterizedObject['params'] | undefined, TGuardArg> = [TGuardArg] extends [{
+    type: string;
+}] ? Identity<TGuardArg> : [TGuardArg] extends [string] ? TGuardArg : GuardPredicate<TContext, TExpressionEvent, TParams, ParameterizedObject>;
+type NormalizeGuardArg<TGuardArg> = TGuardArg extends {
+    type: string;
+} ? Identity<TGuardArg> & {
+    params: unknown;
+} : TGuardArg extends string ? {
+    type: TGuardArg;
+    params: undefined;
+} : '_out_TGuard' extends keyof TGuardArg ? TGuardArg['_out_TGuard'] & ParameterizedObject : never;
+type NormalizeGuardArgArray<TArg extends unknown[]> = Elements<{
+    [K in keyof TArg]: NormalizeGuardArg<TArg[K]>;
+}>;
 export type GuardPredicate<TContext extends MachineContext, TExpressionEvent extends EventObject, TParams extends ParameterizedObject['params'] | undefined, TGuard extends ParameterizedObject> = {
     (args: GuardArgs<TContext, TExpressionEvent>, params: TParams): boolean;
     _out_TGuard?: TGuard;
@@ -12,8 +26,16 @@ export type UnknownGuard = UnknownReferencedGuard | UnknownInlineGuard;
 type UnknownReferencedGuard = Guard<MachineContext, EventObject, ParameterizedObject['params'], ParameterizedObject>;
 type UnknownInlineGuard = Guard<MachineContext, EventObject, undefined, ParameterizedObject>;
 export declare function stateIn<TContext extends MachineContext, TExpressionEvent extends EventObject, TParams extends ParameterizedObject['params'] | undefined>(stateValue: StateValue): GuardPredicate<TContext, TExpressionEvent, TParams, any>;
-export declare function not<TContext extends MachineContext, TExpressionEvent extends EventObject, TParams extends ParameterizedObject['params'] | undefined, TGuard extends ParameterizedObject>(guard: Guard<TContext, TExpressionEvent, TParams, NoInfer<TGuard>>): GuardPredicate<TContext, TExpressionEvent, TParams, TGuard>;
-export declare function and<TContext extends MachineContext, TExpressionEvent extends EventObject, TParams extends ParameterizedObject['params'] | undefined, TGuard extends ParameterizedObject>(guards: ReadonlyArray<Guard<TContext, TExpressionEvent, TParams, NoInfer<TGuard>>>): GuardPredicate<TContext, TExpressionEvent, TParams, TGuard>;
-export declare function or<TContext extends MachineContext, TExpressionEvent extends EventObject, TParams extends ParameterizedObject['params'] | undefined, TGuard extends ParameterizedObject>(guards: ReadonlyArray<Guard<TContext, TExpressionEvent, TParams, NoInfer<TGuard>>>): GuardPredicate<TContext, TExpressionEvent, TParams, TGuard>;
-export declare function evaluateGuard<TContext extends MachineContext, TExpressionEvent extends EventObject>(guard: UnknownGuard | UnknownInlineGuard, context: TContext, event: TExpressionEvent, state: AnyState): boolean;
+export declare function not<TContext extends MachineContext, TExpressionEvent extends EventObject, TArg>(guard: SingleGuardArg<TContext, TExpressionEvent, unknown, TArg>): GuardPredicate<TContext, TExpressionEvent, unknown, NormalizeGuardArg<NoInfer<TArg>>>;
+export declare function and<TContext extends MachineContext, TExpressionEvent extends EventObject, TArg extends unknown[]>(guards: readonly [
+    ...{
+        [K in keyof TArg]: SingleGuardArg<TContext, TExpressionEvent, unknown, TArg[K]>;
+    }
+]): GuardPredicate<TContext, TExpressionEvent, unknown, NormalizeGuardArgArray<NoInfer<TArg>>>;
+export declare function or<TContext extends MachineContext, TExpressionEvent extends EventObject, TArg extends unknown[]>(guards: readonly [
+    ...{
+        [K in keyof TArg]: SingleGuardArg<TContext, TExpressionEvent, unknown, TArg[K]>;
+    }
+]): GuardPredicate<TContext, TExpressionEvent, unknown, NormalizeGuardArgArray<NoInfer<TArg>>>;
+export declare function evaluateGuard<TContext extends MachineContext, TExpressionEvent extends EventObject>(guard: UnknownGuard | UnknownInlineGuard, context: TContext, event: TExpressionEvent, state: AnyMachineSnapshot): boolean;
 export {};

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

@@ -8,13 +8,14 @@ export * from "./typegenTypes.js";
 export * from "./types.js";
 export { waitFor } from "./waitFor.js";
 import { Actor, createActor, interpret, Interpreter } from "./interpreter.js";
-import { createMachine } from "./Machine.js";
-export { type MachineSnapshot } from "./State.js";
+import { createMachine } from "./createMachine.js";
+export { type MachineSnapshot, isMachineSnapshot } from "./State.js";
 import { StateNode } from "./StateNode.js";
 export { matchesState, pathToStateValue, toObserver } from "./utils.js";
 export { Actor, createActor, createMachine, interpret, StateNode, type Interpreter };
 export type { InspectedActorEvent, InspectedEventEvent, InspectedSnapshotEvent, InspectionEvent } from "./system.js";
 export { and, not, or, stateIn } from "./guards.js";
+export { setup } from "./setup.js";
 declare global {
     interface SymbolConstructor {
         readonly observable: symbol;

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

@@ -39,6 +39,7 @@ export declare class Actor<TLogic extends AnyActorLogic> implements ActorRef<Eve
     private observers;
     private logger;
     _parent?: ActorRef<any, any>;
+    _syncSnapshot?: boolean;
     ref: ActorRef<EventFromLogic<TLogic>, SnapshotFrom<TLogic>>;
     private _actorScope;
     private _systemId;

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

@@ -0,0 +1,32 @@
+import { ResolveTypegenMeta, StateMachine, TypegenDisabled } from "./index.js";
+import { GuardPredicate } from "./guards.js";
+import { AnyActorLogic, MachineContext, AnyEventObject, NonReducibleUnknown, MachineConfig, Values, ParameterizedObject, ActionFunction, SetupTypes, DelayConfig } from "./types.js";
+type ToParameterizedObject<TParameterizedMap extends Record<string, ParameterizedObject['params'] | undefined>> = Values<{
+    [K in keyof TParameterizedMap & string]: {
+        type: K;
+        params: TParameterizedMap[K];
+    };
+}>;
+type ToProvidedActor<TActors extends Record<string, AnyActorLogic>> = Values<{
+    [K in keyof TActors & string]: {
+        src: K;
+        logic: TActors[K];
+    };
+}>;
+export declare function setup<TContext extends MachineContext, TEvent extends AnyEventObject, // TODO: consider using a stricter `EventObject` here
+TActors extends Record<string, AnyActorLogic>, TActions extends Record<string, ParameterizedObject['params'] | undefined>, TGuards extends Record<string, ParameterizedObject['params'] | undefined>, TDelay extends string, TTag extends string, TInput, TOutput extends NonReducibleUnknown>({ actors, actions, guards, delays }: {
+    types?: SetupTypes<TContext, TEvent, TTag, TInput, TOutput>;
+    actors?: TActors;
+    actions?: {
+        [K in keyof TActions]: ActionFunction<TContext, TEvent, TEvent, TActions[K], ToProvidedActor<TActors>, ToParameterizedObject<TActions>, ToParameterizedObject<TGuards>, TDelay>;
+    };
+    guards?: {
+        [K in keyof TGuards]: GuardPredicate<TContext, TEvent, TGuards[K], ToParameterizedObject<TGuards>>;
+    };
+    delays?: {
+        [K in TDelay]: DelayConfig<TContext, TEvent, ToParameterizedObject<TActions>['params'], TEvent>;
+    };
+}): {
+    createMachine: (config: MachineConfig<TContext, TEvent, ToProvidedActor<TActors>, ToParameterizedObject<TActions>, ToParameterizedObject<TGuards>, TDelay, TTag, TInput, TOutput, ResolveTypegenMeta<TypegenDisabled, TEvent, ToProvidedActor<TActors>, ToParameterizedObject<TActions>, ToParameterizedObject<TGuards>, TDelay, TTag>>) => StateMachine<TContext, TEvent, ToProvidedActor<TActors>, ToParameterizedObject<TActions>, ToParameterizedObject<TGuards>, TDelay, TTag, TInput, TOutput, ResolveTypegenMeta<TypegenDisabled, TEvent, ToProvidedActor<TActors>, ToParameterizedObject<TActions>, ToParameterizedObject<TGuards>, TDelay, TTag>>;
+};
+export {};

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

@@ -1,21 +1,16 @@
-import { ActorRefFrom, AnyActorScope, AnyActorLogic, AnyActorRef, AnyEventObject, AnyState, InputFrom, IsLiteralString, ProvidedActor } from "./types.js";
-export type SpawnOptions<TActor extends ProvidedActor, TSrc extends TActor['src']> = TActor extends {
+import { ActorRefFrom, AnyActorScope, AnyActorLogic, AnyActorRef, AnyEventObject, AnyMachineSnapshot, InputFrom, IsLiteralString, ProvidedActor, RequiredActorOptions, IsNotNever, ConditionalRequired } from "./types.js";
+type SpawnOptions<TActor extends ProvidedActor, TSrc extends TActor['src']> = TActor extends {
     src: TSrc;
-} ? 'id' extends keyof TActor ? [
-    options: {
-        id: TActor['id'];
-        systemId?: string;
-        input?: InputFrom<TActor['logic']>;
-        syncSnapshot?: boolean;
-    }
-] : [
+} ? ConditionalRequired<[
     options?: {
-        id?: string;
+        id?: TActor['id'];
         systemId?: string;
         input?: InputFrom<TActor['logic']>;
         syncSnapshot?: boolean;
+    } & {
+        [K in RequiredActorOptions<TActor>]: unknown;
     }
-] : never;
+], IsNotNever<RequiredActorOptions<TActor>>> : never;
 export type Spawner<TActor extends ProvidedActor> = IsLiteralString<TActor['src']> extends true ? <TSrc extends TActor['src']>(logic: TSrc, ...[options]: SpawnOptions<TActor, TSrc>) => ActorRefFrom<(TActor & {
     src: TSrc;
 })['logic']> : <TLogic extends AnyActorLogic | string>(src: TLogic, options?: {
@@ -24,4 +19,5 @@ export type Spawner<TActor extends ProvidedActor> = IsLiteralString<TActor['src'
     input?: unknown;
     syncSnapshot?: boolean;
 }) => TLogic extends string ? AnyActorRef : ActorRefFrom<TLogic>;
-export declare function createSpawner(actorScope: AnyActorScope, { machine, context }: AnyState, event: AnyEventObject, spawnedChildren: Record<string, AnyActorRef>): Spawner<any>;
+export declare function createSpawner(actorScope: AnyActorScope, { machine, context }: AnyMachineSnapshot, event: AnyEventObject, spawnedChildren: Record<string, AnyActorRef>): Spawner<any>;
+export {};

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

@@ -1,14 +1,14 @@
 import { MachineSnapshot } from "./State.js";
 import type { StateNode } from "./StateNode.js";
-import { AnyEventObject, AnyHistoryValue, AnyState, AnyStateNode, AnyTransitionDefinition, DelayedTransitionDefinition, EventObject, InitialTransitionConfig, InitialTransitionDefinition, MachineContext, StateValue, StateValueMap, TransitionDefinition, TODO, UnknownAction, AnyTransitionConfig, AnyActorScope } from "./types.js";
-type Configuration<TContext extends MachineContext, TE extends EventObject> = Iterable<StateNode<TContext, TE>>;
-type AnyConfiguration = Configuration<any, any>;
+import { AnyEventObject, AnyHistoryValue, AnyMachineSnapshot, AnyStateNode, AnyTransitionDefinition, DelayedTransitionDefinition, EventObject, InitialTransitionConfig, InitialTransitionDefinition, MachineContext, StateValue, StateValueMap, TransitionDefinition, TODO, UnknownAction, AnyTransitionConfig, AnyActorScope } from "./types.js";
+type StateNodeIterable<TContext extends MachineContext, TE extends EventObject> = Iterable<StateNode<TContext, TE>>;
+type AnyStateNodeIterable = StateNodeIterable<any, any>;
 type AdjList = Map<AnyStateNode, Array<AnyStateNode>>;
 export declare const isAtomicStateNode: (stateNode: StateNode<any, any>) => boolean;
-export declare function getConfiguration(stateNodes: Iterable<AnyStateNode>): Set<AnyStateNode>;
-export declare function getAdjList<TContext extends MachineContext, TE extends EventObject>(configuration: Configuration<TContext, TE>): AdjList;
-export declare function getStateValue(rootNode: AnyStateNode, configuration: AnyConfiguration): StateValue;
-export declare function isInFinalState(configuration: Set<AnyStateNode>, stateNode: AnyStateNode): boolean;
+export declare function getAllStateNodes(stateNodes: Iterable<AnyStateNode>): Set<AnyStateNode>;
+export declare function getAdjList<TContext extends MachineContext, TE extends EventObject>(stateNodes: StateNodeIterable<TContext, TE>): AdjList;
+export declare function getStateValue(rootNode: AnyStateNode, stateNodes: AnyStateNodeIterable): StateValue;
+export declare function isInFinalState(stateNodeSet: Set<AnyStateNode>, stateNode: AnyStateNode): boolean;
 export declare const isStateId: (str: string) => boolean;
 export declare function getCandidates<TEvent extends EventObject>(stateNode: StateNode<any, TEvent>, receivedEventType: TEvent['type']): Array<TransitionDefinition<any, TEvent>>;
 /**
@@ -41,13 +41,13 @@ export declare function transitionAtomicNode<TContext extends MachineContext, TE
 export declare function transitionCompoundNode<TContext extends MachineContext, TEvent extends EventObject>(stateNode: AnyStateNode, stateValue: StateValueMap, state: MachineSnapshot<TContext, TEvent, any, any, any, any>, event: TEvent): Array<TransitionDefinition<TContext, TEvent>> | undefined;
 export declare function transitionParallelNode<TContext extends MachineContext, TEvent extends EventObject>(stateNode: AnyStateNode, stateValue: StateValueMap, state: MachineSnapshot<TContext, TEvent, any, any, any, any>, event: TEvent): Array<TransitionDefinition<TContext, TEvent>> | undefined;
 export declare function transitionNode<TContext extends MachineContext, TEvent extends EventObject>(stateNode: AnyStateNode, stateValue: StateValue, state: MachineSnapshot<TContext, TEvent, any, any, any, any>, event: TEvent): Array<TransitionDefinition<TContext, TEvent>> | undefined;
-export declare function removeConflictingTransitions(enabledTransitions: Array<AnyTransitionDefinition>, configuration: Set<AnyStateNode>, historyValue: AnyHistoryValue): Array<AnyTransitionDefinition>;
+export declare function removeConflictingTransitions(enabledTransitions: Array<AnyTransitionDefinition>, stateNodeSet: Set<AnyStateNode>, historyValue: AnyHistoryValue): Array<AnyTransitionDefinition>;
 /**
  * https://www.w3.org/TR/scxml/#microstepProcedure
  */
-export declare function microstep<TContext extends MachineContext, TEvent extends EventObject>(transitions: Array<AnyTransitionDefinition>, currentState: AnyState, actorScope: AnyActorScope, event: AnyEventObject, isInitial: boolean, internalQueue: Array<AnyEventObject>): AnyState;
-export declare function resolveActionsAndContext(currentState: AnyState, event: AnyEventObject, actorScope: AnyActorScope, actions: UnknownAction[], internalQueue: AnyEventObject[], deferredActorIds?: string[]): AnyState;
-export declare function macrostep(state: AnyState, event: EventObject, actorScope: AnyActorScope, internalQueue?: AnyEventObject[]): {
+export declare function microstep<TContext extends MachineContext, TEvent extends EventObject>(transitions: Array<AnyTransitionDefinition>, currentState: AnyMachineSnapshot, actorScope: AnyActorScope, event: AnyEventObject, isInitial: boolean, internalQueue: Array<AnyEventObject>): AnyMachineSnapshot;
+export declare function resolveActionsAndContext(currentState: AnyMachineSnapshot, event: AnyEventObject, actorScope: AnyActorScope, actions: UnknownAction[], internalQueue: AnyEventObject[], deferredActorIds?: string[]): AnyMachineSnapshot;
+export declare function macrostep(state: AnyMachineSnapshot, event: EventObject, actorScope: AnyActorScope, internalQueue?: AnyEventObject[]): {
     state: typeof state;
     microstates: Array<typeof state>;
 };

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

@@ -8,6 +8,9 @@ import { Guard, GuardPredicate, UnknownGuard } from "./guards.js";
 import { Spawner } from "./spawn.js";
 import { AssignArgs } from "./actions/assign.js";
 import { InspectionEvent } from './system.js';
+export type Identity<T> = {
+    [K in keyof T]: T[K];
+};
 export type HomomorphicPick<T, K extends keyof any> = {
     [P in keyof T as P & K]: T[P];
 };
@@ -33,11 +36,13 @@ export type NonReducibleUnknown = {} | null | undefined;
 export type AnyFunction = (...args: any[]) => any;
 type ReturnTypeOrValue<T> = T extends AnyFunction ? ReturnType<T> : T;
 export type IsNever<T> = [T] extends [never] ? true : false;
+export type IsNotNever<T> = [T] extends [never] ? false : true;
 export type Compute<A extends any> = {
     [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> = {
     [E in T as E[P]]: E;
@@ -67,7 +72,7 @@ export interface AnyEventObject extends EventObject {
 }
 export interface ParameterizedObject {
     type: string;
-    params?: Record<string, unknown>;
+    params?: NonReducibleUnknown;
 }
 export interface UnifiedArg<TContext extends MachineContext, TExpressionEvent extends EventObject, TEvent extends EventObject> {
     context: TContext;
@@ -94,10 +99,8 @@ export interface ChooseBranch<TContext extends MachineContext, TExpressionEvent
     guard?: Guard<TContext, TExpressionEvent, undefined, TGuard>;
     actions: Actions<TContext, TExpressionEvent, TEvent, undefined, TActor, TAction, TGuard, TDelay>;
 }
-export type NoRequiredParams<T extends ParameterizedObject> = T extends any ? {
-    type: T['type'];
-} extends T ? T['type'] : never : never;
-type ConditionalRequired<T, Condition extends boolean> = Condition extends true ? Required<T> : T;
+export type NoRequiredParams<T extends ParameterizedObject> = T extends any ? undefined extends T['params'] ? T['type'] : never : never;
+export type ConditionalRequired<T, Condition extends boolean> = Condition extends true ? Required<T> : T;
 export type WithDynamicParams<TContext extends MachineContext, TExpressionEvent extends EventObject, T extends ParameterizedObject> = T extends any ? ConditionalRequired<{
     type: T['type'];
     params?: T['params'] | (({ context, event }: {
@@ -108,7 +111,7 @@ export type WithDynamicParams<TContext extends MachineContext, TExpressionEvent
 export type Action<TContext extends MachineContext, TExpressionEvent extends EventObject, TEvent extends EventObject, TParams extends ParameterizedObject['params'] | undefined, TActor extends ProvidedActor, TAction extends ParameterizedObject, TGuard extends ParameterizedObject, TDelay extends string> = NoRequiredParams<TAction> | WithDynamicParams<TContext, TExpressionEvent, TAction> | ActionFunction<TContext, TExpressionEvent, TEvent, TParams, TActor, TAction, TGuard, TDelay>;
 export type UnknownAction = Action<MachineContext, EventObject, EventObject, ParameterizedObject['params'] | undefined, ProvidedActor, ParameterizedObject, ParameterizedObject, string>;
 export type Actions<TContext extends MachineContext, TExpressionEvent extends EventObject, TEvent extends EventObject, TParams extends ParameterizedObject['params'] | undefined, TActor extends ProvidedActor, TAction extends ParameterizedObject, TGuard extends ParameterizedObject, TDelay extends string> = SingleOrArray<Action<TContext, TExpressionEvent, TEvent, TParams, TActor, TAction, TGuard, TDelay>>;
-export type StateKey = string | AnyState;
+export type StateKey = string | AnyMachineSnapshot;
 export interface StateValueMap {
     [key: string]: StateValue;
 }
@@ -186,6 +189,11 @@ type DistributeActors<TContext extends MachineContext, TEvent extends EventObjec
      * The source of the machine to be invoked, or the machine itself.
      */
     src: TSrc;
+    /**
+     * The unique identifier for the invoked machine. If not specified, this
+     * will be the machine's own `id`, or the URL (from `src`).
+     */
+    id?: TSpecificActor['id'];
     input?: Mapper<TContext, TEvent, InputFrom<TSpecificActor['logic']>, TEvent> | InputFrom<TSpecificActor['logic']>;
     /**
      * The transition to take upon the invoked child machine reaching its final top-level state.
@@ -196,19 +204,9 @@ type DistributeActors<TContext extends MachineContext, TEvent extends EventObjec
      */
     onError?: string | SingleOrArray<TransitionConfigOrTarget<TContext, ErrorActorEvent, TEvent, TActor, TAction, TGuard, TDelay>>;
     onSnapshot?: string | SingleOrArray<TransitionConfigOrTarget<TContext, SnapshotEvent<SnapshotFrom<TSpecificActor['logic']>>, TEvent, TActor, TAction, TGuard, TDelay>>;
-} & (TSpecificActor['id'] extends string ? {
-    /**
-     * The unique identifier for the invoked machine. If not specified, this
-     * will be the machine's own `id`, or the URL (from `src`).
-     */
-    id: TSpecificActor['id'];
-} : {
-    /**
-     * The unique identifier for the invoked machine. If not specified, this
-     * will be the machine's own `id`, or the URL (from `src`).
-     */
-    id?: string;
-})> : never;
+} & {
+    [K in RequiredActorOptions<TSpecificActor>]: unknown;
+}> : never;
 export type InvokeConfig<TContext extends MachineContext, TEvent extends EventObject, TActor extends ProvidedActor, TAction extends ParameterizedObject, TGuard extends ParameterizedObject, TDelay extends string> = IsLiteralString<TActor['src']> extends true ? DistributeActors<TContext, TEvent, TActor, TAction, TGuard, TDelay, TActor> : {
     /**
      * The unique identifier for the invoked machine. If not specified, this
@@ -347,7 +345,9 @@ export interface StateMachineDefinition<TContext extends MachineContext, TEvent
 }
 export type AnyStateNode = StateNode<any, any>;
 export type AnyStateNodeDefinition = StateNodeDefinition<any, any>;
-export type AnyState = MachineSnapshot<any, any, any, any, any, any>;
+export type AnyMachineSnapshot = MachineSnapshot<any, any, any, any, any, any>;
+/** @deprecated use `AnyMachineSnapshot` instead */
+export type AnyState = AnyMachineSnapshot;
 export type AnyStateMachine = StateMachine<any, any, any, any, any, any, any, any, any, // delays
 any>;
 export type AnyStateConfig = StateConfig<any, AnyEventObject>;
@@ -414,8 +414,8 @@ type GenerateDelaysImplementationsPart<TContext extends MachineContext, TResolve
 type GenerateGuardsImplementationsPart<TContext extends MachineContext, TResolvedTypesMeta, TRequireMissingImplementations, TMissingImplementations> = Compute<MaybeMakeMissingImplementationsRequired<'guards', Prop<TMissingImplementations, 'guards'>, TRequireMissingImplementations> & {
     guards?: MachineImplementationsGuards<TContext, TResolvedTypesMeta>;
 }>;
-export type InternalMachineImplementations<TContext extends MachineContext, TEvent extends EventObject, TActor extends ProvidedActor, TAction extends ParameterizedObject, TDelay extends string, TResolvedTypesMeta, TRequireMissingImplementations extends boolean = false, TMissingImplementations = Prop<Prop<TResolvedTypesMeta, 'resolved'>, 'missingImplementations'>> = Compute<GenerateActionsImplementationsPart<TContext, TResolvedTypesMeta, TRequireMissingImplementations, TMissingImplementations> & GenerateActorsImplementationsPart<TContext, TResolvedTypesMeta, TRequireMissingImplementations, TMissingImplementations> & GenerateDelaysImplementationsPart<TContext, TResolvedTypesMeta, TRequireMissingImplementations, TMissingImplementations> & GenerateGuardsImplementationsPart<TContext, TResolvedTypesMeta, TRequireMissingImplementations, TMissingImplementations>>;
-export type MachineImplementations<TContext extends MachineContext, TEvent extends EventObject, TActor extends ProvidedActor = ProvidedActor, TAction extends ParameterizedObject = ParameterizedObject, TGuard extends ParameterizedObject = ParameterizedObject, TDelay extends string = string, TTag extends string = string, TTypesMeta extends TypegenConstraint = TypegenDisabled> = InternalMachineImplementations<TContext, TEvent, TActor, TAction, TDelay, ResolveTypegenMeta<TTypesMeta, TEvent, TActor, TAction, TGuard, TDelay, TTag>>;
+export type InternalMachineImplementations<TContext extends MachineContext, TResolvedTypesMeta, TRequireMissingImplementations extends boolean = false, TMissingImplementations = Prop<Prop<TResolvedTypesMeta, 'resolved'>, 'missingImplementations'>> = Compute<GenerateActionsImplementationsPart<TContext, TResolvedTypesMeta, TRequireMissingImplementations, TMissingImplementations> & GenerateActorsImplementationsPart<TContext, TResolvedTypesMeta, TRequireMissingImplementations, TMissingImplementations> & GenerateDelaysImplementationsPart<TContext, TResolvedTypesMeta, TRequireMissingImplementations, TMissingImplementations> & GenerateGuardsImplementationsPart<TContext, TResolvedTypesMeta, TRequireMissingImplementations, TMissingImplementations>>;
+export type MachineImplementations<TContext extends MachineContext, TEvent extends EventObject, TActor extends ProvidedActor = ProvidedActor, TAction extends ParameterizedObject = ParameterizedObject, TGuard extends ParameterizedObject = ParameterizedObject, TDelay extends string = string, TTag extends string = string, TTypesMeta extends TypegenConstraint = TypegenDisabled> = InternalMachineImplementations<TContext, ResolveTypegenMeta<TTypesMeta, TEvent, TActor, TAction, TGuard, TDelay, TTag>>;
 type InitialContext<TContext extends MachineContext, TActor extends ProvidedActor, TInput> = TContext | ContextFactory<TContext, TActor, TInput>;
 export type ContextFactory<TContext extends MachineContext, TActor extends ProvidedActor, TInput> = ({ spawn, input }: {
     spawn: Spawner<TActor>;
@@ -441,16 +441,18 @@ export interface ProvidedActor {
     logic: AnyActorLogic;
     id?: string;
 }
-export interface MachineTypes<TContext extends MachineContext, TEvent extends EventObject, TActor extends ProvidedActor, TAction extends ParameterizedObject, TGuard extends ParameterizedObject, TDelay extends string, TTag extends string, TInput, TOutput, TTypesMeta = TypegenDisabled> {
+export interface SetupTypes<TContext extends MachineContext, TEvent extends EventObject, TTag extends string, TInput, TOutput> {
     context?: TContext;
     events?: TEvent;
+    tags?: TTag;
+    input?: TInput;
+    output?: TOutput;
+}
+export interface MachineTypes<TContext extends MachineContext, TEvent extends EventObject, TActor extends ProvidedActor, TAction extends ParameterizedObject, TGuard extends ParameterizedObject, TDelay extends string, TTag extends string, TInput, TOutput, TTypesMeta = TypegenDisabled> extends SetupTypes<TContext, TEvent, TTag, TInput, TOutput> {
     actors?: TActor;
     actions?: TAction;
     guards?: TGuard;
     delays?: TDelay;
-    tags?: TTag;
-    input?: TInput;
-    output?: TOutput;
     typegen?: TTypesMeta;
 }
 export interface HistoryStateNode<TContext extends MachineContext> extends StateNode<TContext> {
@@ -541,7 +543,6 @@ export interface StateLike<TContext extends MachineContext> {
 export interface StateConfig<TContext extends MachineContext, TEvent extends EventObject> {
     context: TContext;
     historyValue?: HistoryValue<TContext, TEvent>;
-    configuration: Array<StateNode<TContext, TEvent>>;
     children: Record<string, ActorRef<any, any>>;
     status: 'active' | 'done' | 'error' | 'stopped';
     output?: any;
@@ -601,7 +602,7 @@ export interface ActorOptions<TLogic extends AnyActorLogic> {
      *
      * @see https://stately.ai/docs/persistence
      */
-    state?: any;
+    state?: Snapshot<unknown>;
     /**
      * The source definition.
      */
@@ -736,7 +737,7 @@ export type DevToolsAdapter = (service: AnyActor) => void;
  * @deprecated Use `Actor<T>` instead.
  */
 export type InterpreterFrom<T extends AnyStateMachine | ((...args: any[]) => AnyStateMachine)> = ReturnTypeOrValue<T> extends StateMachine<infer TContext, infer TEvent, infer TActor, infer _TAction, infer _TGuard, infer _TDelay, infer TTag, infer TInput, infer TOutput, infer TResolvedTypesMeta> ? Actor<ActorLogic<MachineSnapshot<TContext, TEvent, TActor, TTag, TOutput, TResolvedTypesMeta>, TEvent, TInput, ActorSystem<any>>> : never;
-export type MachineImplementationsFrom<T extends AnyStateMachine | ((...args: any[]) => AnyStateMachine), TRequireMissingImplementations extends boolean = false> = ReturnTypeOrValue<T> extends StateMachine<infer TContext, infer TEvent, infer TActor, infer TAction, infer _TGuard, infer TDelay, infer _TTag, infer _TInput, infer _TOutput, infer TResolvedTypesMeta> ? InternalMachineImplementations<TContext, TEvent, TActor, TAction, TDelay, TResolvedTypesMeta, TRequireMissingImplementations> : never;
+export type MachineImplementationsFrom<T extends AnyStateMachine | ((...args: any[]) => AnyStateMachine), TRequireMissingImplementations extends boolean = false> = ReturnTypeOrValue<T> extends StateMachine<infer TContext, infer _TEvent, infer _TActor, infer _TAction, infer _TGuard, infer _TDelay, infer _TTag, infer _TInput, infer _TOutput, infer TResolvedTypesMeta> ? InternalMachineImplementations<TContext, TResolvedTypesMeta, TRequireMissingImplementations> : never;
 export type __ResolvedTypesMetaFrom<T> = T extends StateMachine<any, // context
 any, // event
 any, // actor
@@ -850,4 +851,5 @@ export interface ActorSystem<T extends ActorSystemInfo> {
     inspect: (observer: Observer<InspectionEvent>) => void;
 }
 export type AnyActorSystem = ActorSystem<any>;
+export type RequiredActorOptions<TActor extends ProvidedActor> = ('id' extends keyof TActor ? 'id' : never) | (undefined extends InputFrom<TActor['logic']> ? never : 'input');
 export {};

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

@@ -1,11 +1,9 @@
-import { AnyState } from "./index.js";
 import type { StateNode } from "./StateNode.js";
 import type { ActorLogic, AnyEventObject, EventObject, MachineContext, Mapper, Observer, ErrorActorEvent, SingleOrArray, StateLike, StateValue, Subscribable, TransitionConfigTarget, AnyActorRef, AnyTransitionConfig, NonReducibleUnknown, AnyStateMachine } from "./types.js";
 export declare function keys<T extends object>(value: T): Array<keyof T & string>;
 export declare function matchesState(parentStateId: StateValue, childStateId: StateValue): boolean;
 export declare function toStatePath(stateId: string | string[]): string[];
-export declare function isStateLike(state: any): state is AnyState;
-export declare function toStateValue(stateValue: StateLike<any> | StateValue | string[]): StateValue;
+export declare function toStateValue(stateValue: StateLike<any> | StateValue): StateValue;
 export declare function pathToStateValue(statePath: string[]): StateValue;
 export declare function mapValues<P, O extends Record<string, unknown>>(collection: O, iteratee: (item: O[keyof O], key: keyof O, collection: O, i: number) => P): {
     [key in keyof O]: P;