xstate 5.0.0-beta.44 → 5.0.0-beta.46

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

@@ -1,10 +1,10 @@
 import { MachineSnapshot } from "./State.js";
 import { StateNode } from "./StateNode.js";
 import type { AreAllImplementationsAssumedToBeProvided, MarkAllImplementationsAsProvided, ResolveTypegenMeta, TypegenDisabled } from "./typegenTypes.js";
-import type { ActorScope, ActorLogic, EventObject, InternalMachineImplementations, MachineConfig, MachineContext, MachineImplementationsSimplified, MachineTypes, NoInfer, StateMachineDefinition, StateValue, TransitionDefinition, ParameterizedObject, AnyActorScope, ProvidedActor, Equals, TODO, Snapshot, HistoryValue } from "./types.js";
+import type { ActorScope, ActorLogic, EventObject, InternalMachineImplementations, MachineConfig, MachineContext, MachineImplementationsSimplified, MachineTypes, NoInfer, StateMachineDefinition, StateValue, TransitionDefinition, ParameterizedObject, AnyActorScope, ProvidedActor, AnyActorRef, Equals, TODO, Snapshot, HistoryValue } from "./types.js";
 export declare const STATE_IDENTIFIER = "#";
 export declare const WILDCARD = "*";
-export declare class StateMachine<TContext extends MachineContext, TEvent extends EventObject, TActor extends ProvidedActor, TAction extends ParameterizedObject, TGuard extends ParameterizedObject, TDelay extends string, TTag extends string, TInput, TOutput, TResolvedTypesMeta = ResolveTypegenMeta<TypegenDisabled, NoInfer<TEvent>, TActor, TAction, TGuard, TDelay, TTag>> implements ActorLogic<MachineSnapshot<TContext, TEvent, TActor, TTag, TOutput, TResolvedTypesMeta>, TEvent, TInput, TODO> {
+export declare class StateMachine<TContext extends MachineContext, TEvent extends EventObject, TChildren extends Record<string, AnyActorRef | undefined>, TActor extends ProvidedActor, TAction extends ParameterizedObject, TGuard extends ParameterizedObject, TDelay extends string, TTag extends string, TInput, TOutput, TResolvedTypesMeta = ResolveTypegenMeta<TypegenDisabled, NoInfer<TEvent>, TActor, TAction, TGuard, TDelay, TTag>> implements ActorLogic<MachineSnapshot<TContext, TEvent, TChildren, TTag, TOutput, TResolvedTypesMeta>, TEvent, TInput, TODO> {
     /**
      * The raw config used to create the machine.
      */
@@ -35,7 +35,7 @@ export declare class StateMachine<TContext extends MachineContext, TEvent extend
      *
      * @returns A new `StateMachine` instance with the provided implementations.
      */
-    provide(implementations: InternalMachineImplementations<TContext, TEvent, TActor, TAction, TDelay, TResolvedTypesMeta, true>): StateMachine<TContext, TEvent, TActor, TAction, TGuard, TDelay, TTag, TInput, TOutput, AreAllImplementationsAssumedToBeProvided<TResolvedTypesMeta> extends false ? MarkAllImplementationsAsProvided<TResolvedTypesMeta> : TResolvedTypesMeta>;
+    provide(implementations: InternalMachineImplementations<TContext, TResolvedTypesMeta, true>): StateMachine<TContext, TEvent, TChildren, TActor, TAction, TGuard, TDelay, TTag, TInput, TOutput, AreAllImplementationsAssumedToBeProvided<TResolvedTypesMeta> extends false ? MarkAllImplementationsAsProvided<TResolvedTypesMeta> : TResolvedTypesMeta>;
     resolveState(config: {
         value: StateValue;
         context?: TContext;
@@ -45,7 +45,7 @@ export declare class StateMachine<TContext extends MachineContext, TEvent extend
         error?: unknown;
     } & (Equals<TContext, MachineContext> extends false ? {
         context: unknown;
-    } : {})): MachineSnapshot<TContext, TEvent, TActor, TTag, TOutput, TResolvedTypesMeta>;
+    } : {})): MachineSnapshot<TContext, TEvent, TChildren, TTag, TOutput, TResolvedTypesMeta>;
     /**
      * Determines the next state given the current `state` and received `event`.
      * Calculates a full macrostep from all microsteps.
@@ -53,7 +53,7 @@ export declare class StateMachine<TContext extends MachineContext, TEvent extend
      * @param state The current State instance or state value
      * @param event The received event
      */
