xstate 5.0.0-beta.9 → 5.0.1

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

@@ -1,5 +1,8 @@
-import { EventObject, ExprWithMeta, MachineContext } from '../types.ts';
-import { BaseDynamicActionObject, CancelActionObject, DynamicCancelActionObject } from '../index.ts';
+import { EventObject, MachineContext, ActionArgs, ParameterizedObject } from "../types.js";
+type ResolvableSendId<TContext extends MachineContext, TExpressionEvent extends EventObject, TParams extends ParameterizedObject['params'] | undefined, TEvent extends EventObject> = string | ((args: ActionArgs<TContext, TExpressionEvent, TEvent>, params: TParams) => string);
+export interface CancelAction<TContext extends MachineContext, TExpressionEvent extends EventObject, TParams extends ParameterizedObject['params'] | undefined, TEvent extends EventObject> {
+    (args: ActionArgs<TContext, TExpressionEvent, TEvent>, params: TParams): void;
+}
 /**
  * Cancels an in-flight `send(...)` action. A canceled sent action will not
  * be executed, nor will its event be sent, unless it has already been sent
@@ -7,4 +10,5 @@ import { BaseDynamicActionObject, CancelActionObject, DynamicCancelActionObject
  *
  * @param sendId The `id` of the `send(...)` action to cancel.
  */
-export declare function cancel<TContext extends MachineContext, TExpressionEvent extends EventObject, TEvent extends EventObject>(sendId: string | ExprWithMeta<TContext, TExpressionEvent, string>): BaseDynamicActionObject<TContext, TExpressionEvent, TEvent, CancelActionObject, DynamicCancelActionObject<TContext, TExpressionEvent>['params']>;
+export declare function cancel<TContext extends MachineContext, TExpressionEvent extends EventObject, TParams extends ParameterizedObject['params'] | undefined, TEvent extends EventObject>(sendId: ResolvableSendId<TContext, TExpressionEvent, TParams, TEvent>): CancelAction<TContext, TExpressionEvent, TParams, TEvent>;
+export {};

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

@@ -0,0 +1,32 @@
+import { Guard } from "../guards.js";
+import { Action, ActionArgs, AnyActorRef, EventObject, MachineContext, ParameterizedObject, ProvidedActor } from "../types.js";
+import { assign } from "./assign.js";
+import { cancel } from "./cancel.js";
+import { raise } from "./raise.js";
+import { sendTo } from "./send.js";
+import { spawnChild } from "./spawnChild.js";
+import { stopChild } from "./stopChild.js";
+interface ActionEnqueuer<TContext extends MachineContext, TExpressionEvent extends EventObject, TEvent extends EventObject, TActor extends ProvidedActor, TAction extends ParameterizedObject, TGuard extends ParameterizedObject, TDelay extends string> {
+    (action: Action<TContext, TExpressionEvent, TEvent, undefined, TActor, TAction, TGuard, TDelay>): void;
+    assign: (...args: Parameters<typeof assign<TContext, TExpressionEvent, undefined, TEvent, TActor>>) => void;
+    cancel: (...args: Parameters<typeof cancel<TContext, TExpressionEvent, undefined, TEvent>>) => void;
+    raise: (...args: Parameters<typeof raise<TContext, TExpressionEvent, TEvent, undefined, TDelay>>) => void;
+    sendTo: <TTargetActor extends AnyActorRef>(...args: Parameters<typeof sendTo<TContext, TExpressionEvent, undefined, TTargetActor, TEvent, TDelay>>) => void;
+    spawnChild: (...args: Parameters<typeof spawnChild<TContext, TExpressionEvent, undefined, TEvent, TActor>>) => void;
+    stopChild: (...args: Parameters<typeof stopChild<TContext, TExpressionEvent, undefined, TEvent>>) => void;
+}
+export interface EnqueueActionsAction<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 enqueueActions<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>(collect: ({ context, event, check, enqueue }: {
+    context: TContext;
+    event: TExpressionEvent;
+    check: (guard: Guard<TContext, TExpressionEvent, undefined, TGuard>) => boolean;
+    enqueue: ActionEnqueuer<TContext, TExpressionEvent, TEvent, TActor, TAction, TGuard, TDelay>;
+}) => void): EnqueueActionsAction<TContext, TExpressionEvent, TEvent, TActor, TAction, TGuard, TDelay>;
+export {};

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

