xstate 6.0.0-alpha.21 → 6.0.0-alpha.22

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

@@ -62,8 +62,9 @@ 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, TConfig>, event: TEvent, actorScope: ActorScope<typeof snapshot, TEvent, AnyActorSystem, TEmitted>): ActorLogicTransitionResult<MachineSnapshot<TContext, TEvent, TChildren, TStateValue, TTag, TOutput, TMeta, TConfig>, ExecutableActionObjectFromLogic<this>>;
+    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>>;
     private _collectEffects;
+    private _attachPureActorRef;
     private _transitionFast;
     /**
      * Determines the next state given the current `state` and `event`. Calculates
@@ -79,11 +80,11 @@ export declare class StateMachine<TContext extends MachineContext, TEvent extend
      * Returns the initial `State` instance, with reference to `self` as an
      * `ActorRef`.
      */
-    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>>;
+    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>;
     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>;
+    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/actions.d.ts

@@ -1,15 +1,17 @@
-import { AnyActor, AnyActorScope, EventObject } from "./types.js";
+import { type ActorTermination, AnyActor, AnyActorScope, EventObject } from "./types.js";
+export declare function assertSendToEvent(event: EventObject): void;
 export declare const builtInActions: {
-    "@xstate.spawn": (_actor: AnyActor) => void;
-    "@xstate.start": (actor: AnyActor) => void;
-    "@xstate.raise": (actorScope: AnyActorScope, event: EventObject, options: {
+    "@xstate.spawn": (actor: AnyActor) => any;
+    "@xstate.start": (actor: AnyActor) => any;
+    "@xstate.raise": (actorScope: AnyActorScope, _event: EventObject, options: {
         id?: string;
         delay?: number;
-    }) => void;
+    }) => void | PromiseLike<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;
+    }) => void | PromiseLike<void>;
+    "@xstate.cancel": (actorScope: AnyActorScope, sendId: string) => void | PromiseLike<void>;
+    "@xstate.stop": (actorScope: AnyActorScope, actor: AnyActor) => void | PromiseLike<void>;
+    "@xstate.terminate": (actor: AnyActor, termination: ActorTermination) => any;
 };

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

@@ -1,6 +1,6 @@
 import { StandardSchemaV1 } from "../schema.types.js";