-    transition(state: MachineSnapshot<TContext, TEvent, TActor, TTag, TOutput, TResolvedTypesMeta>, event: TEvent, actorScope: ActorScope<typeof state, TEvent>): MachineSnapshot<TContext, TEvent, TActor, TTag, TOutput, TResolvedTypesMeta>;
+    transition(state: MachineSnapshot<TContext, TEvent, TChildren, TTag, TOutput, TResolvedTypesMeta>, event: TEvent, actorScope: ActorScope<typeof state, TEvent>): MachineSnapshot<TContext, TEvent, TChildren, TTag, TOutput, TResolvedTypesMeta>;
     /**
      * Determines the next state given the current `state` and `event`.
      * Calculates a microstep.
@@ -61,8 +61,8 @@ export declare class StateMachine<TContext extends MachineContext, TEvent extend
      * @param state The current state
      * @param event The received event
      */
-    microstep(state: MachineSnapshot<TContext, TEvent, TActor, TTag, TOutput, TResolvedTypesMeta>, event: TEvent, actorScope: AnyActorScope): Array<MachineSnapshot<TContext, TEvent, TActor, TTag, TOutput, TResolvedTypesMeta>>;
-    getTransitionData(state: MachineSnapshot<TContext, TEvent, TActor, TTag, TOutput, TResolvedTypesMeta>, event: TEvent): Array<TransitionDefinition<TContext, TEvent>>;
+    microstep(state: MachineSnapshot<TContext, TEvent, TChildren, TTag, TOutput, TResolvedTypesMeta>, event: TEvent, actorScope: AnyActorScope): Array<MachineSnapshot<TContext, TEvent, TChildren, TTag, TOutput, TResolvedTypesMeta>>;
+    getTransitionData(state: MachineSnapshot<TContext, TEvent, TChildren, TTag, TOutput, TResolvedTypesMeta>, event: TEvent): Array<TransitionDefinition<TContext, TEvent>>;
     /**
      * The initial state _before_ evaluating any microsteps.
      * This "pre-initial" state is provided to initial actions executed in the initial state.
@@ -71,31 +71,13 @@ export declare class StateMachine<TContext extends MachineContext, TEvent extend
     /**
      * Returns the initial `State` instance, with reference to `self` as an `ActorRef`.
      */
-    getInitialState(actorScope: ActorScope<MachineSnapshot<TContext, TEvent, TActor, TTag, TOutput, TResolvedTypesMeta>, TEvent>, input?: TInput): MachineSnapshot<TContext, TEvent, TActor, TTag, TOutput, TResolvedTypesMeta>;
-    start(state: MachineSnapshot<TContext, TEvent, TActor, TTag, TOutput, TResolvedTypesMeta>): void;
+    getInitialState(actorScope: ActorScope<MachineSnapshot<TContext, TEvent, TChildren, TTag, TOutput, TResolvedTypesMeta>, TEvent>, input?: TInput): MachineSnapshot<TContext, TEvent, TChildren, TTag, TOutput, TResolvedTypesMeta>;
+    start(state: MachineSnapshot<TContext, TEvent, TChildren, TTag, TOutput, TResolvedTypesMeta>): void;
     getStateNodeById(stateId: string): StateNode<TContext, TEvent>;
     get definition(): StateMachineDefinition<TContext, TEvent>;
     toJSON(): StateMachineDefinition<TContext, TEvent>;
