xstate 5.32.2 → 6.0.0-alpha.10

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

@@ -1,15 +1,8 @@
-import type { StateNode } from "./StateNode.js";
-import type { StateMachine } from "./StateMachine.js";
-import type { ProvidedActor, AnyMachineSnapshot, AnyStateMachine, EventObject, HistoryValue, MachineContext, StateConfig, StateValue, AnyActorRef, Snapshot, ParameterizedObject, IsNever, MetaObject, StateSchema, StateId, SnapshotStatus } from "./types.js";
-type ToTestStateValue<TStateValue extends StateValue> = TStateValue extends string ? TStateValue : IsNever<keyof TStateValue> extends true ? never : keyof TStateValue | {
-    [K in keyof TStateValue]?: ToTestStateValue<NonNullable<TStateValue[K]>>;
-};
+import type { AnyMachineSnapshot, AnyStateMachine, EventObject, HistoryValue, MachineContext, StateConfig, StateValue, AnyActorRef, Snapshot, MetaObject, StateSchema, StateId, StateIdInputs, StateContextFromStateValue, SnapshotStatus, AnyStateNode } from "./types.js";
 export declare function isMachineSnapshot(value: unknown): value is AnyMachineSnapshot;
-interface MachineSnapshotBase<TContext extends MachineContext, TEvent extends EventObject, TChildren extends Record<string, AnyActorRef | undefined>, TStateValue extends StateValue, TTag extends string, TOutput, TMeta, TStateSchema extends StateSchema = StateSchema> {
+interface MachineSnapshotBase<TContext extends MachineContext, TEvent extends EventObject, TChildren extends Record<string, AnyActorRef | undefined>, TStateValue extends StateValue, TTag extends string, _TOutput, TMeta extends MetaObject, TStateSchema extends StateSchema = StateSchema> {
     /** The state machine that produced this state snapshot. */
-    machine: StateMachine<TContext, TEvent, TChildren, ProvidedActor, ParameterizedObject, ParameterizedObject, string, TStateValue, TTag, unknown, TOutput, EventObject, // TEmitted
-    any, // TMeta
-    TStateSchema>;
+    machine: AnyStateMachine;
     /** The tags of the active state nodes that represent the current state value. */
     tags: Set<string>;
     /**
@@ -38,9 +31,9 @@ interface MachineSnapshotBase<TContext extends MachineContext, TEvent extends Ev
     status: SnapshotStatus;
     error: unknown;
     context: TContext;
-    historyValue: Readonly<HistoryValue<TContext, TEvent>>;
+    historyValue: Readonly<HistoryValue>;
     /** The enabled state nodes representative of the state value. */
-    _nodes: Array<StateNode<TContext, TEvent>>;
+    _nodes: Array<AnyStateNode>;
     /** An object mapping actor names to spawned/invoked actors. */
     children: TChildren;
     /**
@@ -49,7 +42,7 @@ interface MachineSnapshotBase<TContext extends MachineContext, TEvent extends Ev
      *
      * @param partialStateValue
      */
-    matches: (partialStateValue: ToTestStateValue<TStateValue>) => boolean;
+    matches<const TTestStateValue extends StateValue>(partialStateValue: TTestStateValue): this is MachineSnapshot<StateContextFromStateValue<TStateSchema, TContext, TTestStateValue>, TEvent, TChildren, TStateValue, TTag, _TOutput, TMeta, TStateSchema>;
     /**
      * Whether the current state nodes has a state node with the specified `tag`.
      *
@@ -66,6 +59,11 @@ interface MachineSnapshotBase<TContext extends MachineContext, TEvent extends Ev
      */
     can: (event: TEvent) => boolean;
     getMeta: () => Record<StateId<TStateSchema> & string, TMeta | undefined>;
+    /**
+     * Returns the inputs for the current active state nodes, keyed by state node
+     * id.
+     */
+    getInputs: () => StateIdInputs<TStateSchema>;
     toJSON: () => unknown;
 }
 interface ActiveMachineSnapshot<TContext extends MachineContext, TEvent extends EventObject, TChildren extends Record<string, AnyActorRef | undefined>, TStateValue extends StateValue, TTag extends string, TOutput, TMeta extends MetaObject, TStateSchema extends StateSchema> extends MachineSnapshotBase<TContext, TEvent, TChildren, TStateValue, TTag, TOutput, TMeta, TStateSchema> {

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

@@ -1,47 +1,60 @@
 import { MachineSnapshot } from "./State.js";
 import { StateNode } from "./StateNode.js";
 import { AnyActorSystem } from "./system.js";
-import type { ActorLogic, ActorScope, AnyActorRef, AnyActorScope, DoNotInfer, Equals, EventDescriptor, EventObject, HistoryValue, InternalMachineImplementations, MachineConfig, MachineContext, MachineImplementationsSimplified, MachineOptions, MetaObject, ParameterizedObject, ProvidedActor, Snapshot, StateMachineDefinition, StateValue, TransitionDefinition, ResolvedStateMachineTypes, StateSchema, SnapshotStatus } from "./types.js";
-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, TStateValue extends StateValue, TTag extends string, TInput, TOutput, TEmitted extends EventObject, TMeta extends MetaObject, TStateSchema extends StateSchema> implements ActorLogic<MachineSnapshot<TContext, TEvent, TChildren, TStateValue, TTag, TOutput, TMeta, TStateSchema>, TEvent, TInput, AnyActorSystem, TEmitted> {
+import type { ActorLogic, ActorLogicTransitionResult, ActorScope, AnyActor, AnyActorLogic, AnyActorRef, AnyActorScope, AnyTransitionDefinition, Equals, EventDescriptor, EmittedFrom, EventObject, EventFromLogic, ExecutableActionObjectFromLogic, HistoryValue, InputFrom, IsAny, MachineContext, MetaObject, OutputFrom, Snapshot, SnapshotFrom, StateValue, StateSchema, SnapshotStatus } from "./types.js";
+import { AnyMachineSchemas, Implementations, Next_MachineConfig, MachineOptions } from "./types.v6.js";
+type CompatibleProvidedActorSource<TExpected extends AnyActorLogic, TActual extends AnyActorLogic> = IsAny<TActual> extends true ? TActual : [OutputFrom<TActual>] extends [OutputFrom<TExpected>] ? [Omit<SnapshotFrom<TActual>, 'input'>] extends [
+    Omit<SnapshotFrom<TExpected>, 'input'>
+] ? [InputFrom<TExpected>] extends [InputFrom<TActual>] ? [EventFromLogic<TExpected>] extends [EventFromLogic<TActual>] ? [EmittedFrom<TActual>] extends [EmittedFrom<TExpected>] ? TActual : never : never : never : never : never;
+type ProvidedActorSources<TExpectedActorMap extends Implementations['actorSources'], TProvidedActorMap extends Partial<Record<keyof TExpectedActorMap & string, AnyActorLogic>>> = {
+    [K in keyof TProvidedActorMap]: K extends keyof TExpectedActorMap ? TProvidedActorMap[K] extends AnyActorLogic ? CompatibleProvidedActorSource<TExpectedActorMap[K], TProvidedActorMap[K]> : never : never;
+};
+export declare class StateMachine<TContext extends MachineContext, TEvent extends EventObject, TChildren extends Record<string, AnyActorRef | undefined>, TStateValue extends StateValue, TTag extends string, TInput, TOutput, TEmitted extends EventObject, TMeta extends MetaObject, TConfig extends StateSchema, TActionMap extends Implementations['actions'], TActorMap extends Implementations['actorSources'], TGuardMap extends Implementations['guards'], TDelayMap extends Implementations['delays']> implements ActorLogic<MachineSnapshot<TContext, TEvent, TChildren, TStateValue, TTag, TOutput, TMeta, TConfig>, TEvent, TInput, AnyActorSystem, TEmitted> {
     /** The raw config used to create the machine. */
-    config: MachineConfig<TContext, TEvent, any, any, any, any, any, any, TOutput, any, // TEmitted
-    any> & {
-        schemas?: unknown;
+    config: Next_MachineConfig<any, any, any, any, any, any, any, any, any, any, any> & {
+        schemas?: AnyMachineSchemas;
+        internalEvents?: readonly string[];
     };
     /** The machine's own version. */
     version?: string;
-    schemas: unknown;
-    implementations: MachineImplementationsSimplified<TContext, TEvent>;
+    schemas: AnyMachineSchemas | undefined;
+    implementations: Implementations;
     /** Runtime options for machine execution. */
     options: MachineOptions;
     root: StateNode<TContext, TEvent>;
     id: string;
     states: StateNode<TContext, TEvent>['states'];
     events: Array<EventDescriptor<TEvent>>;
+    internalEventDescriptors: ReadonlyArray<string>;
     constructor(
     /** The raw config used to create the machine. */
-    config: MachineConfig<TContext, TEvent, any, any, any, any, any, any, TOutput, any, // TEmitted
-    any> & {
-        schemas?: unknown;
-    }, implementations?: MachineImplementationsSimplified<TContext, TEvent>);
+    config: Next_MachineConfig<any, any, any, any, any, any, any, any, any, any, any> & {
+        schemas?: AnyMachineSchemas;
+        internalEvents?: readonly string[];
+    }, implementations?: Implementations);
     /**
      * Clones this state machine with the provided implementations.
      *
-     * @param implementations Options (`actions`, `guards`, `actors`, `delays`) to
-     *   recursively merge with the existing options.
+     * @param implementations Options (`actions`, `guards`, `actorSources`,
+     *   `delays`) to recursively merge with the existing options.
      * @returns A new `StateMachine` instance with the provided implementations.
      */
-    provide(implementations: InternalMachineImplementations<ResolvedStateMachineTypes<TContext, DoNotInfer<TEvent>, TActor, TAction, TGuard, TDelay, TTag, TEmitted>>): StateMachine<TContext, TEvent, TChildren, TActor, TAction, TGuard, TDelay, TStateValue, TTag, TInput, TOutput, TEmitted, TMeta, TStateSchema>;
+    provide<const TProvidedActorMap extends Partial<Record<keyof TActorMap & string, AnyActorLogic>> = {}>(implementations: {
+        actions?: Partial<TActionMap>;
+        actorSources?: TProvidedActorMap & ProvidedActorSources<TActorMap, TProvidedActorMap>;
+        guards?: Partial<TGuardMap>;
+        delays?: Partial<TDelayMap>;
+    }): StateMachine<TContext, TEvent, TChildren, TStateValue, TTag, TInput, TOutput, TEmitted, TMeta, TConfig, TActionMap, TActorMap, TGuardMap, TDelayMap>;
     resolveState(config: {
         value: StateValue;
         context?: TContext;
-        historyValue?: HistoryValue<TContext, TEvent>;
+        historyValue?: HistoryValue;
         status?: SnapshotStatus;
         output?: TOutput;
         error?: unknown;
-    } & (Equals<TContext, MachineContext> extends false ? {
+    } & ([TContext] extends [never] ? {} : Equals<TContext, MachineContext> extends false ? {
         context: unknown;
-    } : {})): MachineSnapshot<TContext, TEvent, TChildren, TStateValue, TTag, TOutput, TMeta, TStateSchema>;
+    } : {})): MachineSnapshot<TContext, TEvent, TChildren, TStateValue, TTag, TOutput, TMeta, TConfig>;
     /**
      * Determines the next snapshot given the current `snapshot` and received
      * `event`. Calculates a full macrostep from all microsteps.
@@ -49,7 +62,7 @@ export declare class StateMachine<TContext extends MachineContext, TEvent extend
      * @param snapshot The current snapshot
      * @param event The received event
      */
-    transition(snapshot: MachineSnapshot<TContext, TEvent, TChildren, TStateValue, TTag, TOutput, TMeta, TStateSchema>, event: TEvent, actorScope: ActorScope<typeof snapshot, TEvent, AnyActorSystem, TEmitted>): MachineSnapshot<TContext, TEvent, TChildren, TStateValue, TTag, TOutput, TMeta, TStateSchema>;
+    transition(snapshot: MachineSnapshot<TContext, TEvent, TChildren, TStateValue, TTag, TOutput, TMeta, TConfig>, event: TEvent, actorScope: ActorScope<typeof snapshot, TEvent, AnyActorSystem, TEmitted>): ActorLogicTransitionResult<MachineSnapshot<TContext, TEvent, TChildren, TStateValue, TTag, TOutput, TMeta, TConfig>, ExecutableActionObjectFromLogic<this>>;
     /**
      * Determines the next state given the current `state` and `event`. Calculates
      * a microstep.
@@ -57,17 +70,18 @@ export declare class StateMachine<TContext extends MachineContext, TEvent extend
      * @param state The current state
      * @param event The received event
      */
-    microstep(snapshot: MachineSnapshot<TContext, TEvent, TChildren, TStateValue, TTag, TOutput, TMeta, TStateSchema>, event: TEvent, actorScope: AnyActorScope): Array<MachineSnapshot<TContext, TEvent, TChildren, TStateValue, TTag, TOutput, TMeta, TStateSchema>>;
-    getTransitionData(snapshot: MachineSnapshot<TContext, TEvent, TChildren, TStateValue, TTag, TOutput, TMeta, TStateSchema>, event: TEvent): Array<TransitionDefinition<TContext, TEvent>>;
+    microstep(snapshot: MachineSnapshot<TContext, TEvent, TChildren, TStateValue, TTag, TOutput, TMeta, TConfig>, event: TEvent, actorScope: AnyActorScope): Array<MachineSnapshot<TContext, TEvent, TChildren, TStateValue, TTag, TOutput, TMeta, TConfig>>;
+    getTransitionData(snapshot: MachineSnapshot<TContext, TEvent, TChildren, TStateValue, TTag, TOutput, TMeta, TConfig>, event: TEvent, self: AnyActor): Array<AnyTransitionDefinition>;
+    isInternalEventType(eventType: string): boolean;
     /**
      * Returns the initial `State` instance, with reference to `self` as an
      * `ActorRef`.
      */
-    getInitialSnapshot(actorScope: ActorScope<MachineSnapshot<TContext, TEvent, TChildren, TStateValue, TTag, TOutput, TMeta, TStateSchema>, TEvent, AnyActorSystem, TEmitted>, input?: TInput): MachineSnapshot<TContext, TEvent, TChildren, TStateValue, TTag, TOutput, TMeta, TStateSchema>;
-    start(snapshot: MachineSnapshot<TContext, TEvent, TChildren, TStateValue, TTag, TOutput, TMeta, TStateSchema>): void;
+    getInitialSnapshot(actorScope: ActorScope<MachineSnapshot<TContext, TEvent, TChildren, TStateValue, TTag, TOutput, TMeta, TConfig>, TEvent, AnyActorSystem, TEmitted>, input?: TInput): MachineSnapshot<TContext, TEvent, TChildren, TStateValue, TTag, TOutput, TMeta, TConfig>;
+    initialTransition(input: TInput | undefined, actorScope: ActorScope<MachineSnapshot<TContext, TEvent, TChildren, TStateValue, TTag, TOutput, TMeta, TConfig>, TEvent, AnyActorSystem, TEmitted>): ActorLogicTransitionResult<MachineSnapshot<TContext, TEvent, TChildren, TStateValue, TTag, TOutput, TMeta, TConfig>, ExecutableActionObjectFromLogic<this>>;
+    start(snapshot?: MachineSnapshot<TContext, TEvent, TChildren, TStateValue, TTag, TOutput, TMeta, TConfig>): void;
     getStateNodeById(stateId: string): StateNode<TContext, TEvent>;
-    get definition(): StateMachineDefinition<TContext, TEvent>;
-    toJSON(): StateMachineDefinition<TContext, TEvent>;
-    getPersistedSnapshot(snapshot: MachineSnapshot<TContext, TEvent, TChildren, TStateValue, TTag, TOutput, TMeta, TStateSchema>, options?: unknown): Snapshot<unknown>;
-    restoreSnapshot(snapshot: Snapshot<unknown>, _actorScope: ActorScope<MachineSnapshot<TContext, TEvent, TChildren, TStateValue, TTag, TOutput, TMeta, TStateSchema>, TEvent, AnyActorSystem, TEmitted>): MachineSnapshot<TContext, TEvent, TChildren, TStateValue, TTag, TOutput, TMeta, TStateSchema>;
+    getPersistedSnapshot(snapshot: MachineSnapshot<TContext, TEvent, TChildren, TStateValue, TTag, TOutput, TMeta, TConfig>, options?: unknown): Snapshot<unknown>;
+    restoreSnapshot(snapshot: Snapshot<unknown>, _actorScope: ActorScope<MachineSnapshot<TContext, TEvent, TChildren, TStateValue, TTag, TOutput, TMeta, TConfig>, TEvent, AnyActorSystem, TEmitted>): MachineSnapshot<TContext, TEvent, TChildren, TStateValue, TTag, TOutput, TMeta, TConfig>;
 }
+export {};

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

@@ -1,5 +1,4 @@
-import type { StateMachine } from "./StateMachine.js";
-import type { DelayedTransitionDefinition, EventObject, InitialTransitionDefinition, InvokeDefinition, MachineContext, Mapper, StateNodeConfig, StateNodeDefinition, StateNodesConfig, TransitionDefinition, TransitionDefinitionMap, TODO, UnknownAction, ParameterizedObject, AnyStateMachine, ProvidedActor, NonReducibleUnknown, EventDescriptor } from "./types.js";
+import type { DelayedTransitionDefinition, EventObject, InitialTransitionDefinition, MachineContext, Mapper, StateNodesConfig, TransitionDefinitionMap, AnyStateMachine, AnyStateNodeConfig, NonReducibleUnknown, EventDescriptor, AnyAction, AnyTransitionDefinition, AnyInvokeDefinition } from "./types.js";
 interface StateNodeOptions<TContext extends MachineContext, TEvent extends EventObject> {
     _key: string;
     _parent?: StateNode<TContext, TEvent>;
@@ -7,14 +6,7 @@ interface StateNodeOptions<TContext extends MachineContext, TEvent extends Event
 }
 export declare class StateNode<TContext extends MachineContext = MachineContext, TEvent extends EventObject = EventObject> {
     /** The raw config used to create the machine. */
-    config: StateNodeConfig<TContext, TEvent, TODO, // actors
-    TODO, // actions
-    TODO, // guards
-    TODO, // delays
-    TODO, // tags
-    TODO, // output
-    TODO, // emitted
-    TODO>;
+    config: AnyStateNodeConfig;
     /**
      * The relative key of the state node, which represents its location in the
      * overall state value.
@@ -29,13 +21,14 @@ export declare class StateNode<TContext extends MachineContext = MachineContext,
      * - `'compound'` - nested child state nodes (XOR)
      * - `'parallel'` - orthogonal nested child state nodes (AND)
      * - `'history'` - history state node
+     * - `'choice'` - pure routing decision state node
      * - `'final'` - final state node
      */
-    type: 'atomic' | 'compound' | 'parallel' | 'final' | 'history';
+    type: 'atomic' | 'compound' | 'parallel' | 'final' | 'history' | 'choice';
     /** The string path from the root machine node to this node. */
     path: string[];
     /** The child state nodes. */
-    states: StateNodesConfig<TContext, TEvent>;
+    states: StateNodesConfig<any, any>;
     /**
      * The type of history on this state node. Can be:
      *
@@ -44,24 +37,13 @@ export declare class StateNode<TContext extends MachineContext = MachineContext,
      */
     history: false | 'shallow' | 'deep';
     /** The action(s) to be executed upon entering the state node. */
-    entry: UnknownAction[];
+    entry: AnyAction | undefined;
     /** The action(s) to be executed upon exiting the state node. */
-    exit: UnknownAction[];
+    exit: AnyAction | undefined;
     /** The parent state node. */
-    parent?: StateNode<TContext, TEvent>;
+    parent?: StateNode<any, any>;
     /** The root machine node. */
-    machine: StateMachine<TContext, TEvent, any, // children
-    any, // actor
-    any, // action
-    any, // guard
-    any, // delay
-    any, // state value
-    any, // tag
-    any, // input
-    any, // output
-    any, // emitted
-    any, // meta
-    any>;
+    machine: AnyStateMachine;
     /**
      * The meta data associated with this state node, which will be returned in
      * State instances.
@@ -79,34 +61,16 @@ export declare class StateNode<TContext extends MachineContext = MachineContext,
     order: number;
     description?: string;
     tags: string[];
-    transitions: Map<string, TransitionDefinition<TContext, TEvent>[]>;
-    always?: Array<TransitionDefinition<TContext, TEvent>>;
+    transitions: Map<string, AnyTransitionDefinition[]>;
+    always?: Array<AnyTransitionDefinition>;
+    invoke: Array<AnyInvokeDefinition>;
+    on: TransitionDefinitionMap<any, any>;
+    after: Array<DelayedTransitionDefinition<any, any>>;
+    events: Array<EventDescriptor<any>>;
+    ownEvents: Array<EventDescriptor<any>>;
     constructor(
     /** The raw config used to create the machine. */
-    config: StateNodeConfig<TContext, TEvent, TODO, // actors
-    TODO, // actions
-    TODO, // guards
-    TODO, // delays
-    TODO, // tags
-    TODO, // output
-    TODO, // emitted
-    TODO>, options: StateNodeOptions<TContext, TEvent>);
-    /** The well-structured state node definition. */
-    get definition(): StateNodeDefinition<TContext, TEvent>;
-    /** The logic invoked as actors by this state node. */
-    get invoke(): Array<InvokeDefinition<TContext, TEvent, ProvidedActor, ParameterizedObject, ParameterizedObject, string, TODO, // TEmitted
-    TODO>>;
-    /** The mapping of events to transitions. */
-    get on(): TransitionDefinitionMap<TContext, TEvent>;
-    get after(): Array<DelayedTransitionDefinition<TContext, TEvent>>;
-    get initial(): InitialTransitionDefinition<TContext, TEvent>;
-    /** All the event types accepted by this state node and its descendants. */
-    get events(): Array<EventDescriptor<TEvent>>;
-    /**
-     * All the events that have transitions directly from this state node.
-     *
-     * Excludes any inert events.
-     */
-    get ownEvents(): Array<EventDescriptor<TEvent>>;
+    config: AnyStateNodeConfig, options: StateNodeOptions<TContext, TEvent>);
+    get initial(): InitialTransitionDefinition;
 }
 export {};

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

