xstate 5.14.0 → 5.16.0

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

@@ -13,22 +13,21 @@ export declare enum ProcessingStatus {
     Stopped = 2
 }
 /**
- * An Actor is a running process that can receive events, send events and change its behavior based on the events it receives, which can cause effects outside of the actor. When you run a state machine, it becomes an actor.
+ * An Actor is a running process that can receive events, send events and change
+ * its behavior based on the events it receives, which can cause effects outside
+ * of the actor. When you run a state machine, it becomes an actor.
  */
 export declare class Actor<TLogic extends AnyActorLogic> implements ActorRef<SnapshotFrom<TLogic>, EventFromLogic<TLogic>, EmittedFrom<TLogic>> {
     logic: TLogic;
-    /**
-     * The current internal state of the actor.
-     */
+    /** The current internal state of the actor. */
     private _snapshot;
     /**
-     * The clock that is responsible for setting and clearing timeouts, such as delayed events and transitions.
+     * The clock that is responsible for setting and clearing timeouts, such as
+     * delayed events and transitions.
      */
     clock: Clock;
     options: Readonly<ActorOptions<TLogic>>;
-    /**
-     * The unique identifier for this actor relative to its parent.
-     */
+    /** The unique identifier for this actor relative to its parent. */
     id: string;
     private mailbox;
     private observers;
@@ -38,18 +37,15 @@ export declare class Actor<TLogic extends AnyActorLogic> implements ActorRef<Sna
     ref: ActorRef<SnapshotFrom<TLogic>, EventFromLogic<TLogic>, EmittedFrom<TLogic>>;
     private _actorScope;
     private _systemId;
-    /**
-     * The globally unique process ID for this invocation.
-     */
+    /** The globally unique process ID for this invocation. */
     sessionId: string;
-    /**
-     * The system to which this actor belongs.
-     */
+    /** The system to which this actor belongs. */
     system: AnyActorSystem;
     private _doneEvent?;
     src: string | AnyActorLogic;
     /**
-     * Creates a new actor instance for the given logic with the provided options, if any.
+     * Creates a new actor instance for the given logic with the provided options,
+     * if any.
      *
      * @param logic The logic to create an actor from
      * @param options Actor options
@@ -62,11 +58,15 @@ export declare class Actor<TLogic extends AnyActorLogic> implements ActorRef<Sna
      * Subscribe an observer to an actor’s snapshot values.
      *
      * @remarks
-     * The observer will receive the actor’s snapshot value when it is emitted. The observer can be:
+     * The observer will receive the actor’s snapshot value when it is emitted.
+     * The observer can be:
+     *
      * - A plain function that receives the latest snapshot, or
-     * - An observer object whose `.next(snapshot)` method receives the latest snapshot
+     * - An observer object whose `.next(snapshot)` method receives the latest
+     *   snapshot
      *
      * @example
+     *
      * ```ts
      * // Observer as a plain function
      * const subscription = actor.subscribe((snapshot) => {
@@ -75,6 +75,7 @@ export declare class Actor<TLogic extends AnyActorLogic> implements ActorRef<Sna
      * ```
      *
      * @example
+     *
      * ```ts
      * // Observer as an object
      * const subscription = actor.subscribe({
@@ -86,13 +87,16 @@ export declare class Actor<TLogic extends AnyActorLogic> implements ActorRef<Sna
      *   },
      *   complete() {
      *     // ...
-     *   },
+     *   }
      * });
      * ```
      *
-     * The return value of `actor.subscribe(observer)` is a subscription object that has an `.unsubscribe()` method. You can call `subscription.unsubscribe()` to unsubscribe the observer:
+     * The return value of `actor.subscribe(observer)` is a subscription object
+     * that has an `.unsubscribe()` method. You can call
+     * `subscription.unsubscribe()` to unsubscribe the observer:
      *
      * @example
+     *
      * ```ts
      * const subscription = actor.subscribe((snapshot) => {
      *   // ...
@@ -102,24 +106,23 @@ export declare class Actor<TLogic extends AnyActorLogic> implements ActorRef<Sna
      * subscription.unsubscribe();
      * ```
      *
-     * When the actor is stopped, all of its observers will automatically be unsubscribed.
+     * When the actor is stopped, all of its observers will automatically be
+     * unsubscribed.
      *
-     * @param observer - Either a plain function that receives the latest snapshot, or an observer object whose `.next(snapshot)` method receives the latest snapshot
+     * @param observer - Either a plain function that receives the latest
+     *   snapshot, or an observer object whose `.next(snapshot)` method receives
+     *   the latest snapshot
      */
     subscribe(observer: Observer<SnapshotFrom<TLogic>>): Subscription;
     subscribe(nextListener?: (snapshot: SnapshotFrom<TLogic>) => void, errorListener?: (error: any) => void, completeListener?: () => void): Subscription;
     on<TType extends EmittedFrom<TLogic>['type'] | '*'>(type: TType, handler: (emitted: EmittedFrom<TLogic> & (TType extends '*' ? {} : {
         type: TType;
     })) => void): Subscription;
-    /**
-     * Starts the Actor from the initial state
-     */
+    /** Starts the Actor from the initial state */
     start(): this;
     private _process;
     private _stop;
-    /**
-     * Stops the Actor and unsubscribe all listeners.
-     */
+    /** Stops the Actor and unsubscribe all listeners. */
     stop(): this;
     private _complete;
     private _reportError;
@@ -142,10 +145,11 @@ export declare class Actor<TLogic extends AnyActorLogic> implements ActorRef<Sna
      * @remarks
      * The internal state can be persisted from any actor, not only machines.
      *
-     * Note that the persisted state is not the same as the snapshot from {@link Actor.getSnapshot}. Persisted state represents the internal state of the actor, while snapshots represent the actor's last emitted value.
+     * Note that the persisted state is not the same as the snapshot from
+     * {@link Actor.getSnapshot}. Persisted state represents the internal state of
+     * the actor, while snapshots represent the actor's last emitted value.
      *
      * Can be restored with {@link ActorOptions.state}
-     *
      * @see https://stately.ai/docs/persistence
      */
     getPersistedSnapshot(): Snapshot<unknown>;
@@ -156,11 +160,11 @@ export declare class Actor<TLogic extends AnyActorLogic> implements ActorRef<Sna
      * @remarks
      * The snapshot represent an actor's last emitted value.
      *
-     * When an actor receives an event, its internal state may change.
-     * An actor may emit a snapshot when a state transition occurs.
-     *
-     * Note that some actors, such as callback actors generated with `fromCallback`, will not emit snapshots.
+     * When an actor receives an event, its internal state may change. An actor
+     * may emit a snapshot when a state transition occurs.
      *
+     * Note that some actors, such as callback actors generated with
+     * `fromCallback`, will not emit snapshots.
      * @see {@link Actor.subscribe} to subscribe to an actor’s snapshot values.
      * @see {@link Actor.getPersistedSnapshot} to persist the internal state of an actor (which is more than just a snapshot).
      */
@@ -168,13 +172,16 @@ export declare class Actor<TLogic extends AnyActorLogic> implements ActorRef<Sna
 }
 type RequiredOptions<TLogic extends AnyActorLogic> = undefined extends InputFrom<TLogic> ? never : 'input';
 /**
- * Creates a new actor instance for the given actor logic with the provided options, if any.
+ * Creates a new actor instance for the given actor logic with the provided
+ * options, if any.
  *
  * @remarks
- * When you create an actor from actor logic via `createActor(logic)`, you implicitly create an actor system where the created actor is the root actor.
- * Any actors spawned from this root actor and its descendants are part of that actor system.
- *
+ * When you create an actor from actor logic via `createActor(logic)`, you
+ * implicitly create an actor system where the created actor is the root actor.
+ * Any actors spawned from this root actor and its descendants are part of that
+ * actor system.
  * @example
+ *
  * ```ts
  * import { createActor } from 'xstate';
  * import { someActorLogic } from './someActorLogic.ts';
@@ -196,7 +203,10 @@ type RequiredOptions<TLogic extends AnyActorLogic> = undefined extends InputFrom
  * actor.stop();
  * ```
  *
- * @param logic - The actor logic to create an actor from. For a state machine actor logic creator, see {@link createMachine}. Other actor logic creators include {@link fromCallback}, {@link fromEventObservable}, {@link fromObservable}, {@link fromPromise}, and {@link fromTransition}.
+ * @param logic - The actor logic to create an actor from. For a state machine
+ *   actor logic creator, see {@link createMachine}. Other actor logic creators
+ *   include {@link fromCallback}, {@link fromEventObservable},
+ *   {@link fromObservable}, {@link fromPromise}, and {@link fromTransition}.
  * @param options - Actor options
  */
 export declare function createActor<TLogic extends AnyActorLogic>(logic: TLogic, ...[options]: ConditionalRequired<[
@@ -205,13 +215,12 @@ export declare function createActor<TLogic extends AnyActorLogic>(logic: TLogic,
     }
 ], IsNotNever<RequiredOptions<TLogic>>>): Actor<TLogic>;
 /**
- * Creates a new Interpreter instance for the given machine with the provided options, if any.
+ * Creates a new Interpreter instance for the given machine with the provided
+ * options, if any.
  *
  * @deprecated Use `createActor` instead
  */
 export declare const interpret: typeof createActor;