@@ -1,5 +1,8 @@
-import { EventObject, LogExpr, MachineContext, LogActionObject } from '../types.ts';
-import { BaseDynamicActionObject, DynamicLogAction } from '../index.ts';
+import { ActionArgs, EventObject, LogExpr, MachineContext, ParameterizedObject } from "../types.js";
+type ResolvableLogValue<TContext extends MachineContext, TExpressionEvent extends EventObject, TParams extends ParameterizedObject['params'] | undefined, TEvent extends EventObject> = string | LogExpr<TContext, TExpressionEvent, TParams, TEvent>;
+export interface LogAction<TContext extends MachineContext, TExpressionEvent extends EventObject, TParams extends ParameterizedObject['params'] | undefined, TEvent extends EventObject> {
+    (args: ActionArgs<TContext, TExpressionEvent, TEvent>, params: TParams): void;
+}
 /**
  *
  * @param expr The expression function to evaluate which will be logged.
@@ -8,4 +11,5 @@ import { BaseDynamicActionObject, DynamicLogAction } from '../index.ts';
  *  - `event` - the event that caused this action to be executed.
  * @param label The label to give to the logged expression.
  */
-export declare function log<TContext extends MachineContext, TExpressionEvent extends EventObject, TEvent extends EventObject = TExpressionEvent>(expr?: string | LogExpr<TContext, TExpressionEvent>, label?: string): BaseDynamicActionObject<TContext, TExpressionEvent, TEvent, LogActionObject, DynamicLogAction<TContext, TExpressionEvent, TEvent>['params']>;
+export declare function log<TContext extends MachineContext, TExpressionEvent extends EventObject, TParams extends ParameterizedObject['params'] | undefined, TEvent extends EventObject>(value?: ResolvableLogValue<TContext, TExpressionEvent, TParams, TEvent>, label?: string): LogAction<TContext, TExpressionEvent, TParams, TEvent>;
+export {};

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

@@ -1,8 +1,13 @@
-import { EventObject, MachineContext, RaiseActionObject, BaseDynamicActionObject, RaiseActionOptions, SendExpr, RaiseActionParams, NoInfer } from '../types.ts';
+import { ActionArgs, EventObject, MachineContext, NoInfer, RaiseActionOptions, SendExpr, ParameterizedObject } from "../types.js";
+export interface RaiseAction<TContext extends MachineContext, TExpressionEvent extends EventObject, TParams extends ParameterizedObject['params'] | undefined, TEvent extends EventObject, TDelay extends string> {
+    (args: ActionArgs<TContext, TExpressionEvent, TEvent>, params: TParams): void;
+    _out_TEvent?: TEvent;
+    _out_TDelay?: TDelay;
+}
 /**
  * Raises an event. This places the event in the internal event queue, so that
  * the event is immediately consumed by the machine in the current step.
  *
  * @param eventType The event to raise.
  */
-export declare function raise<TContext extends MachineContext, TExpressionEvent extends EventObject, TEvent extends EventObject = TExpressionEvent>(eventOrExpr: NoInfer<TEvent> | SendExpr<TContext, TExpressionEvent, NoInfer<TEvent>>, options?: RaiseActionOptions<TContext, TExpressionEvent>): BaseDynamicActionObject<TContext, TExpressionEvent, TEvent, RaiseActionObject<TContext, TExpressionEvent, TEvent>, RaiseActionParams<TContext, TExpressionEvent, TEvent>>;
+export declare function raise<TContext extends MachineContext, TExpressionEvent extends EventObject, TEvent extends EventObject = TExpressionEvent, TParams extends ParameterizedObject['params'] | undefined = ParameterizedObject['params'] | undefined, TDelay extends string = string>(eventOrExpr: NoInfer<TEvent> | SendExpr<TContext, TExpressionEvent, TParams, NoInfer<TEvent>, TEvent>, options?: RaiseActionOptions<TContext, TExpressionEvent, TParams, NoInfer<TEvent>, NoInfer<TDelay>>): RaiseAction<TContext, TExpressionEvent, TParams, TEvent, TDelay>;

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