@@ -1,9 +1,14 @@
-export { assign, type AssignAction, type AssignArgs } from "./actions/assign.js";
-export { cancel, type CancelAction } from "./actions/cancel.js";
-export { emit, type EmitAction } from "./actions/emit.js";
-export { enqueueActions, type EnqueueActionsAction } from "./actions/enqueueActions.js";
-export { log, type LogAction } from "./actions/log.js";
-export { raise, type RaiseAction } from "./actions/raise.js";
-export { forwardTo, sendParent, sendTo, type SendToAction } from "./actions/send.js";
-export { spawnChild, type SpawnAction, type SpawnActionOptions } from "./actions/spawnChild.js";
-export { stop, stopChild, type StopAction } from "./actions/stopChild.js";
+import { AnyActor, AnyActorScope, EventObject } from "./types.js";
+export declare const builtInActions: {
+    "@xstate.start": (actor: AnyActor) => void;
+    "@xstate.raise": (actorScope: AnyActorScope, event: EventObject, options: {
+        id?: string;
+        delay?: number;
+    }) => void;
+    "@xstate.sendTo": (actorScope: AnyActorScope, actor: AnyActor, event: EventObject, options: {
+        id?: string;
+        delay?: number;
+    }) => void;
+    "@xstate.cancel": (actorScope: AnyActorScope, sendId: string) => void;
+    "@xstate.stop": (actorScope: AnyActorScope, actor: AnyActor) => void;
+};

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