-    getPersistedState(state: MachineSnapshot<TContext, TEvent, TActor, TTag, TOutput, TResolvedTypesMeta>, options?: unknown): Snapshot<unknown>;
-    restoreState(snapshot: Snapshot<unknown>, _actorScope: ActorScope<MachineSnapshot<TContext, TEvent, TActor, TTag, TOutput, TResolvedTypesMeta>, TEvent>): MachineSnapshot<TContext, TEvent, TActor, TTag, TOutput, TResolvedTypesMeta>;
-    /**@deprecated an internal property acting as a "phantom" type, not meant to be used at runtime */
-    __TContext: TContext;
-    /** @deprecated an internal property acting as a "phantom" type, not meant to be used at runtime */
-    __TEvent: TEvent;
-    /** @deprecated an internal property acting as a "phantom" type, not meant to be used at runtime */
-    __TActor: TActor;
-    /** @deprecated an internal property acting as a "phantom" type, not meant to be used at runtime */
-    __TAction: TAction;
-    /** @deprecated an internal property acting as a "phantom" type, not meant to be used at runtime */
-    __TGuard: TGuard;
-    /** @deprecated an internal property acting as a "phantom" type, not meant to be used at runtime */
-    __TDelay: TDelay;
-    /** @deprecated an internal property acting as a "phantom" type, not meant to be used at runtime */
-    __TTag: TTag;
-    /** @deprecated an internal property acting as a "phantom" type, not meant to be used at runtime */
-    __TInput: TInput;
-    /** @deprecated an internal property acting as a "phantom" type, not meant to be used at runtime */
-    __TOutput: TOutput;
+    getPersistedState(state: MachineSnapshot<TContext, TEvent, TChildren, TTag, TOutput, TResolvedTypesMeta>, options?: unknown): Snapshot<unknown>;
+    restoreState(snapshot: Snapshot<unknown>, _actorScope: ActorScope<MachineSnapshot<TContext, TEvent, TChildren, TTag, TOutput, TResolvedTypesMeta>, TEvent>): MachineSnapshot<TContext, TEvent, TChildren, TTag, TOutput, TResolvedTypesMeta>;
     /** @deprecated an internal property acting as a "phantom" type, not meant to be used at runtime */
     __TResolvedTypesMeta: TResolvedTypesMeta;
 }

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

@@ -64,13 +64,15 @@ export declare class StateNode<TContext extends MachineContext = MachineContext,
     /**
      * The root machine node.
      */
-    machine: StateMachine<TContext, TEvent, any, // actors
+    machine: StateMachine<TContext, TEvent, any, // children
+    any, // actor
+    any, // action
+    any, // guard
+    any, // delay
+    any, // tag
     any, // input
-    TODO, // output
-    TODO, // guards
-    TODO, // delays
-    TODO, // tags
-    TODO>;
+    any, // output
+    any>;
     /**
      * The meta data associated with this state node, which will be returned in State instances.
      */

package/dist/declarations/src/actions/choose.d.ts

@@ -1,9 +1,9 @@
 import { EventObject, ChooseBranch, MachineContext, ActionArgs, ParameterizedObject, NoInfer, ProvidedActor } from "../types.js";