@@ -1,53 +1,31 @@
-import { EventObject, SendActionParams, SendExpr, AnyEventObject, MachineContext } from '../types.ts';
-import { AnyActorRef, BaseDynamicActionObject, Cast, EventFrom, ExprWithMeta, InferEvent, SendActionObject, SendActionOptions } from '../index.ts';
+import { ActionArgs, ActorRef, AnyActorRef, AnyEventObject, Cast, EventFrom, EventObject, InferEvent, MachineContext, SendExpr, SendToActionOptions, ParameterizedObject, NoInfer } from "../types.js";
+export interface SendToAction<TContext extends MachineContext, TExpressionEvent extends EventObject, TParams extends ParameterizedObject['params'] | undefined, TEvent extends EventObject, TDelay extends string> {
+    (args: ActionArgs<TContext, TExpressionEvent, TEvent>, params: TParams): void;
+    _out_TDelay?: TDelay;
+}
 /**
- * Sends an event. This returns an action that will be read by an interpreter to
- * send the event in the next step, after the current step is finished executing.
- *
- * @deprecated Use the `sendTo(...)` action creator instead.
+ * Sends an event to an actor.
  *
- * @param eventOrExpr The event to send.
- * @param options Options to pass into the send event:
+ * @param actor The `ActorRef` to send the event to.
+ * @param event The event to send, or an expression that evaluates to the event to send
+ * @param options Send action options
  *  - `id` - The unique send event identifier (used with `cancel()`).
  *  - `delay` - The number of milliseconds to delay the sending of the event.
- *  - `to` - The target of this event (by default, the machine the event was sent from).
  */
-export declare function send<TContext extends MachineContext, TEvent extends EventObject, TSentEvent extends EventObject = AnyEventObject>(eventOrExpr: TSentEvent | SendExpr<TContext, TEvent, AnyEventObject>, options?: SendActionOptions<TContext, TEvent>): BaseDynamicActionObject<TContext, TEvent, TEvent, SendActionObject<AnyEventObject>, SendActionParams<TContext, TEvent>>;
+export declare function sendTo<TContext extends MachineContext, TExpressionEvent extends EventObject, TParams extends ParameterizedObject['params'] | undefined, TTargetActor extends AnyActorRef, TEvent extends EventObject, TDelay extends string>(to: TTargetActor | string | ((args: ActionArgs<TContext, TExpressionEvent, TEvent>, params: TParams) => TTargetActor | string), eventOrExpr: EventFrom<TTargetActor> | SendExpr<TContext, TExpressionEvent, TParams, InferEvent<Cast<EventFrom<TTargetActor>, EventObject>>, TEvent>, options?: SendToActionOptions<TContext, TExpressionEvent, TParams, NoInfer<TEvent>, NoInfer<TDelay>>): SendToAction<TContext, TExpressionEvent, TParams, TEvent, TDelay>;
 /**
  * Sends an event to this machine's parent.
  *
  * @param event The event to send to the parent machine.
  * @param options Options to pass into the send event.
  */
-export declare function sendParent<TContext extends MachineContext, TEvent extends EventObject, TSentEvent extends EventObject = AnyEventObject>(event: TSentEvent | SendExpr<TContext, TEvent, TSentEvent>, options?: SendActionOptions<TContext, TEvent>): BaseDynamicActionObject<TContext, TEvent, TEvent, SendActionObject<AnyEventObject>, SendActionParams<TContext, TEvent, EventObject>>;
-/**
- * Sends an event back to the sender of the original event.
- *
- * @param event The event to send back to the sender
- * @param options Options to pass into the send event
- */
-export declare function respond<TContext extends MachineContext, TEvent extends EventObject, TSentEvent extends EventObject = AnyEventObject>(event: TEvent | SendExpr<TContext, TEvent, TSentEvent>, options?: SendActionOptions<TContext, TEvent>): BaseDynamicActionObject<TContext, TEvent, TEvent, SendActionObject<AnyEventObject>, SendActionParams<TContext, TEvent, EventObject>>;
+export declare function sendParent<TContext extends MachineContext, TExpressionEvent extends EventObject, TParams extends ParameterizedObject['params'] | undefined, TSentEvent extends EventObject = AnyEventObject, TEvent extends EventObject = AnyEventObject, TDelay extends string = string>(event: TSentEvent | SendExpr<TContext, TExpressionEvent, TParams, TSentEvent, TEvent>, options?: SendToActionOptions<TContext, TExpressionEvent, TParams, TEvent, TDelay>): SendToAction<TContext, TExpressionEvent, TParams, TEvent, TDelay>;
+type Target<TContext extends MachineContext, TExpressionEvent extends EventObject, TParams extends ParameterizedObject['params'] | undefined, TEvent extends EventObject> = string | ActorRef<any, any> | ((args: ActionArgs<TContext, TExpressionEvent, TEvent>, params: TParams) => string | ActorRef<any, any>);
 /**
  * Forwards (sends) an event to a specified service.
  *
  * @param target The target service to forward the event to.
  * @param options Options to pass into the send action creator.
  */