-/**
- * @deprecated Use `Actor` instead.
- */
+/** @deprecated Use `Actor` instead. */
 export type Interpreter = typeof Actor;
 export {};

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

@@ -1,64 +1,50 @@
 import { StateMachine } from "./StateMachine.js";
-import { ResolveTypegenMeta, TypegenConstraint, TypegenDisabled } from "./typegenTypes.js";
-import { AnyActorRef, EventObject, AnyEventObject, Cast, InternalMachineImplementations, IsNever, MachineConfig, MachineContext, MachineTypes, NonReducibleUnknown, ParameterizedObject, Prop, ProvidedActor, StateValue, ToChildren, MetaObject } from "./types.js";
-type TestValue = string | {
-    [k: string]: TestValue | undefined;
-};
-type _GroupTestValues<TTestValue extends string | TestValue> = TTestValue extends string ? TTestValue extends `${string}.${string}` ? [never, never] : [TTestValue, never] : [never, TTestValue];
-type GroupTestValues<TTestValue extends string | TestValue> = {
-    leafCandidates: _GroupTestValues<TTestValue>[0];
-    nonLeaf: _GroupTestValues<TTestValue>[1];
-};
-type FilterLeafValues<TLeafCandidate extends string, TNonLeaf extends {
-    [k: string]: TestValue | undefined;
-}> = IsNever<TNonLeaf> extends true ? TLeafCandidate : TLeafCandidate extends string ? TLeafCandidate extends keyof TNonLeaf ? never : TLeafCandidate : never;
-type ToStateValue<TTestValue extends string | TestValue> = FilterLeafValues<GroupTestValues<TTestValue>['leafCandidates'], GroupTestValues<TTestValue>['nonLeaf']> | (IsNever<GroupTestValues<TTestValue>['nonLeaf']> extends false ? {
-    [K in keyof GroupTestValues<TTestValue>['nonLeaf']]: ToStateValue<NonNullable<GroupTestValues<TTestValue>['nonLeaf'][K]>>;
-} : never);
+import { ResolvedStateMachineTypes } from "./types.js";
+import { AnyActorRef, EventObject, AnyEventObject, Cast, InternalMachineImplementations, MachineConfig, MachineContext, MachineTypes, NonReducibleUnknown, ParameterizedObject, ProvidedActor, StateValue, ToChildren, MetaObject } from "./types.js";
 /**
  * Creates a state machine (statechart) with the given configuration.
  *
  * The state machine represents the pure logic of a state machine actor.
  *
- * @param config The state machine configuration.
- * @param options DEPRECATED: use `setup({ ... })` or `machine.provide({ ... })` to provide machine implementations instead.
- *
  * @example
-  ```ts
-  import { createMachine } from 'xstate';
-
-  const lightMachine = createMachine({
-    id: 'light',
-    initial: 'green',
-    states: {
-      green: {
-        on: {
-          TIMER: { target: 'yellow' }
-        }
-      },
-      yellow: {
-        on: {
-          TIMER: { target: 'red' }
-        }
-      },
-      red: {
-        on: {
-          TIMER: { target: 'green' }
-        }
-      }
-    }
-  });
-
-  const lightActor = createActor(lightMachine);
-  lightActor.start();
-
-  lightActor.send({ type: 'TIMER' });
-  ```
+ *
+ * ```ts
+ * import { createMachine } from 'xstate';
+ *
+ * const lightMachine = createMachine({
+ *   id: 'light',
+ *   initial: 'green',
+ *   states: {
+ *     green: {
+ *       on: {
+ *         TIMER: { target: 'yellow' }
+ *       }
+ *     },
+ *     yellow: {
+ *       on: {
+ *         TIMER: { target: 'red' }
+ *       }
+ *     },
+ *     red: {
+ *       on: {
+ *         TIMER: { target: 'green' }
+ *       }
+ *     }
+ *   }
+ * });
+ *
+ * const lightActor = createActor(lightMachine);
+ * lightActor.start();
+ *
+ * lightActor.send({ type: 'TIMER' });
+ * ```
+ *
+ * @param config The state machine configuration.
+ * @param options DEPRECATED: use `setup({ ... })` or `machine.provide({ ... })`
+ *   to provide machine implementations instead.
  */
 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, TEmitted extends EventObject, TMeta extends MetaObject, TTypesMeta extends TypegenConstraint = TypegenDisabled>(config: {
-    types?: MachineTypes<TContext, TEvent, TActor, TAction, TGuard, TDelay, TTag, TInput, TOutput, TEmitted, TMeta, TTypesMeta>;
+TActor extends ProvidedActor, TAction extends ParameterizedObject, TGuard extends ParameterizedObject, TDelay extends string, TTag extends string, TInput, TOutput extends NonReducibleUnknown, TEmitted extends EventObject, TMeta extends MetaObject, _ = any>(config: {
+    types?: MachineTypes<TContext, TEvent, TActor, TAction, TGuard, TDelay, TTag, TInput, TOutput, TEmitted, TMeta>;
     schemas?: unknown;
-} & MachineConfig<TContext, TEvent, TActor, TAction, TGuard, TDelay, TTag, TInput, TOutput, TEmitted, TMeta, TTypesMeta>, implementations?: InternalMachineImplementations<TContext, ResolveTypegenMeta<TTypesMeta, TEvent, TActor, TAction, TGuard, TDelay, TTag, TEmitted>>): StateMachine<TContext, TEvent, Cast<ToChildren<TActor>, Record<string, AnyActorRef | undefined>>, TActor, TAction, TGuard, TDelay, 'matchesStates' extends keyof TTypesMeta ? ToStateValue<Cast<TTypesMeta['matchesStates'], TestValue>> : StateValue, Prop<ResolveTypegenMeta<TTypesMeta, TEvent, TActor, TAction, TGuard, TDelay, TTag, TEmitted>['resolved'], 'tags'> & string, TInput, TOutput, TEmitted, TMeta, // TMeta
-ResolveTypegenMeta<TTypesMeta, TEvent, TActor, TAction, TGuard, TDelay, TTag, TEmitted>>;
-export {};
+} & MachineConfig<TContext, TEvent, TActor, TAction, TGuard, TDelay, TTag, TInput, TOutput, TEmitted, TMeta>, implementations?: InternalMachineImplementations<ResolvedStateMachineTypes<TContext, TEvent, TActor, TAction, TGuard, TDelay, TTag, TEmitted>>): StateMachine<TContext, TEvent, Cast<ToChildren<TActor>, Record<string, AnyActorRef | undefined>>, TActor, TAction, TGuard, TDelay, StateValue, TTag & string, TInput, TOutput, TEmitted, TMeta>;

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