-export interface ChooseAction<TContext extends MachineContext, TExpressionEvent extends EventObject, TParams extends ParameterizedObject['params'] | undefined, TEvent extends EventObject, TActor extends ProvidedActor, TAction extends ParameterizedObject, TGuard extends ParameterizedObject, TDelay extends string> {
-    (args: ActionArgs<TContext, TExpressionEvent, TEvent>, params: TParams): void;
+export interface ChooseAction<TContext extends MachineContext, TExpressionEvent extends EventObject, TEvent extends EventObject, TActor extends ProvidedActor, TAction extends ParameterizedObject, TGuard extends ParameterizedObject, TDelay extends string> {
+    (args: ActionArgs<TContext, TExpressionEvent, TEvent>, params: unknown): void;
     _out_TActor?: TActor;
     _out_TAction?: TAction;
     _out_TGuard?: TGuard;
     _out_TDelay?: TDelay;
 }
-export declare function choose<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>(branches: ReadonlyArray<ChooseBranch<TContext, TExpressionEvent, TEvent, TActor, NoInfer<TAction>, NoInfer<TGuard>, TDelay>>): ChooseAction<TContext, TExpressionEvent, TParams, TEvent, TActor, TAction, TGuard, TDelay>;
+export declare function choose<TContext extends MachineContext, TExpressionEvent extends EventObject, TEvent extends EventObject, TActor extends ProvidedActor, TAction extends ParameterizedObject, TGuard extends ParameterizedObject, TDelay extends string>(branches: ReadonlyArray<ChooseBranch<TContext, TExpressionEvent, TEvent, TActor, NoInfer<TAction>, NoInfer<TGuard>, TDelay>>): ChooseAction<TContext, TExpressionEvent, TEvent, TActor, TAction, TGuard, TDelay>;

package/dist/declarations/src/actions/pure.d.ts

@@ -1,13 +1,13 @@
 import { Actions, ActionArgs, EventObject, MachineContext, ParameterizedObject, NoInfer, ProvidedActor } from "../types.js";
-export interface PureAction<TContext extends MachineContext, TExpressionEvent extends EventObject, TParams extends ParameterizedObject['params'] | undefined, TEvent extends EventObject, TActor extends ProvidedActor, TAction extends ParameterizedObject, TGuard extends ParameterizedObject, TDelay extends string> {
-    (args: ActionArgs<TContext, TExpressionEvent, TEvent>, params: TParams): void;
+export interface PureAction<TContext extends MachineContext, TExpressionEvent extends EventObject, TEvent extends EventObject, TActor extends ProvidedActor, TAction extends ParameterizedObject, TGuard extends ParameterizedObject, TDelay extends string> {
+    (args: ActionArgs<TContext, TExpressionEvent, TEvent>, params: unknown): void;
     _out_TEvent?: TEvent;
     _out_TActor?: TActor;
     _out_TAction?: TAction;
     _out_TGuard?: TGuard;
     _out_TDelay?: TDelay;
 }
-export declare function pure<TContext extends MachineContext, TExpressionEvent extends EventObject, TParams extends ParameterizedObject['params'] | undefined = ParameterizedObject['params'] | undefined, TEvent extends EventObject = TExpressionEvent, TActor extends ProvidedActor = ProvidedActor, TAction extends ParameterizedObject = ParameterizedObject, TGuard extends ParameterizedObject = ParameterizedObject, TDelay extends string = string>(getActions: ({ context, event }: {
+export declare function pure<TContext extends MachineContext, TExpressionEvent extends EventObject, TEvent extends EventObject = TExpressionEvent, TActor extends ProvidedActor = ProvidedActor, TAction extends ParameterizedObject = ParameterizedObject, TGuard extends ParameterizedObject = ParameterizedObject, TDelay extends string = string>(getActions: ({ context, event }: {
     context: TContext;
     event: TExpressionEvent;
-}) => Actions<TContext, TExpressionEvent, NoInfer<TEvent>, undefined, TActor, NoInfer<TAction>, NoInfer<TGuard>, TDelay> | undefined): PureAction<TContext, TExpressionEvent, TParams, TEvent, TActor, TAction, TGuard, TDelay>;
+}) => Actions<TContext, TExpressionEvent, NoInfer<TEvent>, undefined, TActor, NoInfer<TAction>, NoInfer<TGuard>, TDelay> | undefined): PureAction<TContext, TExpressionEvent, TEvent, TActor, TAction, TGuard, TDelay>;

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

@@ -9,18 +9,94 @@ export type ObservableActorLogic<TContext, TInput> = ActorLogic<ObservableSnapsh
     [k: string]: unknown;
 }, TInput, AnyActorSystem>;
 export type ObservableActorRef<TContext> = ActorRefFrom<ObservableActorLogic<TContext, any>>;
+/**
+ * Observable actor logic is described by an observable stream of values. Actors created from observable logic (“observable actors”) can:
+ *
+ * - Emit snapshots of the observable’s emitted value
+ *
+ * The observable’s emitted value is used as its observable actor’s `context`.
+ *
+ * Sending events to observable actors will have no effect.
+ *
+ * @param observableCreator A function that creates an observable. It receives one argument, an object with the following properties:
+ * - `input` - Data that was provided to the observable actor
+ * - `self` - The parent actor
+ * - `system` - The actor system to which the observable actor belongs
+ *
+ * It should return a {@link Subscribable}, which is compatible with an RxJS Observable, although RxJS is not required to create them.
+ *
+ * @example
+ * ```ts
+ * import { fromObservable, createActor } from 'xstate'
+ * import { interval } from 'rxjs';
+ *
+ * const logic = fromObservable((obj) => interval(1000));
+ *
+ * const actor = createActor(logic);
+ *
+ * actor.subscribe((snapshot) => {
+ *   console.log(snapshot.context);
+ * });
+ *
+ * actor.start();
+ * // At every second:
+ * // Logs 0
+ * // Logs 1
+ * // Logs 2
+ * // ...
+ * ```
+ *
+ * @see {@link https://rxjs.dev} for documentation on RxJS Observable and observable creators.
+ * @see {@link Subscribable} interface in XState, which is based on and compatible with RxJS Observable.
+ */
 export declare function fromObservable<TContext, TInput>(observableCreator: ({ input, system }: {
     input: TInput;
     system: AnyActorSystem;
     self: ObservableActorRef<TContext>;
 }) => Subscribable<TContext>): ObservableActorLogic<TContext, TInput>;
 /**
- * Creates event observable logic that listens to an observable
- * that delivers event objects.
+ * Creates event observable logic that listens to an observable that delivers event objects.
+ *
+ * Event observable actor logic is described by an observable stream of {@link https://stately.ai/docs/transitions#event-objects | event objects}. Actors created from event observable logic (“event observable actors”) can:
+ *
+ * - Implicitly send events to its parent actor
+ * - Emit snapshots of its emitted event objects
+ *
+ * Sending events to event observable actors will have no effect.
+ *
+ * @param lazyObservable A function that creates an observable that delivers event objects. It receives one argument, an object with the following properties:
+ *
+ * - `input` - Data that was provided to the event observable actor
+ * - `self` - The parent actor
+ * - `system` - The actor system to which the event observable actor belongs.
+ *
+ * It should return a {@link Subscribable}, which is compatible with an RxJS Observable, although RxJS is not required to create them.
+ *
+ * @example
+ * ```ts
+ * import {
+ *   fromEventObservable,
+ *   Subscribable,
+ *   EventObject,
+ *   createMachine,
+ *   createActor
+ * } from 'xstate';
+ * import { fromEvent } from 'rxjs';
+ *
+ * const mouseClickLogic = fromEventObservable(() =>
+ *   fromEvent(document.body, 'click') as Subscribable<EventObject>
+ * );
  *
+ * const canvasMachine = createMachine({
+ *   invoke: {
+ *     // Will send mouse `click` events to the canvas actor
+ *     src: mouseClickLogic,
+ *   }
+ * });
  *
- * @param lazyObservable A function that creates an observable
- * @returns Event observable logic
+ * const canvasActor = createActor(canvasMachine);
+ * canvasActor.start();
+ * ```
  */
 export declare function fromEventObservable<T extends EventObject, TInput>(lazyObservable: ({ input, system }: {
     input: TInput;

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/createMachine.d.ts

@@ -0,0 +1,5 @@
+import { StateMachine } from "./StateMachine.js";
+import { ResolveTypegenMeta, TypegenConstraint, TypegenDisabled } from "./typegenTypes.js";
+import { AnyActorRef, AnyEventObject, Cast, InternalMachineImplementations, MachineConfig, MachineContext, NonReducibleUnknown, ParameterizedObject, Prop, ProvidedActor, ToChildren } from "./types.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, ResolveTypegenMeta<TTypesMeta, TEvent, TActor, TAction, TGuard, TDelay, TTag>>): StateMachine<TContext, TEvent, Cast<ToChildren<TActor>, Record<string, AnyActorRef | undefined>>, 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, AnyMachineSnapshot, 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 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";
+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 { matchesState, pathToStateValue, toObserver, getAllOwnEventDescriptors as __unsafe_getAllOwnEventDescriptors } 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,35 @@
+import { StateMachine } from "./StateMachine.js";
+import { GuardPredicate } from "./guards.js";
+import { ResolveTypegenMeta, TypegenDisabled } from "./typegenTypes.js";
+import { ActionFunction, AnyActorLogic, AnyActorRef, AnyEventObject, Cast, DelayConfig, Invert, IsNever, MachineConfig, MachineContext, NonReducibleUnknown, ParameterizedObject, SetupTypes, ToChildren, Values } from "./types.js";
+type ToParameterizedObject<TParameterizedMap extends Record<string, ParameterizedObject['params'] | undefined>> = Values<{
+    [K in keyof TParameterizedMap & string]: {
+        type: K;
+        params: TParameterizedMap[K];
+    };
+}>;
+type DefaultToAnyActors<TActors extends Record<string, AnyActorLogic>> = IsNever<keyof TActors> extends true ? Record<string, AnyActorLogic> : TActors;
+type ToProvidedActor<TChildrenMap extends Record<string, string>, TActors extends Record<Values<TChildrenMap>, AnyActorLogic>> = Values<{
+    [K in keyof DefaultToAnyActors<TActors> & string]: {
+        src: K;
+        logic: TActors[K];
+        id: IsNever<TChildrenMap> extends true ? string | undefined : K extends keyof Invert<TChildrenMap> ? Invert<TChildrenMap>[K] : string | undefined;
+    };
+}>;
+export declare function setup<TContext extends MachineContext, TEvent extends AnyEventObject, // TODO: consider using a stricter `EventObject` here
+TActors extends Record<Values<TChildrenMap>, 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, TChildrenMap extends Record<string, string> = never>({ actors, actions, guards, delays }: {
+    types?: SetupTypes<TContext, TEvent, TChildrenMap, TTag, TInput, TOutput>;
+    actors?: TActors;
+    actions?: {
+        [K in keyof TActions]: ActionFunction<TContext, TEvent, TEvent, TActions[K], ToProvidedActor<TChildrenMap, 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: <const TConfig extends MachineConfig<TContext, TEvent, ToProvidedActor<TChildrenMap, TActors>, ToParameterizedObject<TActions>, ToParameterizedObject<TGuards>, TDelay, TTag, TInput, TOutput, ResolveTypegenMeta<TypegenDisabled, TEvent, ToProvidedActor<TChildrenMap, TActors>, ToParameterizedObject<TActions>, ToParameterizedObject<TGuards>, TDelay, TTag>>>(config: TConfig) => StateMachine<TContext, TEvent, Cast<ToChildren<ToProvidedActor<TChildrenMap, TActors>>, Record<string, AnyActorRef | undefined>>, ToProvidedActor<TChildrenMap, TActors>, ToParameterizedObject<TActions>, ToParameterizedObject<TGuards>, TDelay, TTag, TInput, TOutput, ResolveTypegenMeta<TypegenDisabled, TEvent, ToProvidedActor<TChildrenMap, TActors>, ToParameterizedObject<TActions>, ToParameterizedObject<TGuards>, TDelay, TTag>>;
+};
+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, AnyMachineSnapshot, 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>;
+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,7 +41,7 @@ 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
  */