-export declare function forwardTo<TContext extends MachineContext, TEvent extends EventObject>(target: Required<SendActionParams<TContext, TEvent>>['to'], options?: SendActionOptions<TContext, TEvent>): BaseDynamicActionObject<TContext, TEvent, TEvent, SendActionObject<AnyEventObject>, SendActionParams<TContext, TEvent, EventObject>>;
-/**
- * Escalates an error by sending it as an event to this machine's parent.
- *
- * @param errorData The error data to send, or the expression function that
- * takes in the `context`, `event`, and `meta`, and returns the error data to send.
- * @param options Options to pass into the send action creator.
- */
-export declare function escalate<TContext extends MachineContext, TEvent extends EventObject, TErrorData = any>(errorData: TErrorData | ExprWithMeta<TContext, TEvent, TErrorData>, options?: SendActionParams<TContext, TEvent>): BaseDynamicActionObject<TContext, TEvent, TEvent, SendActionObject<AnyEventObject>, SendActionParams<TContext, TEvent, EventObject>>;
-/**
- * Sends an event to an actor.
- *
- * @param actor The `ActorRef` to send the event to.
- * @param event The event to send, or an expression that evaluates to the event to send
- * @param options Send action options
- * @returns An XState send action object
- */
-export declare function sendTo<TContext extends MachineContext, TEvent extends EventObject, TActor extends AnyActorRef>(actor: TActor | string | ExprWithMeta<TContext, TEvent, TActor | string>, event: EventFrom<TActor> | SendExpr<TContext, TEvent, InferEvent<Cast<EventFrom<TActor>, EventObject>>>, options?: SendActionOptions<TContext, TEvent>): BaseDynamicActionObject<TContext, TEvent, TEvent, SendActionObject<AnyEventObject>, SendActionParams<TContext, TEvent, EventObject>>;
+export declare function forwardTo<TContext extends MachineContext, TExpressionEvent extends EventObject, TParams extends ParameterizedObject['params'] | undefined, TEvent extends EventObject, TDelay extends string>(target: Target<TContext, TExpressionEvent, TParams, TEvent>, options?: SendToActionOptions<TContext, TExpressionEvent, TParams, TEvent, TDelay>): SendToAction<TContext, TExpressionEvent, TParams, TEvent, TDelay>;
+export {};

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

@@ -0,0 +1,29 @@
+import { ActionArgs, EventObject, MachineContext, ParameterizedObject, AnyActorLogic, ProvidedActor, IsLiteralString, InputFrom, UnifiedArg, Mapper, RequiredActorOptions, ConditionalRequired, IsNotNever } from "../types.js";
+type ResolvableActorId<TContext extends MachineContext, TExpressionEvent extends EventObject, TEvent extends EventObject, TId extends string | undefined> = TId | ((args: UnifiedArg<TContext, TExpressionEvent, TEvent>) => TId);
+export interface SpawnAction<TContext extends MachineContext, TExpressionEvent extends EventObject, TParams extends ParameterizedObject['params'] | undefined, TEvent extends EventObject, TActor extends ProvidedActor> {
+    (args: ActionArgs<TContext, TExpressionEvent, TEvent>, params: TParams): void;
+    _out_TActor?: TActor;
+}
+interface SpawnActionOptions<TContext extends MachineContext, TExpressionEvent extends EventObject, TEvent extends EventObject, TActor extends ProvidedActor> {
+    id?: ResolvableActorId<TContext, TExpressionEvent, TEvent, TActor['id']>;
+    systemId?: string;
+    input?: Mapper<TContext, TEvent, InputFrom<TActor['logic']>, TEvent> | InputFrom<TActor['logic']>;
+    syncSnapshot?: boolean;
+}
+type DistributeActors<TContext extends MachineContext, TExpressionEvent extends EventObject, TEvent extends EventObject, TActor extends ProvidedActor> = TActor extends any ? ConditionalRequired<[
+    src: TActor['src'],
+    options?: SpawnActionOptions<TContext, TExpressionEvent, TEvent, TActor> & {
+        [K in RequiredActorOptions<TActor>]: unknown;
+    }
+], IsNotNever<RequiredActorOptions<TActor>>> : never;
+type SpawnArguments<TContext extends MachineContext, TExpressionEvent extends EventObject, TEvent extends EventObject, TActor extends ProvidedActor> = IsLiteralString<TActor['src']> extends true ? DistributeActors<TContext, TExpressionEvent, TEvent, TActor> : [
+    src: string | AnyActorLogic,
+    options?: {
+        id?: ResolvableActorId<TContext, TExpressionEvent, TEvent, string>;
+        systemId?: string;
+        input?: unknown;
+        syncSnapshot?: boolean;
+    }
+];
+export declare function spawnChild<TContext extends MachineContext, TExpressionEvent extends EventObject, TParams extends ParameterizedObject['params'] | undefined, TEvent extends EventObject, TActor extends ProvidedActor>(...[src, { id, systemId, input, syncSnapshot }]: SpawnArguments<TContext, TExpressionEvent, TEvent, TActor>): SpawnAction<TContext, TExpressionEvent, TParams, TEvent, TActor>;
+export {};

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