@@ -1,18 +1,28 @@
 import { AnyActorSystem } from "../system.js";
 import { ActorLogic, ActorRefFromLogic, AnyEventObject, EventObject, NonReducibleUnknown, Snapshot } from "../types.js";
+import { StandardSchemaV1 } from "../schema.types.js";
 export type CallbackSnapshot<TInput> = Snapshot<undefined> & {
     input: TInput;
+    effects?: Record<string, {
+        status: 'active';
+    } | {
+        status: 'done';
+        output?: unknown;
+    } | {
+        status: 'error';
+        error: unknown;
+    }>;
 };
 export type CallbackActorLogic<TEvent extends EventObject, TInput = NonReducibleUnknown, TEmitted extends EventObject = EventObject> = ActorLogic<CallbackSnapshot<TInput>, TEvent, TInput, AnyActorSystem, TEmitted>;
 /**
- * Represents an actor created by `fromCallback`.
+ * Represents an actor created by `createCallbackLogic`.
  *
  * The type of `self` within the actor's logic.
  *
  * @example
  *
  * ```ts
- * import { fromCallback, createActor } from 'xstate';
+ * import { createCallbackLogic, createActor } from 'xstate';
  *
  * // The events the actor receives.
  * type Event = { type: 'someEvent' };
@@ -20,23 +30,25 @@ export type CallbackActorLogic<TEvent extends EventObject, TInput = NonReducible
  * type Input = { name: string };
  *
  * // Actor logic that logs whenever it receives an event of type `someEvent`.
- * const logic = fromCallback<Event, Input>(({ self, input, receive }) => {
- *   self;
- *   // ^? CallbackActorRef<Event, Input>
- *
- *   receive((event) => {
- *     if (event.type === 'someEvent') {
- *       console.log(`${input.name}: received "someEvent" event`);
- *       // logs 'myActor: received "someEvent" event'
- *     }
- *   });
- * });
+ * const logic = createCallbackLogic<Event, Input>(
+ *   ({ self, input, receive }) => {
+ *     self;
+ *     // ^? CallbackActorRef<Event, Input>
+ *
+ *     receive((event) => {
+ *       if (event.type === 'someEvent') {
+ *         console.log(`${input.name}: received "someEvent" event`);
+ *         // logs 'myActor: received "someEvent" event'
+ *       }
+ *     });
+ *   }
+ * );
  *
  * const actor = createActor(logic, { input: { name: 'myActor' } });
  * //    ^? CallbackActorRef<Event, Input>
  * ```
  *
- * @see {@link fromCallback}
+ * @see {@link createCallbackLogic}
  */
 export type CallbackActorRef<TEvent extends EventObject, TInput = NonReducibleUnknown> = ActorRefFromLogic<CallbackActorLogic<TEvent, TInput>>;
 type Receiver<TEvent extends EventObject> = (listener: {
@@ -62,6 +74,12 @@ export type CallbackLogicFunction<TEvent extends EventObject = AnyEventObject, T
     receive: Receiver<TEvent>;
     emit: (emitted: TEmitted) => void;
 }) => (() => void) | void;