@@ -1,32 +1,35 @@
 import { AnyActorLogic, EventFromLogic, InputFrom, SnapshotFrom } from "./types.js";
 export declare function getInitialSnapshot<T extends AnyActorLogic>(actorLogic: T, ...[input]: undefined extends InputFrom<T> ? [input?: InputFrom<T>] : [input: InputFrom<T>]): SnapshotFrom<T>;
 /**
- * Determines the next snapshot for the given `actorLogic` based on
- * the given `snapshot` and `event`.
+ * Determines the next snapshot for the given `actorLogic` based on the given
+ * `snapshot` and `event`.
  *
- * If the `snapshot` is `undefined`, the initial snapshot of the
- * `actorLogic` is used.
+ * If the `snapshot` is `undefined`, the initial snapshot of the `actorLogic` is
+ * used.
  *
  * @example
-  ```ts
-  import { getNextSnapshot } from 'xstate';
-  import { trafficLightMachine } from './trafficLightMachine.ts';
-
-  const nextSnapshot = getNextSnapshot(
-    trafficLightMachine, // actor logic
-    undefined, // snapshot (or initial state if undefined)
-    { type: 'TIMER' }); // event object
-
-  console.log(nextSnapshot.value);
-  // => 'yellow'
-
-  const nextSnapshot2 = getNextSnapshot(
-    trafficLightMachine, // actor logic
-    nextSnapshot, // snapshot
-    { type: 'TIMER' }); // event object
-
-  console.log(nextSnapshot2.value);
-  // =>'red'
-  ```
+ *
+ * ```ts
+ * import { getNextSnapshot } from 'xstate';
+ * import { trafficLightMachine } from './trafficLightMachine.ts';
+ *
+ * const nextSnapshot = getNextSnapshot(
+ *   trafficLightMachine, // actor logic
+ *   undefined, // snapshot (or initial state if undefined)
+ *   { type: 'TIMER' }
+ * ); // event object
+ *
+ * console.log(nextSnapshot.value);
+ * // => 'yellow'
+ *
+ * const nextSnapshot2 = getNextSnapshot(
+ *   trafficLightMachine, // actor logic
+ *   nextSnapshot, // snapshot
+ *   { type: 'TIMER' }
+ * ); // event object
+ *
+ * console.log(nextSnapshot2.value);
+ * // =>'red'
+ * ```
  */
 export declare function getNextSnapshot<T extends AnyActorLogic>(actorLogic: T, snapshot: SnapshotFrom<T>, event: EventFromLogic<T>): SnapshotFrom<T>;

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