@@ -0,0 +1,18 @@
+import { ActionArgs, ActorRef, EventObject, MachineContext, ParameterizedObject } from "../types.js";
+type ResolvableActorRef<TContext extends MachineContext, TExpressionEvent extends EventObject, TParams extends ParameterizedObject['params'] | undefined, TEvent extends EventObject> = string | ActorRef<any, any> | ((args: ActionArgs<TContext, TExpressionEvent, TEvent>, params: TParams) => ActorRef<any, any> | string);
+export interface StopAction<TContext extends MachineContext, TExpressionEvent extends EventObject, TParams extends ParameterizedObject['params'] | undefined, TEvent extends EventObject> {
+    (args: ActionArgs<TContext, TExpressionEvent, TEvent>, params: TParams): void;
+}
+/**
+ * Stops a child actor.
+ *
+ * @param actorRef The actor to stop.
+ */
+export declare function stopChild<TContext extends MachineContext, TExpressionEvent extends EventObject, TParams extends ParameterizedObject['params'] | undefined, TEvent extends EventObject>(actorRef: ResolvableActorRef<TContext, TExpressionEvent, TParams, TEvent>): StopAction<TContext, TExpressionEvent, TParams, TEvent>;
+/**
+ * Stops a child actor.
+ *
+ * @deprecated Use `stopChild(...)` instead
+ */
+export declare const stop: typeof stopChild;
+export {};

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

@@ -1,48 +1,8 @@
-import { Action, EventObject, SingleOrArray, ActionFunction, ActionFunctionMap, ActionTypes, DoneEvent, ErrorPlatformEvent, DoneEventObject, MachineContext, BaseActionObject, SCXML } from './types.ts';
-import * as actionTypes from './actionTypes.ts';
-export { send, sendTo, sendParent, respond, forwardTo, escalate } from './actions/send.ts';
-export { stop } from './actions/stop.ts';
-export { log } from './actions/log.ts';
-export { cancel } from './actions/cancel.ts';
-export { assign } from './actions/assign.ts';
-export { raise } from './actions/raise.ts';
-export { choose } from './actions/choose.ts';
-export { pure } from './actions/pure.ts';
-export { actionTypes };
-export declare const initEvent: SCXML.Event<{
-    type: ActionTypes;
-}>;
-export declare function resolveActionObject(actionObject: BaseActionObject, actionFunctionMap: ActionFunctionMap<any, any>): BaseActionObject;
-export declare function toActionObject<TContext extends MachineContext, TEvent extends EventObject>(action: BaseActionObject | ActionFunction<TContext, TEvent> | string): BaseActionObject;
-export declare const toActionObjects: <TContext extends MachineContext, TEvent extends EventObject>(action?: SingleOrArray<Action<TContext, TEvent>> | undefined) => BaseActionObject[];
-/**
- * Returns an event type that represents an implicit event that
- * is sent after the specified `delay`.
- *
- * @param delayRef The delay in milliseconds
- * @param id The state node ID where this event is handled
- */
-export declare function after(delayRef: number | string, id?: string): string;
-/**
- * Returns an event that represents that a final state node
- * has been reached in the parent state node.
- *
- * @param id The final state node's parent state node `id`
- * @param output The data to pass into the event
- */
-export declare function done(id: string, output?: any): DoneEventObject;
-/**
- * Returns an event that represents that an invoked service has terminated.
- *
- * An invoked service is terminated when it has reached a top-level final state node,
- * but not when it is canceled.
- *
- * @param invokeId The invoked service ID
- * @param output The data to pass into the event
- */
-export declare function doneInvoke(invokeId: string, output?: any): DoneEvent;
-export declare function error(id: string, data?: any): ErrorPlatformEvent & string;
-export declare function createInitEvent(input: any): SCXML.Event<{
-    type: ActionTypes.Init;
-    input: any;
-}>;
+export { assign, type AssignAction, type AssignArgs } from "./actions/assign.js";
+export { cancel, type CancelAction } from "./actions/cancel.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 } from "./actions/spawnChild.js";
+export { stop, stopChild, type StopAction } from "./actions/stopChild.js";

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