+export interface CallbackLogicConfig<TEvent extends EventObject = AnyEventObject, TSentEvent extends EventObject = AnyEventObject, TInput = NonReducibleUnknown, TEmitted extends EventObject = EventObject, TInputSchema extends StandardSchemaV1 = StandardSchemaV1> {
+    schemas?: {
+        input?: TInputSchema;
+    };
+    run: CallbackLogicFunction<TEvent, TSentEvent, TInput, TEmitted>;
+}
 /**
  * An actor logic creator which returns callback logic as defined by a callback
  * function.
@@ -85,7 +103,7 @@ export type CallbackLogicFunction<TEvent extends EventObject = AnyEventObject, T
  * @example
  *
  * ```typescript
- * const callbackLogic = fromCallback(({ sendBack, receive }) => {
+ * const callbackLogic = createCallbackLogic(({ sendBack, receive }) => {
  *   let lockStatus = 'unlocked';
  *
  *   const handler = (event) => {
@@ -128,5 +146,13 @@ export type CallbackLogicFunction<TEvent extends EventObject = AnyEventObject, T
  * @see {@link CallbackLogicFunction} for more information about the callback function and its object argument
  * @see {@link https://stately.ai/docs/input | Input docs} for more information about how input is passed
  */
-export declare function fromCallback<TEvent extends EventObject, TInput = NonReducibleUnknown, TEmitted extends EventObject = EventObject>(callback: CallbackLogicFunction<TEvent, AnyEventObject, TInput, TEmitted>): CallbackActorLogic<TEvent, TInput, TEmitted>;
+export declare function createCallbackLogic<TEvent extends EventObject, const TInputSchema extends StandardSchemaV1, TEmitted extends EventObject = EventObject>(config: CallbackLogicConfig<TEvent, AnyEventObject, StandardSchemaV1.InferOutput<TInputSchema>, TEmitted, TInputSchema> & {
+    schemas: {
+        input: TInputSchema;
+    };
+}): CallbackActorLogic<TEvent, StandardSchemaV1.InferOutput<TInputSchema>, TEmitted>;
+export declare function createCallbackLogic<TEvent extends EventObject, TInput = NonReducibleUnknown, TEmitted extends EventObject = EventObject>(config: CallbackLogicConfig<TEvent, AnyEventObject, TInput, TEmitted> & {
+    schemas?: undefined;
+}): CallbackActorLogic<TEvent, TInput, TEmitted>;
+export declare function createCallbackLogic<TEvent extends EventObject, TInput = NonReducibleUnknown, TEmitted extends EventObject = EventObject>(callback: CallbackLogicFunction<TEvent, AnyEventObject, TInput, TEmitted>): CallbackActorLogic<TEvent, TInput, TEmitted>;
 export {};

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