@@ -27,29 +27,32 @@ type UnknownReferencedGuard = Guard<MachineContext, EventObject, ParameterizedOb
 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>;
 /**
- * Higher-order guard that evaluates to `true` if the `guard` passed to it evaluates to `false`.
+ * Higher-order guard that evaluates to `true` if the `guard` passed to it
+ * evaluates to `false`.
  *
  * @category Guards
  * @example
-  ```ts
-  import { setup, not } from 'xstate';
-
-  const machine = setup({
-    guards: {
-      someNamedGuard: () => false
-    }
-  }).createMachine({
-    on: {
-      someEvent: {
-        guard: not('someNamedGuard'),
-        actions: () => {
-          // will be executed if guard in `not(...)`
-          // evaluates to `false`
-        }
-      }
-    }
-  });
-  ```
+ *
+ * ```ts
+ * import { setup, not } from 'xstate';
+ *
+ * const machine = setup({
+ *   guards: {
+ *     someNamedGuard: () => false
+ *   }
+ * }).createMachine({
+ *   on: {
+ *     someEvent: {
+ *       guard: not('someNamedGuard'),
+ *       actions: () => {
+ *         // will be executed if guard in `not(...)`
+ *         // evaluates to `false`
+ *       }
+ *     }
+ *   }
+ * });
+ * ```
+ *
  * @returns A guard
  */
 export declare function not<TContext extends MachineContext, TExpressionEvent extends EventObject, TArg>(guard: SingleGuardArg<TContext, TExpressionEvent, unknown, TArg>): GuardPredicate<TContext, TExpressionEvent, unknown, NormalizeGuardArg<DoNotInfer<TArg>>>;