@@ -1,8 +1,91 @@
-import { InvokeCallback, ActorBehavior, EventObject } from '../types';
-export interface CallbackInternalState {
-    canceled: boolean;
-    receivers: Set<(e: EventObject) => void>;
-    dispose: void | (() => void) | Promise<any>;
-    input?: any;
-}
-export declare function fromCallback<TEvent extends EventObject>(invokeCallback: InvokeCallback): ActorBehavior<TEvent, undefined>;
+import { ActorLogic, EventObject, AnyActorSystem, AnyEventObject, ActorSystem, ActorRefFrom, Snapshot, NonReducibleUnknown } from "../types.js";
+export type CallbackSnapshot<TInput> = Snapshot<undefined> & {
+    input: TInput;
+};
+export type CallbackActorLogic<TEvent extends EventObject, TInput = NonReducibleUnknown> = ActorLogic<CallbackSnapshot<TInput>, TEvent, TInput, ActorSystem<any>>;
+export type CallbackActorRef<TEvent extends EventObject, TInput = NonReducibleUnknown> = ActorRefFrom<CallbackActorLogic<TEvent, TInput>>;
+export type Receiver<TEvent extends EventObject> = (listener: {
+    bivarianceHack(event: TEvent): void;
+}['bivarianceHack']) => void;
+export type InvokeCallback<TEvent extends EventObject = AnyEventObject, TSentEvent extends EventObject = AnyEventObject, TInput = NonReducibleUnknown> = ({ input, system, self, sendBack, receive }: {
+    /**
+     * Data that was provided to the callback actor
+     * @see {@link https://stately.ai/docs/input | Input docs}
+     */
+    input: TInput;
+    /**
+     * The actor system to which the callback actor belongs
+     */
+    system: AnyActorSystem;
+    /**
+     * The parent actor of the callback actor
+     */
+    self: CallbackActorRef<TEvent>;
+    /**
+     * A function that can send events back to the parent actor
+     */
+    sendBack: (event: TSentEvent) => void;
+    /**
+     * A function that can be called with a listener function argument;
+     * the listener is then called whenever events are received by the callback actor
+     */
+    receive: Receiver<TEvent>;
+}) => (() => void) | void;
+/**
+ * An actor logic creator which returns callback logic as defined by a callback function.
+ *
+ * @remarks
+ * Useful for subscription-based or other free-form logic that can send events back to the parent actor.
+ *
+ * Actors created from callback logic (“callback actors”) can:
+ * - Receive events via the `receive` function
+ * - Send events to the parent actor via the `sendBack` function
+ *
+ * Callback actors are a bit different from other actors in that they:
+ * - Do not work with `onDone`
+ * - Do not produce a snapshot using `.getSnapshot()`
+ * - Do not emit values when used with `.subscribe()`
+ * - Can not be stopped with `.stop()`
+ *
+ * @param invokeCallback - The callback function used to describe the callback logic
+ * The callback function is passed an object with the following properties:
+ * - `receive` - A function that can send events back to the parent actor; the listener is then called whenever events are received by the callback actor
+ * - `sendBack` - A function that can send events back to the parent actor
+ * - `input` - Data that was provided to the callback actor
+ * - `self` - The parent actor of the callback actor
+ * - `system` - The actor system to which the callback actor belongs
+ * The callback function can (optionally) return a cleanup function, which is called when the actor is stopped.
+ * @see {@link InvokeCallback} 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
+
+ * @returns Callback logic
+ *
+ * @example
+ * ```typescript
+ * const callbackLogic = fromCallback(({ sendBack, receive }) => {
+ *   let lockStatus = 'unlocked';
+ *
+ *   const handler = (event) => {
+ *     if (lockStatus === 'locked') {
+ *       return;
+ *     }
+ *     sendBack(event);
+ *   };
+ *
+ *   receive((event) => {
+ *     if (event.type === 'lock') {
+ *       lockStatus = 'locked';
+ *     } else if (event.type === 'unlock') {
+ *       lockStatus = 'unlocked';
+ *     }
+ *   });
+ *
+ *   document.body.addEventListener('click', handler);
+ *
+ *   return () => {
+ *     document.body.removeEventListener('click', handler);
+ *   };
+ * });
+ * ```
+ */
+export declare function fromCallback<TEvent extends EventObject, TInput = NonReducibleUnknown>(invokeCallback: InvokeCallback<TEvent, AnyEventObject, TInput>): CallbackActorLogic<TEvent, TInput>;

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