@@ -1,6 +1,9 @@
-import type { ActorRef, AnyEventObject, Snapshot } from "../types.js";
-export { fromCallback, type CallbackActorLogic, type CallbackActorRef, type CallbackSnapshot, type CallbackLogicFunction } from "./callback.js";
-export { fromEventObservable, fromObservable, type ObservableActorLogic, type ObservableActorRef, type ObservableSnapshot } from "./observable.js";
-export { fromPromise, type PromiseActorLogic, type PromiseActorRef, type PromiseSnapshot } from "./promise.js";
-export { fromTransition, type TransitionActorLogic, type TransitionActorRef, type TransitionSnapshot } from "./transition.js";
-export declare function createEmptyActor(): ActorRef<Snapshot<undefined>, AnyEventObject, AnyEventObject>;
+import type { ActorFromLogic } from "../types.js";
+export { createCallbackLogic, type CallbackActorLogic, type CallbackActorRef, type CallbackLogicConfig, type CallbackSnapshot, type CallbackLogicFunction } from "./callback.js";
+export { createObservableLogic, createEventObservableLogic, type EventObservableLogicConfig, type EventObservableLogicFunction, type ObservableActorLogic, type ObservableActorRef, type ObservableLogicConfig, type ObservableLogicFunction, type ObservableSnapshot } from "./observable.js";
+export { createLogic, type LogicActorLogic, type LogicActorRef, type LogicArgs, type LogicConfig, type LogicEffect, type LogicEffectState, type LogicEnqueue, type LogicFunction, type LogicPatch, type LogicSnapshot } from "./logic.js";
+export { createAsyncLogic, type AsyncActorLogic, type AsyncActorRef, type AsyncSnapshot, type LogicArgs as AsyncLogicArgs, type LogicConfig as AsyncLogicConfig, type LogicEnqueue as AsyncLogicEnqueue, type LogicFunction as AsyncLogicFunction, TimeoutError } from "./promise.js";
+export { createListenerLogic, listenerLogic, type ListenerActorLogic, type ListenerActorRef, type ListenerSnapshot, type ListenerInput } from "./listener.js";
+export { createSubscriptionLogic, subscriptionLogic, type SubscriptionActorLogic, type SubscriptionActorRef, type SubscriptionSnapshot, type SubscriptionInput, type SubscriptionMappers } from "./subscription.js";
+declare const emptyLogic: import("./logic.js").LogicActorLogic<undefined, undefined, import("../types.js").EventObject, import("../types.js").NonReducibleUnknown, import("../types.js").EventObject>;
+export declare function createEmptyActor(): ActorFromLogic<typeof emptyLogic>;

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