-import { AnyActorSystem } from "../system.js";
-import { ActorLogic, ActorRefFromLogic, ActorScope, EventObject, NonReducibleUnknown, Snapshot } from "../types.js";
+import { ActorSystemRuntime, AnyActorSystem } from "../system.js";
+import { ActorLogic, ActorRefFromLogic, ActorScope, EventObject, ExecutableActionObject, NonReducibleUnknown, Snapshot } from "../types.js";
 export type LogicSnapshot<TContext, TOutput, TInput> = Snapshot<TOutput> & {
     context: TContext;
     input: TInput | undefined;
@@ -22,29 +22,14 @@ export interface LogicArgs<TContext, TEvent extends EventObject, 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 type LogicEffect<_TEvent extends EventObject, _TEmitted extends EventObject> = ExecutableActionObject;
 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;
+        (exec: (runtime?: Partial<ActorSystemRuntime>) => void | (() => void)): void;
+        (key: string, exec: (runtime?: Partial<ActorSystemRuntime>) => void | (() => void)): void;
     };
 }
 export type LogicPatch<TContext, TOutput, TInput> = Partial<{
@@ -82,7 +67,6 @@ export type LogicActorRef<TContext, TOutput, TEvent extends EventObject, 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;

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

@@ -56,7 +56,9 @@ export declare class Actor<TLogic extends AnyActorLogic> implements ActorInstanc
      */
     constructor(logic: TLogic, options?: ActorOptions<TLogic>);
     private _deferred;
-    private _pendingEffects?;
+    private _restored;
+    /** Associates each live snapshot with this actor for later pure transitions. */
+    private _setSnapshot;
     private _setErrorSnapshot;
     /** Recover via the logic's error event if possible; otherwise error out. */
     private _recoverOrError;

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

@@ -1,10 +1,12 @@
 import { createTransitionEnqueue } from "./transitionActions.js";
-import type { ActorLogic, EventObject, MachineContext, NonReducibleUnknown, Snapshot } from "./types.js";
+import type { ActorLogic, EventObject, MachineContext, LogicalTimer, NonReducibleUnknown, Snapshot } from "./types.js";
 export type FSMSnapshot<TContext extends MachineContext, TState extends string, TInput = unknown> = Snapshot<undefined> & {
     value: TState;
     context: TContext;
     input: TInput | undefined;
     children: {};
+    timers: Record<string, LogicalTimer>;
+    _nextTimerId: number;
     _stateInput: Record<string, unknown> | undefined;
     machine: {
         id: string;

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

@@ -18,13 +18,13 @@ export { isMachineSnapshot, type MachineSnapshot } from "./State.js";
 export { StateMachine } from "./StateMachine.js";
 export { StateNode } from "./StateNode.js";
 export { getStateNodes } from "./stateUtils.js";
-export type { ActorSystem, AnyActorSystem } from "./system.js";
+export type { ActorSystem, ActorSystemRuntime, AnyActorSystem } from "./system.js";
 export { toPromise } from "./toPromise.js";
 export * from "./types.js";
 export type { Next_MachineConfig as MachineConfig, Next_StateNodeConfig as StateNodeConfig, Next_InvokeConfig as InvokeConfig, Next_TransitionConfigOrTarget as TransitionConfigOrTarget, Implementations, InferEvents, WidenLiterals } from "./types.v6.js";
 export { getAllOwnEventDescriptors as __unsafe_getAllOwnEventDescriptors, matchesState, checkStateIn, pathToStateValue, toObserver } from "./utils.js";
 export { transition, initialTransition, getMicrosteps, getInitialMicrosteps, getNextTransitions } from "./transition.js";
-export { isBuiltInExecutableAction } from "./transitionActions.js";
+export { executeEffects, isBuiltInExecutableAction } from "./transitionActions.js";
 export { waitFor } from "./waitFor.js";
 declare global {
     interface SymbolConstructor {

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

@@ -50,7 +50,7 @@ export declare function getTransitionResult(transition: Pick<AnyTransitionDefini
     internalEvents: EventObject[] | undefined;
     input: Record<string, unknown> | undefined;
 };
-export declare function macrostep(snapshot: AnyMachineSnapshot, event: EventObject, actorScope: AnyActorScope, internalQueue: AnyEventObject[]): {
+export declare function macrostep(snapshot: AnyMachineSnapshot, event: EventObject, actorScope: AnyActorScope, internalQueue: AnyEventObject[], initialMicrosteps?: Microstep[]): {
     snapshot: typeof snapshot;
     microsteps: Microstep[];
 };

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

@@ -1,29 +1,54 @@
 import { InspectionEvent } from "./inspection.js";
-import { ActorSystemInfo, AnyActor, Observer, EventObject, Subscription, TimersRestoreStrategy } from "./types.js";
-interface ScheduledEvent {
+import { AnyEventObject, ActorTermination, ActorSystemInfo, AnyActor, Observer, EventObject, Subscription } from "./types.js";
+interface ScheduledTimer {
     id: string;
-    event: EventObject;
-    startedAt: number;
+    scheduledAt: number;
+    dueAt: number;
     delay: number;
     source: AnyActor;
-    target: AnyActor;
 }
 export interface Clock {
     setTimeout(fn: (...args: any[]) => void, timeout: number): any;
     clearTimeout(id: any): void;
 }
 interface Scheduler {
-    schedule(source: AnyActor, target: AnyActor, event: EventObject, delay: number, id: string | undefined): void;
+    schedule(source: AnyActor, id: string, delay: number): void;
     cancel(source: AnyActor, id: string): void;
     cancelAll(actor: AnyActor): void;
 }
-export interface ActorSystem<T extends ActorSystemInfo> {
+/**
+ * Runtime operations used to execute effects.
+ *
+ * An external interpreter can override these operations while the default actor
+ * system provides the local in-memory implementation.
+ */
+export interface ActorSystemRuntime {
+    /** Publishes a newly created actor to the runtime. */
+    spawnActor(source: AnyActor | undefined, actor: AnyActor): void | PromiseLike<void>;
+    /** Starts an actor. */
+    startActor(actor: AnyActor): void | PromiseLike<void>;
+    /** Stops an actor without producing a completion result. */
+    stopActor(actor: AnyActor): void | PromiseLike<void>;
+    /** Completes or errors an actor and publishes its terminal result. */
+    terminateActor(actor: AnyActor, termination: ActorTermination): void | PromiseLike<void>;
+    /** Delivers an event between actors. */
+    sendEvent(source: AnyActor | undefined, target: AnyActor, event: AnyEventObject): void | PromiseLike<void>;
+    /** Publishes an emitted event. */
+    emitEvent(source: AnyActor, event: EventObject): void | PromiseLike<void>;
+    /** Schedules a logical timer. */
+    scheduleTimer(source: AnyActor, id: string, delay: number): void | PromiseLike<void>;
+    /** Cancels one logical timer. */
+    cancelTimer(source: AnyActor, id: string): void | PromiseLike<void>;
+    /** Cancels all logical timers owned by an actor. */
+    cancelAllTimers(source: AnyActor): void | PromiseLike<void>;
+}
+export interface ActorSystem<T extends ActorSystemInfo> extends ActorSystemRuntime {
     get: <K extends keyof T['actors']>(key: K) => T['actors'][K] | undefined;
     getAll: () => Partial<T['actors']>;
     inspect: (observer: Observer<InspectionEvent> | ((inspectionEvent: InspectionEvent) => void)) => Subscription;
     scheduler: Scheduler;
     getSnapshot: () => {
-        _scheduledEvents: Record<string, ScheduledEvent>;
+        _scheduledTimers: Record<string, ScheduledTimer>;
     };
     start: () => void;
     _clock: Clock;
@@ -34,6 +59,6 @@ export declare function createRuntimeSystem<T extends ActorSystemInfo>(rootActor
     clock: Clock;
     logger: (...args: any[]) => void;
     snapshot?: unknown;
-    timers?: TimersRestoreStrategy;
+    createActorRef: ActorSystem<T>['createActorRef'];
 }): ActorSystem<T>;
 export {};

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

@@ -1,6 +1,8 @@
-import type { AnyAction, AnyActorScope, AnyEventObject, AnyMachineSnapshot, EnqueueObject, EventObject, ExecutableActionObject, MachineContext, SpecialExecutableAction, StartExecutableActionObject } from "./types.js";
+import type { ActorSystemRuntime } from "./system.js";
+import type { AnyAction, AnyActor, AnyActorScope, AnyEventObject, AnyMachineSnapshot, EnqueueObject, EventObject, ExecutableActionObject, MachineContext, SpecialExecutableAction, SpawnExecutableActionObject, StartExecutableActionObject } from "./types.js";
 export declare function mergeContextPatch(context: MachineContext, patch: MachineContext): MachineContext;
 export declare function createTransitionEnqueue(actorScope: AnyActorScope, actions: any[], internalEvents: EventObject[], actorSubscriptions?: boolean, createActors?: boolean): EnqueueObject<any, any>;
+export declare function createSpawnEffect(actor: AnyActor): SpawnExecutableActionObject;
 /**
  * Attached (listener/subscription) starts are ordered before child starts so
  * that a listener/subscription captures events emitted synchronously as its
@@ -8,5 +10,7 @@ export declare function createTransitionEnqueue(actorScope: AnyActorScope, actio
  */
 export declare function deriveDeferredStarts(effects: ReadonlyArray<ExecutableActionObject>): StartExecutableActionObject[];
 export declare function isBuiltInExecutableAction(action: ExecutableActionObject): action is SpecialExecutableAction;
+/** Executes transition effects sequentially, awaiting each runtime operation. */
+export declare function executeEffects(effects: readonly ExecutableActionObject[], runtime?: Partial<ActorSystemRuntime>): Promise<void>;
 export declare function resolveActionsWithContext(currentSnapshot: AnyMachineSnapshot, event: AnyEventObject, actorScope: AnyActorScope, actions: AnyAction[]): [AnyMachineSnapshot, ExecutableActionObject[]];
 export declare function createEnqueueObject(props: Partial<EnqueueObject<any, any>>, action: <T extends (...args: any[]) => any>(fn: T, ...args: Parameters<T>) => void): EnqueueObject<any, any>;

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

@@ -5,7 +5,7 @@ import { AsyncActorLogic } from "./actors/promise.js";
 import type { Actor } from "./createActor.js";
 import { InspectionEvent } from "./inspection.js";
 import { Spawner } from "./spawn.js";
-import { AnyActorSystem, Clock } from "./system.js";
+import type { ActorSystemRuntime, AnyActorSystem, Clock } from "./system.js";
 import { Implementations, Next_StateNodeConfig } from "./types.v6.js";
 import { StandardSchemaV1 } from "./schema.types.js";
 import { builtInActions } from "./actions.js";
@@ -486,50 +486,27 @@ export interface StateConfig<TContext extends MachineContext, TEvent extends Eve
     context: TContext;
     historyValue?: HistoryValue;
     children: Record<string, AnyActorRef | undefined>;
+    timers?: Record<string, LogicalTimer>;
     status: SnapshotStatus;
     output?: any;
     error?: unknown;
     machine?: StateMachine<TContext, TEvent, any, any, any, any, any, any, any, any, any, any, any, any>;
 }
-/**
- * A pending effect (delayed event/transition that has not fired yet) captured
- * in a persisted snapshot — a serialized built-in action descriptor plus its
- * runtime progress, with enough information to restore it under any strategy.
- */
-export interface PendingEffect {
-    /** The serialized built-in action type for this effect. */
-    type: '@xstate.raise';
-    event: EventObject;
+/** A deterministic delayed-delivery declaration owned by a logic snapshot. */
+export interface LogicalTimer {
     id: string;
-    /** The original delay (in ms) the effect was scheduled with. */
     delay: number;
-    /** Wall-clock timestamp (ms) when the effect was scheduled. */
-    startedAt: number;
-    /** Wall-clock time (ms) that had elapsed when the snapshot was persisted. */
-    elapsed: number;
+    type: '@xstate.raise' | '@xstate.sendTo';
+    event: EventObject;
+    /** `self` or the logical actor that will receive `event`. */
+    target: 'self' | AnyActor;
+}
+/** The logical input delivered to a timer's source when its runtime delay ends. */
+export interface TimerEvent extends EventObject {
+    type: 'xstate.timer';
+    id: string;
 }
-/**
- * How pending effects (timers) from a persisted snapshot are restored on
- * `actor.start()`:
- *
- * - `'resume'` (default) — the clock was "frozen" while persisted: a 5-minute
- *   timer persisted with 1 minute elapsed fires after 4 more minutes.
- * - `'restart'` — timers start over with their full delay.
- * - `'absolute'` — timers honor the original wall-clock expiry (`startedAt +
- *   delay`); already-expired timers fire immediately.
- * - A custom function receiving the pending effect and returning the remaining
- *   delay in ms.
- */
-export type TimersRestoreStrategy = 'resume' | 'restart' | 'absolute' | ((pendingEffect: PendingEffect) => number);
 export interface ActorOptions<TLogic extends AnyActorLogic> {
-    /**
-     * How pending timers (delayed events/transitions) from a persisted `snapshot`
-     * are restored when the actor starts. Applies to this actor and (when this is
-     * the root) all rehydrated child actors.
-     *
-     * @default 'resume'
-     */
-    timers?: TimersRestoreStrategy;
     /**
      * The clock that is responsible for setting and clearing timeouts, such as
      * delayed events and transitions.
@@ -795,7 +772,7 @@ export interface ActorScope<TSnapshot extends Snapshot<unknown>, TEvent extends
     sessionId: string;
     logger: (...args: any[]) => void;
     defer: (fn: () => void) => void;
-    emit: (event: TEmitted) => void;
+    emit: (event: TEmitted) => void | PromiseLike<void>;
     system: TSystem;
     stopChild: (child: AnyActor) => void;
     actionExecutor: ActionExecutor;
@@ -822,7 +799,7 @@ export type Snapshot<TOutput> = {
     output: undefined;
     error: undefined;
 };
-export type ActorLogicTransitionResult<TSnapshot extends Snapshot<unknown>, TEffect = unknown> = [nextSnapshot: TSnapshot, effects: TEffect[]];
+export type ActorLogicTransitionResult<TSnapshot extends Snapshot<unknown>, TEffect = ExecutableActionObject> = [nextSnapshot: TSnapshot, effects: TEffect[]];
 /**
  * Represents logic which can be used by an actor.
  *
@@ -877,8 +854,12 @@ in TInput = NonReducibleUnknown, TSystem extends AnyActorSystem = AnyActorSystem
      *
      * @param snapshot - The starting state.
      * @param actorScope - The actor scope.
+     * @param options - Start metadata, including whether the snapshot was
+     *   restored.
      */
-    start?: (snapshot: TSnapshot, actorScope: ActorScope<TSnapshot, TEvent, AnyActorSystem, TEmitted>) => void;
+    start?: (snapshot: TSnapshot, actorScope: ActorScope<TSnapshot, TEvent, AnyActorSystem, TEmitted>, options?: {
+        restored: boolean;
+    }) => void;
     /**
      * Obtains the internal state of the actor in a representation which can be be
      * persisted. The persisted state can be restored by `restoreSnapshot`.
@@ -887,12 +868,6 @@ in TInput = NonReducibleUnknown, TSystem extends AnyActorSystem = AnyActorSystem
      * @returns The a representation of the internal state to be persisted.
      */
     getPersistedSnapshot: (snapshot: TSnapshot, options?: unknown) => Snapshot<unknown>;
-    /**
-     * Executes the non-action effects returned from `transition` (e.g. the
-     * effects produced by `createLogic`-based actors). Actor logic that never
-     * returns such effects can omit this.
-     */
-    executeEffects?: (effects: readonly unknown[], actorScope: ActorScope<TSnapshot, TEvent, TSystem, TEmitted>) => void;
     /**
      * Returns an event that the actor should transition with to recover from an
      * execution error, or `undefined` if the given snapshot cannot handle it.
@@ -906,9 +881,10 @@ export interface AnyActorLogic {
     initialTransition(input: any, actorScope: any): ActorLogicTransitionResult<any>;
     getInitialSnapshot(actorScope: any, input: any): any;
     restoreSnapshot?(persistedState: Snapshot<unknown>, actorScope: any): any;
-    start?(snapshot: any, actorScope: any): void;
+    start?(snapshot: any, actorScope: any, options?: {
+        restored: boolean;
+    }): void;
     getPersistedSnapshot(snapshot: any, options?: unknown): Snapshot<unknown>;
-    executeEffects?(effects: readonly unknown[], actorScope: any): void;
     getExecutionErrorEvent?(snapshot: any, error: unknown): any;
 }
 export type UnknownActorLogic = ActorLogic<any, // snapshot
@@ -1047,13 +1023,35 @@ export type ToStateValue<T extends StateSchema> = T extends {
 export interface BaseExecutableActionObject {
     params: NonReducibleUnknown;
     args: unknown[];
-    exec: (() => void) | undefined;
+    exec(runtime?: Partial<ActorSystemRuntime>): void | PromiseLike<void> | undefined;
 }
+/** The terminal result published when an actor completes or errors. */
+export type ActorTermination = {
+    status: 'done';
+    output: unknown;
+    error: undefined;
+} | {
+    status: 'error';
+    output: undefined;
+    error: unknown;
+};
 export interface CustomExecutableActionObject<TType extends string = string & {}> extends BaseExecutableActionObject {
+    kind: 'action';
     type: TType;
+    action: ((...args: any[]) => void | PromiseLike<void>) | undefined;
+}
+export interface EmitExecutableActionObject<TType extends string = string & {}> extends BaseExecutableActionObject {
+    kind: 'emit';
+    type: TType;
+    source: AnyActor;
+    event: EventObject & {
+        type: TType;
+    };
 }
 export interface SpawnExecutableActionObject extends BaseExecutableActionObject {
+    kind: 'builtin';
     type: '@xstate.spawn';
+    source: AnyActor | undefined;
     actor: AnyActor;
     id: string;
     logic: AnyActorLogic;
@@ -1062,20 +1060,26 @@ export interface SpawnExecutableActionObject extends BaseExecutableActionObject
     args: Parameters<(typeof builtInActions)['@xstate.spawn']>;
 }
 export interface StartExecutableActionObject extends BaseExecutableActionObject {
+    kind: 'builtin';
     type: '@xstate.start';
+    source: AnyActor | undefined;
     actor: AnyActor;
     id: string;
     args: Parameters<(typeof builtInActions)['@xstate.start']>;
 }
 export interface RaiseExecutableActionObject extends BaseExecutableActionObject {
+    kind: 'builtin';
     type: '@xstate.raise';
+    source: AnyActor;
     event: EventObject;
     id: string | undefined;
     delay: number | undefined;
     args: Parameters<(typeof builtInActions)['@xstate.raise']>;
 }
 export interface SendToExecutableActionObject extends BaseExecutableActionObject {
+    kind: 'builtin';
     type: '@xstate.sendTo';
+    source: AnyActor;
     target: AnyActor;
     event: EventObject;
     id: string | undefined;
@@ -1083,15 +1087,29 @@ export interface SendToExecutableActionObject extends BaseExecutableActionObject
     args: Parameters<(typeof builtInActions)['@xstate.sendTo']>;
 }
 export interface CancelExecutableActionObject extends BaseExecutableActionObject {
+    kind: 'builtin';
     type: '@xstate.cancel';
+    source: AnyActor;
     id: string;
     args: Parameters<(typeof builtInActions)['@xstate.cancel']>;
 }
 export interface StopExecutableActionObject extends BaseExecutableActionObject {
+    kind: 'builtin';
     type: '@xstate.stop';
+    source: AnyActor;
     actor: AnyActor;
+    id: string;
     args: Parameters<(typeof builtInActions)['@xstate.stop']>;
 }
+/** An executable effect that publishes an actor's terminal result. */
+export type TerminateExecutableActionObject = BaseExecutableActionObject & {
+    kind: 'builtin';
+    type: '@xstate.terminate';
+    source: AnyActor;
+    actor: AnyActor;
+    id: string;
+    args: Parameters<(typeof builtInActions)['@xstate.terminate']>;
+} & ActorTermination;
 export type BuiltInExecutableActionObject = Values<{
     '@xstate.spawn': SpawnExecutableActionObject;
     '@xstate.start': StartExecutableActionObject;
@@ -1099,16 +1117,17 @@ export type BuiltInExecutableActionObject = Values<{
     '@xstate.sendTo': SendToExecutableActionObject;
     '@xstate.cancel': CancelExecutableActionObject;
     '@xstate.stop': StopExecutableActionObject;
+    '@xstate.terminate': TerminateExecutableActionObject;
 }>;
 export type SpecialExecutableAction = BuiltInExecutableActionObject;
-type TransitionExecutableActionObject<TType extends string = never> = BuiltInExecutableActionObject | CustomExecutableActionObject<TType | (string & {})>;
+type TransitionExecutableActionObject<TType extends string = never> = BuiltInExecutableActionObject | EmitExecutableActionObject | CustomExecutableActionObject<TType | (string & {})>;
 type KnownImplementationKeys<TImplementationMap> = string extends keyof TImplementationMap ? never : Extract<keyof TImplementationMap, string>;
 export type ExecutableActionObjectFromLogic<T extends AnyActorLogic> = T extends StateMachine<any, any, any, any, any, any, any, any, any, any, infer TActionMap, any, any, any> ? TransitionExecutableActionObject<KnownImplementationKeys<TActionMap>> : ExecutableActionObject;
-export type ExecutableActionObject<TType extends string = string & {}> = BuiltInExecutableActionObject | CustomExecutableActionObject<TType>;
+export type ExecutableActionObject<TType extends string = string & {}> = BuiltInExecutableActionObject | EmitExecutableActionObject | CustomExecutableActionObject<TType>;
 export interface ToExecutableAction<T extends ParameterizedObject> extends CustomExecutableActionObject<T['type']> {
     type: T['type'];
     params: T['params'];
-    exec: undefined;
+    action: undefined;
 }
 export type ActionExecutor = (actionToExecute: ExecutableActionObject) => void;
 /** Mappers for subscribeTo - maps lifecycle events to machine events */