@@ -1,28 +1,6 @@
-import type { EventObject, ActorRef, BaseActorRef, AnyEventObject } from '../types.ts';
-export { fromTransition } from './transition.ts';
-export { fromPromise } from './promise.ts';
-export { fromObservable, fromEventObservable } from './observable.ts';
-export { fromCallback } from './callback.ts';
-export declare const startSignalType = "xstate.init";
-export declare const stopSignalType = "xstate.stop";
-export declare const startSignal: StartSignal;
-export declare const stopSignal: StopSignal;
-export interface StartSignal {
-    type: 'xstate.init';
-}
-export interface StopSignal {
-    type: 'xstate.stop';
-}
-export type LifecycleSignal = StartSignal | StopSignal;
-export type LifecycleSignalType = typeof startSignalType | typeof stopSignalType;
-/**
- * An object that expresses the behavior of an actor in reaction to received events,
- * as well as an optionally emitted stream of values.
- *
- * @template TReceived The received event
- * @template TSnapshot The emitted value
- */
-export declare function isSignal(eventType: string): eventType is LifecycleSignalType;
-export declare function isActorRef(item: any): item is ActorRef<any>;
-export declare function toActorRef<TEvent extends EventObject, TSnapshot = any, TActorRefLike extends BaseActorRef<TEvent> = BaseActorRef<TEvent>>(actorRefLike: TActorRefLike): ActorRef<TEvent, TSnapshot> & Omit<TActorRefLike, keyof ActorRef<any, any>>;
-export declare function createEmptyActor(): ActorRef<AnyEventObject, undefined>;
+import type { ActorRef, AnyEventObject, Snapshot } from "../types.js";
+export { fromCallback, type CallbackActorLogic, type CallbackSnapshot } from "./callback.js";
+export { fromEventObservable, fromObservable, type ObservableActorLogic, type ObservableSnapshot } from "./observable.js";
+export { fromPromise, type PromiseActorLogic, type PromiseSnapshot } from "./promise.js";
+export { fromTransition, type TransitionActorLogic, type TransitionSnapshot } from "./transition.js";
+export declare function createEmptyActor(): ActorRef<Snapshot<undefined>, AnyEventObject>;

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

@@ -1,22 +1,105 @@
-import { Subscribable, ActorBehavior, EventObject, Subscription } from '../types';
-export interface ObservableInternalState<T> {
-    subscription: Subscription | undefined;
-    status: 'active' | 'done' | 'error' | 'canceled';
-    data: T | undefined;
-    input?: any;
-}
-export type ObservablePersistedState<T> = Omit<ObservableInternalState<T>, 'subscription'>;
-export declare function fromObservable<T, TEvent extends EventObject>(observableCreator: ({ input }: {
-    input: any;
-}) => Subscribable<T>): ActorBehavior<TEvent, T | undefined, ObservableInternalState<T>, ObservablePersistedState<T>>;
+import { Subscribable, ActorLogic, EventObject, Subscription, AnyActorSystem, ActorRefFrom, Snapshot, NonReducibleUnknown } from "../types.js";
+export type ObservableSnapshot<TContext, TInput extends NonReducibleUnknown> = Snapshot<undefined> & {
+    context: TContext | undefined;
+    input: TInput | undefined;
+    _subscription: Subscription | undefined;
+};
+export type ObservableActorLogic<TContext, TInput extends NonReducibleUnknown> = ActorLogic<ObservableSnapshot<TContext, TInput>, {
+    type: string;
+    [k: string]: unknown;
+}, TInput, AnyActorSystem>;
+export type ObservableActorRef<TContext> = ActorRefFrom<ObservableActorLogic<TContext, any>>;
 /**
- * Creates an event observable behavior that listens to an observable
- * that delivers event objects.
+ * 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
  *
- * @param lazyObservable A function that creates an observable
- * @returns An event observable behavior
+ * 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 extends NonReducibleUnknown>(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.
+ *
+ * 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,
+ *   }
+ * });
+ *
+ * const canvasActor = createActor(canvasMachine);
+ * canvasActor.start();
+ * ```
  */