@@ -59,28 +62,27 @@ export declare function not<TContext extends MachineContext, TExpressionEvent ex
  *
  * @category Guards
  * @example
-  ```ts
-  import { setup, and } from 'xstate';
-
-  const machine = setup({
-    guards: {
-      someNamedGuard: () => true
-    }
-  }).createMachine({
-    on: {
-      someEvent: {
-        guard: and([
-          ({ context }) => context.value > 0,
-          'someNamedGuard'
-        ]),
-        actions: () => {
-          // will be executed if all guards in `and(...)`
-          // evaluate to true
-        }
-      }
-    }
-  });
-  ```
+ *
+ * ```ts
+ * import { setup, and } from 'xstate';
+ *
+ * const machine = setup({
+ *   guards: {
+ *     someNamedGuard: () => true
+ *   }
+ * }).createMachine({
+ *   on: {
+ *     someEvent: {
+ *       guard: and([({ context }) => context.value > 0, 'someNamedGuard']),
+ *       actions: () => {
+ *         // will be executed if all guards in `and(...)`
+ *         // evaluate to true
+ *       }
+ *     }
+ *   }
+ * });
+ * ```
+ *
  * @returns A guard action object
  */
 export declare function and<TContext extends MachineContext, TExpressionEvent extends EventObject, TArg extends unknown[]>(guards: readonly [
@@ -89,33 +91,32 @@ export declare function and<TContext extends MachineContext, TExpressionEvent ex
     }
 ]): GuardPredicate<TContext, TExpressionEvent, unknown, NormalizeGuardArgArray<DoNotInfer<TArg>>>;
 /**
- * Higher-order guard that evaluates to `true` if any of the `guards` passed to it
- * evaluate to `true`.
+ * Higher-order guard that evaluates to `true` if any of the `guards` passed to
+ * it evaluate to `true`.
  *
  * @category Guards
  * @example
-  ```ts
-  import { setup, or } from 'xstate';
-
-  const machine = setup({
-    guards: {
-      someNamedGuard: () => true
-    }
-  }).createMachine({
-    on: {
-      someEvent: {
-        guard: or([
-          ({ context }) => context.value > 0,
-          'someNamedGuard'
-        ]),
-        actions: () => {
-          // will be executed if any of the guards in `or(...)`
-          // evaluate to true
-        }
-      }
-    }
-  });
-  ```
+ *
+ * ```ts
+ * import { setup, or } from 'xstate';
+ *
+ * const machine = setup({
+ *   guards: {
+ *     someNamedGuard: () => true
+ *   }
+ * }).createMachine({
+ *   on: {
+ *     someEvent: {
+ *       guard: or([({ context }) => context.value > 0, 'someNamedGuard']),
+ *       actions: () => {
+ *         // will be executed if any of the guards in `or(...)`
+ *         // evaluate to true
+ *       }
+ *     }
+ *   }
+ * });
+ * ```
+ *
  * @returns A guard action object
  */
 export declare function or<TContext extends MachineContext, TExpressionEvent extends EventObject, TArg extends unknown[]>(guards: readonly [

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

@@ -5,12 +5,11 @@ export { type Spawner } from "./spawn.js";
 export { isMachineSnapshot, type MachineSnapshot } from "./State.js";
 export { StateMachine } from "./StateMachine.js";
 export { getStateNodes } from "./stateUtils.js";
-export * from "./typegenTypes.js";
 export * from "./types.js";
 export { waitFor } from "./waitFor.js";
 import { createMachine } from "./createMachine.js";
 export { getInitialSnapshot, getNextSnapshot } from "./getNextSnapshot.js";
-import { Actor, createActor, interpret, Interpreter } from "./createActor.js";
+import { Actor, createActor, interpret, type Interpreter } from "./createActor.js";
 import { StateNode } from "./StateNode.js";
 export { and, not, or, stateIn } from "./guards.js";
 export { setup } from "./setup.js";

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

@@ -4,6 +4,7 @@ export interface BaseInspectionEventProperties {
     rootId: string;
     /**
      * The relevant actorRef for the inspection event.
+     *
      * - For snapshot events, this is the `actorRef` of the snapshot.
      * - For event events, this is the target `actorRef` (recipient of event).
      * - For actor events, this is the `actorRef` of the registered actor.

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

@@ -1,6 +1,5 @@
 import { StateMachine } from "./StateMachine.js";
 import { GuardPredicate } from "./guards.js";
-import { ResolveTypegenMeta, TypegenDisabled } from "./typegenTypes.js";
 import { ActionFunction, AnyActorRef, AnyEventObject, Cast, ConditionalRequired, DelayConfig, EventObject, Invert, IsNever, MachineConfig, MachineContext, MetaObject, NonReducibleUnknown, ParameterizedObject, SetupTypes, StateSchema, ToChildren, UnknownActorLogic, Values } from "./types.js";
 type ToParameterizedObject<TParameterizedMap extends Record<string, ParameterizedObject['params'] | undefined>> = IsNever<TParameterizedMap> extends true ? never : Values<{
     [K in keyof TParameterizedMap & string]: {
@@ -51,6 +50,6 @@ TActors extends Record<string, UnknownActorLogic> = {}, TChildrenMap extends Rec
 } & {
     [K in RequiredSetupKeys<TChildrenMap>]: unknown;
 }): {
-    createMachine: <const TConfig extends MachineConfig<TContext, TEvent, ToProvidedActor<TChildrenMap, TActors>, ToParameterizedObject<TActions>, ToParameterizedObject<TGuards>, TDelay, TTag, TInput, TOutput, TEmitted, TMeta, ResolveTypegenMeta<TypegenDisabled, TEvent, ToProvidedActor<TChildrenMap, TActors>, ToParameterizedObject<TActions>, ToParameterizedObject<TGuards>, TDelay, TTag, TEmitted>>>(config: TConfig) => StateMachine<TContext, TEvent, Cast<ToChildren<ToProvidedActor<TChildrenMap, TActors>>, Record<string, AnyActorRef | undefined>>, ToProvidedActor<TChildrenMap, TActors>, ToParameterizedObject<TActions>, ToParameterizedObject<TGuards>, TDelay, ToStateValue<TConfig>, TTag, TInput, TOutput, TEmitted, TMeta, ResolveTypegenMeta<TypegenDisabled, TEvent, ToProvidedActor<TChildrenMap, TActors>, ToParameterizedObject<TActions>, ToParameterizedObject<TGuards>, TDelay, TTag, TEmitted>>;
+    createMachine: <const TConfig extends MachineConfig<TContext, TEvent, ToProvidedActor<TChildrenMap, TActors>, ToParameterizedObject<TActions>, ToParameterizedObject<TGuards>, TDelay, TTag, TInput, TOutput, TEmitted, TMeta>>(config: TConfig) => StateMachine<TContext, TEvent, Cast<ToChildren<ToProvidedActor<TChildrenMap, TActors>>, Record<string, AnyActorRef | undefined>>, ToProvidedActor<TChildrenMap, TActors>, ToParameterizedObject<TActions>, ToParameterizedObject<TGuards>, TDelay, ToStateValue<TConfig>, TTag, TInput, TOutput, TEmitted, TMeta>;
 };
 export {};

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

@@ -1,4 +1,4 @@
-import { ActorRefFrom, AnyActorLogic, AnyActorRef, AnyActorScope, AnyEventObject, AnyMachineSnapshot, ConditionalRequired, InputFrom, IsLiteralString, IsNotNever, ProvidedActor, RequiredActorOptions } from "./types.js";
+import { ActorRefFrom, AnyActorLogic, AnyActorRef, AnyActorScope, AnyEventObject, AnyMachineSnapshot, ConditionalRequired, GetConcreteByKey, InputFrom, IsLiteralString, IsNotNever, ProvidedActor, RequiredActorOptions } from "./types.js";
 type SpawnOptions<TActor extends ProvidedActor, TSrc extends TActor['src']> = TActor extends {
     src: TSrc;
 } ? ConditionalRequired<[
@@ -11,11 +11,8 @@ type SpawnOptions<TActor extends ProvidedActor, TSrc extends TActor['src']> = TA
         [K in RequiredActorOptions<TActor>]: unknown;
     }
 ], IsNotNever<RequiredActorOptions<TActor>>> : never;
-type GetConcreteLogic<TActor extends ProvidedActor, TSrc extends TActor['src']> = Extract<TActor, {
-    src: TSrc;
-}>['logic'];
 export type Spawner<TActor extends ProvidedActor> = IsLiteralString<TActor['src']> extends true ? {
-    <TSrc extends TActor['src']>(logic: TSrc, ...[options]: SpawnOptions<TActor, TSrc>): ActorRefFrom<GetConcreteLogic<TActor, TSrc>>;
+    <TSrc extends TActor['src']>(logic: TSrc, ...[options]: SpawnOptions<TActor, TSrc>): ActorRefFrom<GetConcreteByKey<TActor, 'src', TSrc>['logic']>;
     <TLogic extends AnyActorLogic>(src: TLogic, options?: {
         id?: never;
         systemId?: string;

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

@@ -11,9 +11,7 @@ export declare function getStateValue(rootNode: AnyStateNode, stateNodes: AnySta
 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>>;
-/**
- * All delayed transitions from the config.
- */
+/** All delayed transitions from the config. */
 export declare function getDelayedTransitions(stateNode: AnyStateNode): Array<DelayedTransitionDefinition<MachineContext, EventObject>>;
 export declare function formatTransition<TContext extends MachineContext, TEvent extends EventObject>(stateNode: AnyStateNode, descriptor: string, transitionConfig: AnyTransitionConfig): AnyTransitionDefinition;
 export declare function formatTransitions<TContext extends MachineContext, TEvent extends EventObject>(stateNode: AnyStateNode): Map<string, TransitionDefinition<TContext, TEvent>[]>;
@@ -21,9 +19,7 @@ export declare function formatInitialTransition<TContext extends MachineContext,
 export declare function resolveTarget(stateNode: AnyStateNode, targets: ReadonlyArray<string | AnyStateNode> | undefined): ReadonlyArray<AnyStateNode> | undefined;
 export declare function getInitialStateNodesWithTheirAncestors(stateNode: AnyStateNode): Set<AnyStateNode>;
 export declare function getInitialStateNodes(stateNode: AnyStateNode): Set<AnyStateNode>;
-/**
- * Returns the child state node from its relative `stateKey`, or throws.
- */
+/** Returns the child state node from its relative `stateKey`, or throws. */
 export declare function getStateNode(stateNode: AnyStateNode, stateKey: string): AnyStateNode;
 /**
  * Returns the relative state node from the given `statePath`, or throws.
@@ -42,9 +38,7 @@ export declare function transitionCompoundNode<TContext extends MachineContext,
 export declare function transitionParallelNode<TContext extends MachineContext, TEvent extends EventObject>(stateNode: AnyStateNode, stateValue: StateValueMap, snapshot: MachineSnapshot<TContext, TEvent, any, 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, snapshot: MachineSnapshot<TContext, TEvent, any, any, any, any, any>, event: TEvent): Array<TransitionDefinition<TContext, TEvent>> | undefined;
 export declare function removeConflictingTransitions(enabledTransitions: Array<AnyTransitionDefinition>, stateNodeSet: Set<AnyStateNode>, historyValue: AnyHistoryValue): Array<AnyTransitionDefinition>;
-/**
- * https://www.w3.org/TR/scxml/#microstepProcedure
- */
+/** https://www.w3.org/TR/scxml/#microstepProcedure */
 export declare function microstep<TContext extends MachineContext, TEvent extends EventObject>(transitions: Array<AnyTransitionDefinition>, currentSnapshot: AnyMachineSnapshot, actorScope: AnyActorScope, event: AnyEventObject, isInitial: boolean, internalQueue: Array<AnyEventObject>): AnyMachineSnapshot;
 export declare let executingCustomAction: ActionFunction<any, any, any, any, any, any, any, any, any> | false;
 export declare function resolveActionsAndContext(currentSnapshot: AnyMachineSnapshot, event: AnyEventObject, actorScope: AnyActorScope, actions: UnknownAction[], internalQueue: AnyEventObject[], deferredActorIds?: string[]): AnyMachineSnapshot;
@@ -53,7 +47,8 @@ export declare function macrostep(snapshot: AnyMachineSnapshot, event: EventObje
     microstates: Array<typeof snapshot>;
 };
 /**
- * Resolves a partial state value with its full representation in the state node's machine.
+ * Resolves a partial state value with its full representation in the state
+ * node's machine.
  *
  * @param stateValue The partial state value to resolve.
  */