@@ -0,0 +1,18 @@
+import { AnyActorSystem } from "../system.js";
+import { ActorLogic, ActorRefFromLogic, AnyActor, EventObject, Snapshot } from "../types.js";
+export type ListenerSnapshot = Snapshot<undefined> & {
+    input: ListenerInput<any, any>;
+};
+export interface ListenerInput<TEmitted extends EventObject, TMappedEvent extends EventObject> {
+    actor: AnyActor;
+    eventType: string;
+    mapper: (event: TEmitted) => TMappedEvent;
+}
+export type ListenerActorLogic<TEmitted extends EventObject = EventObject, TMappedEvent extends EventObject = EventObject> = ActorLogic<ListenerSnapshot, EventObject, ListenerInput<TEmitted, TMappedEvent>, AnyActorSystem, EventObject>;
+export type ListenerActorRef<TEmitted extends EventObject = EventObject, TMappedEvent extends EventObject = EventObject> = ActorRefFromLogic<ListenerActorLogic<TEmitted, TMappedEvent>>;
+/**
+ * Creates actor logic for listening to emitted events from another actor. Used
+ * internally by `enq.listen()`.
+ */
+export declare function createListenerLogic<TEmitted extends EventObject = EventObject, TMappedEvent extends EventObject = EventObject>(): ListenerActorLogic<TEmitted, TMappedEvent>;
+export declare const listenerLogic: ListenerActorLogic<EventObject, EventObject>;

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