-export declare function fromEventObservable<T extends EventObject>(lazyObservable: ({ input }: {
-    input: any;
-}) => Subscribable<T>): ActorBehavior<EventObject, T | undefined>;
+export declare function fromEventObservable<T extends EventObject, TInput extends NonReducibleUnknown>(lazyObservable: ({ input, system }: {
+    input: TInput;
+    system: AnyActorSystem;
+    self: ObservableActorRef<T>;
+}) => Subscribable<T>): ObservableActorLogic<T, TInput>;

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

@@ -1,11 +1,81 @@
-import { ActorBehavior } from '../types';
-export interface PromiseInternalState<T> {
-    status: 'active' | 'error' | 'done' | 'canceled';
-    data: T | undefined;
-    input?: any;
-}
-export declare function fromPromise<T>(promiseCreator: ({ input }: {
-    input: any;
-}) => PromiseLike<T>): ActorBehavior<{
+import { XSTATE_STOP } from "../constants.js";
+import { ActorLogic, ActorRefFrom, ActorSystem, AnyActorSystem, NonReducibleUnknown, Snapshot } from "../types.js";
+export type PromiseSnapshot<TOutput, TInput> = Snapshot<TOutput> & {
+    input: TInput | undefined;
+};
+declare const XSTATE_PROMISE_RESOLVE = "xstate.promise.resolve";
+declare const XSTATE_PROMISE_REJECT = "xstate.promise.reject";
+export type PromiseActorEvents<T> = {
+    type: typeof XSTATE_PROMISE_RESOLVE;
+    data: T;
+} | {
+    type: typeof XSTATE_PROMISE_REJECT;
+    data: any;
+} | {
+    type: typeof XSTATE_STOP;
+};
+export type PromiseActorLogic<TOutput, TInput = unknown> = ActorLogic<PromiseSnapshot<TOutput, TInput>, {
     type: string;
-}, T | undefined, PromiseInternalState<T>>;
+    [k: string]: unknown;
+}, TInput, // input
+ActorSystem<any>>;
+export type PromiseActorRef<TOutput> = ActorRefFrom<PromiseActorLogic<TOutput, unknown>>;
+/**
+ * An actor logic creator which returns promise logic as defined by an async process that resolves or rejects after some time.
+ *
+ * Actors created from promise actor logic (“promise actors”) can:
+ * - Emit the resolved value of the promise
+ * - Output the resolved value of the promise
+ *
+ * Sending events to promise actors will have no effect.
+ *
+ * @param promiseCreator
+ *   A function which returns a Promise, and accepts an object with the following properties:
+ *   - `input` - Data that was provided to the promise actor
+ *   - `self` - The parent actor of the promise actor
+ *   - `system` - The actor system to which the promise actor belongs
+ * @see {@link https://stately.ai/docs/input | Input docs} for more information about how input is passed
+ *
+ * @example
+ * ```ts
+ * const promiseLogic = fromPromise(async () => {
+ *   const result = await fetch('https://example.com/...')
+ *     .then((data) => data.json());
+ *
+ *   return result;
+ * });
+ *
+ * const promiseActor = createActor(promiseLogic);
+ * promiseActor.subscribe((snapshot) => {
+ *   console.log(snapshot);
+ * });
+ * promiseActor.start();
+ * // => {
+ * //   output: undefined,
+ * //   status: 'active'
+ * //   ...
+ * // }
+ *
+ * // After promise resolves
+ * // => {
+ * //   output: { ... },
+ * //   status: 'done',
+ * //   ...
+ * // }
+ * ```
+ */
+export declare function fromPromise<TOutput, TInput = NonReducibleUnknown>(promiseCreator: ({ input, system }: {
+    /**
+     * Data that was provided to the promise actor
+     */
+    input: TInput;
+    /**
+     * The actor system to which the promise actor belongs
+     */
+    system: AnyActorSystem;
+    /**
+     * The parent actor of the promise actor
+     */
+    self: PromiseActorRef<TOutput>;
+}) => PromiseLike<TOutput>): PromiseActorLogic<TOutput, TInput>;
+export {};