@@ -0,0 +1,105 @@
+import { StandardSchemaV1 } from "../schema.types.js";
+import { AnyActorSystem } from "../system.js";
+import { ActorLogic, ActorRefFromLogic, ActorScope, EventObject, NonReducibleUnknown, Snapshot } from "../types.js";
+export type LogicSnapshot<TContext, TOutput, TInput> = Snapshot<TOutput> & {
+    context: TContext;
+    input: TInput | undefined;
+    effects?: Record<string, LogicEffectState>;
+};
+export type LogicEffectState = {
+    status: 'active';
+} | {
+    status: 'done';
+    output?: unknown;
+} | {
+    status: 'error';
+    error: unknown;
+};
+export interface LogicArgs<TContext, TEvent extends EventObject, TInput> {
+    context: TContext;
+    event: TEvent;
+    input: TInput;
+    system: AnyActorSystem;
+    self: LogicActorRef<TContext, unknown, TEvent, TInput>;
+}
+export type LogicEffect<TEvent extends EventObject, TEmitted extends EventObject> = {
+    type: 'emit';
+    event: TEmitted;
+} | {
+    type: 'sendBack';
+    event: EventObject;
+} | {
+    type: 'raise';
+    event: TEvent;
+} | {
+    type: 'effect';
+    key?: string;
+    exec: () => void | (() => void);
+} | {
+    type: 'cleanupEffects';
+};
+export interface LogicEnqueue<TEvent extends EventObject, TEmitted extends EventObject> {
+    emit: (emitted: TEmitted) => void;
+    sendBack: (event: EventObject) => void;
+    raise: (event: TEvent) => void;
+    effect: {
+        (exec: () => void | (() => void)): void;
+        (key: string, exec: () => void | (() => void)): void;
+    };
+}
+export type LogicPatch<TContext, TOutput, TInput> = Partial<{
+    context: TContext;
+    input: TInput | undefined;
+    status: LogicSnapshot<TContext, TOutput, TInput>['status'];
+    output: TOutput;
+    error: unknown;
+    effects: Record<string, LogicEffectState>;
+}>;
+export type LogicFunction<TContext, TOutput, TEvent extends EventObject, TInput, TEmitted extends EventObject> = (args: LogicArgs<TContext, TEvent, TInput>, enq: LogicEnqueue<TEvent, TEmitted>) => void | LogicPatch<TContext, TOutput, TInput>;
+export interface LogicConfig<TContext, TOutput, TEvent extends EventObject, TInput, TEmitted extends EventObject, TInputSchema extends StandardSchemaV1 = StandardSchemaV1, TOutputSchema extends StandardSchemaV1 = StandardSchemaV1> {
+    id?: string;
+    schemas?: {
+        input?: TInputSchema;
+        output?: TOutputSchema;
+    };
+    context: TContext | ((args: {
+        input: TInput;
+    }) => TContext);
+    run: LogicFunction<TContext, TOutput, TEvent, TInput, TEmitted>;
+}
+interface LogicTransition<TContext, TOutput, TEvent extends EventObject, TInput, TEmitted extends EventObject> {
+    (snapshot: LogicSnapshot<TContext, TOutput, TInput>, event: TEvent, actorScope: ActorScope<LogicSnapshot<TContext, TOutput, TInput>, TEvent, AnyActorSystem, TEmitted>): [
+        LogicSnapshot<TContext, TOutput, TInput>,
+        LogicEffect<TEvent, TEmitted>[]
+    ];
+    (snapshot: LogicSnapshot<TContext, TOutput, TInput>, event: TEvent, actorScope: ActorScope<LogicSnapshot<TContext, TOutput, TInput>, TEvent, AnyActorSystem, TEmitted>): LogicSnapshot<TContext, TOutput, TInput>;
+}
+export type LogicActorLogic<TContext, TOutput, TEvent extends EventObject = EventObject, TInput = NonReducibleUnknown, TEmitted extends EventObject = EventObject> = Omit<ActorLogic<LogicSnapshot<TContext, TOutput, TInput>, TEvent, TInput, AnyActorSystem, TEmitted>, 'transition'> & {
+    id?: string;
+    transition: LogicTransition<TContext, TOutput, TEvent, TInput, TEmitted>;
+};
+export type LogicActorRef<TContext, TOutput, TEvent extends EventObject, TInput> = ActorRefFromLogic<LogicActorLogic<TContext, TOutput, TEvent, TInput>>;
+export declare const XSTATE_LOGIC_EFFECT_RESOLVE = "xstate.logic.effect.resolve";
+export declare const XSTATE_LOGIC_EFFECT_REJECT = "xstate.logic.effect.reject";
+export declare const XSTATE_LOGIC_EFFECT_START = "xstate.logic.effect.start";
+export declare function executeLogicEffects(effects: readonly unknown[] | undefined, actorScope: ActorScope<any, any, any, any>): void;
+export declare function createLogic<TContext, const TInputSchema extends StandardSchemaV1, const TOutputSchema extends StandardSchemaV1, TEvent extends EventObject = EventObject, TEmitted extends EventObject = EventObject>(config: LogicConfig<TContext, StandardSchemaV1.InferOutput<TOutputSchema>, TEvent, StandardSchemaV1.InferOutput<TInputSchema>, TEmitted, TInputSchema, TOutputSchema> & {
+    schemas: {
+        input: TInputSchema;
+        output: TOutputSchema;
+    };
+}): LogicActorLogic<TContext, StandardSchemaV1.InferOutput<TOutputSchema>, TEvent, StandardSchemaV1.InferOutput<TInputSchema>, TEmitted>;
+export declare function createLogic<TContext, TOutput, const TInputSchema extends StandardSchemaV1, TEvent extends EventObject = EventObject, TEmitted extends EventObject = EventObject>(config: LogicConfig<TContext, TOutput, TEvent, StandardSchemaV1.InferOutput<TInputSchema>, TEmitted, TInputSchema> & {
+    schemas: {
+        input: TInputSchema;
+        output?: undefined;
+    };
+}): LogicActorLogic<TContext, TOutput, TEvent, StandardSchemaV1.InferOutput<TInputSchema>, TEmitted>;
+export declare function createLogic<TContext, const TOutputSchema extends StandardSchemaV1, TEvent extends EventObject = EventObject, TInput = NonReducibleUnknown, TEmitted extends EventObject = EventObject>(config: LogicConfig<TContext, StandardSchemaV1.InferOutput<TOutputSchema>, TEvent, TInput, TEmitted, StandardSchemaV1, TOutputSchema> & {
+    schemas: {
+        input?: undefined;
+        output: TOutputSchema;
+    };
+}): LogicActorLogic<TContext, StandardSchemaV1.InferOutput<TOutputSchema>, TEvent, TInput, TEmitted>;
+export declare function createLogic<TContext, TOutput = unknown, TEvent extends EventObject = EventObject, TInput = NonReducibleUnknown, TEmitted extends EventObject = EventObject>(config: LogicConfig<TContext, TOutput, TEvent, TInput, TEmitted>): LogicActorLogic<TContext, TOutput, TEvent, TInput, TEmitted>;
+export {};