xstate 6.0.0-alpha.54 → 6.0.0-alpha.55

package/dist/{createActor-72c06d5c.development.cjs.js → createActor-2213c48b.development.cjs.js}

@@ -4144,7 +4144,10 @@ function toObserver(nextHandler, errorHandler, completionHandler) {
   return {
     next: (isObserver ? nextHandler.next : nextHandler)?.bind(self),
     error: (isObserver ? nextHandler.error : errorHandler)?.bind(self),
-    complete: (isObserver ? nextHandler.complete : completionHandler)?.bind(self)
+    complete: (isObserver ? nextHandler.complete : completionHandler)?.bind(self),
+    ...(isObserver && nextHandler.passive ? {
+      passive: true
+    } : {})
   };
 }
 function createInvokeId(stateNodeId, index) {
@@ -5051,6 +5054,8 @@ class Actor {
     this.mailbox = void 0;
     this._mailboxStarted = false;
     this.observers = void 0;
+    /** Whether a consumer subscribed to this actor's error after it errored. */
+    this._errorObserved = false;
     this.eventListeners = void 0;
     this.logger = void 0;
     /** @internal */
@@ -5245,7 +5250,15 @@ class Actor {
       const saveExecutingCustomAction = executingCustomAction;
       try {
         executingCustomAction = true;
-        void action.exec();
+        const result = action.exec();
+        if (result && typeof result.then === 'function') {
+          void Promise.resolve(result).catch(err => {
+            if (this._processingStatus === ProcessingStatus.Stopped) {
+              return;
+            }
+            this._recoverOrError(err);
+          });
+        }
       } finally {
         executingCustomAction = saveExecutingCustomAction;
       }
@@ -5455,6 +5468,9 @@ class Actor {
             if (!observer.error) {
               reportUnhandledError(err);
             } else {
+              if (!observer.passive) {
+                this._errorObserved = true;
+              }
               safeCall(observer.error, err);
             }
             break;
@@ -5709,22 +5725,41 @@ class Actor {
     this.observers?.clear();
     this.eventListeners?.clear();
   }
+
+  /**
+   * Reports an unhandled error unless a consumer observes it before the
+   * report runs. An actor can error before its creator has a chance to
+   * subscribe, so the check waits one macrotask for a subscriber with an
+   * `error` callback.
+   */
+  _reportUnlessObserved(err) {
+    setTimeout(() => {
+      if (!this._errorObserved) {
+        reportUnhandledError(err);
+      }
+    });
+  }
   _error(err) {
     this._stopProcedure();
     if (!this.observers?.size) {
       if (!this._parent) {
-        reportUnhandledError(err);
+        this._reportUnlessObserved(err);
       }
     } else {
       let reportError = false;
+      let handled = false;
       for (const observer of this.observers) {
         const errorListener = observer.error;
-        reportError ||= !errorListener;
+        if (!observer.passive) {
+          reportError ||= !errorListener;
+          handled ||= !!errorListener;
+        }
         safeCall(errorListener, err);
       }
+      reportError ||= !handled;
       this.observers.clear();
       if (reportError) {
-        reportUnhandledError(err);
+        this._reportUnlessObserved(err);
       }
     }
     this.eventListeners?.clear();

package/dist/{createActor-04e2ee20.development.esm.js → createActor-3dc6cdb7.development.esm.js}

@@ -4142,7 +4142,10 @@ function toObserver(nextHandler, errorHandler, completionHandler) {
   return {
     next: (isObserver ? nextHandler.next : nextHandler)?.bind(self),
     error: (isObserver ? nextHandler.error : errorHandler)?.bind(self),
-    complete: (isObserver ? nextHandler.complete : completionHandler)?.bind(self)
+    complete: (isObserver ? nextHandler.complete : completionHandler)?.bind(self),
+    ...(isObserver && nextHandler.passive ? {
+      passive: true
+    } : {})
   };
 }
 function createInvokeId(stateNodeId, index) {
@@ -5049,6 +5052,8 @@ class Actor {
     this.mailbox = void 0;
     this._mailboxStarted = false;
     this.observers = void 0;
+    /** Whether a consumer subscribed to this actor's error after it errored. */
+    this._errorObserved = false;
     this.eventListeners = void 0;
     this.logger = void 0;
     /** @internal */
@@ -5243,7 +5248,15 @@ class Actor {
       const saveExecutingCustomAction = executingCustomAction;
       try {
         executingCustomAction = true;
-        void action.exec();
+        const result = action.exec();
+        if (result && typeof result.then === 'function') {
+          void Promise.resolve(result).catch(err => {
+            if (this._processingStatus === ProcessingStatus.Stopped) {
+              return;
+            }
+            this._recoverOrError(err);
+          });
+        }
       } finally {
         executingCustomAction = saveExecutingCustomAction;
       }
@@ -5453,6 +5466,9 @@ class Actor {
             if (!observer.error) {
               reportUnhandledError(err);
             } else {
+              if (!observer.passive) {
+                this._errorObserved = true;
+              }
               safeCall(observer.error, err);
             }
             break;
@@ -5707,22 +5723,41 @@ class Actor {
     this.observers?.clear();
     this.eventListeners?.clear();
   }
+
+  /**
+   * Reports an unhandled error unless a consumer observes it before the
+   * report runs. An actor can error before its creator has a chance to
+   * subscribe, so the check waits one macrotask for a subscriber with an
+   * `error` callback.
+   */
+  _reportUnlessObserved(err) {
+    setTimeout(() => {
+      if (!this._errorObserved) {
+        reportUnhandledError(err);
+      }
+    });
+  }
   _error(err) {
     this._stopProcedure();
     if (!this.observers?.size) {
       if (!this._parent) {
-        reportUnhandledError(err);
+        this._reportUnlessObserved(err);
       }
     } else {
       let reportError = false;
+      let handled = false;
       for (const observer of this.observers) {
         const errorListener = observer.error;
-        reportError ||= !errorListener;
+        if (!observer.passive) {
+          reportError ||= !errorListener;
+          handled ||= !!errorListener;
+        }
         safeCall(errorListener, err);
       }
+      reportError ||= !handled;
       this.observers.clear();
       if (reportError) {
-        reportUnhandledError(err);
+        this._reportUnlessObserved(err);
       }
     }
     this.eventListeners?.clear();

package/dist/{createActor-54b4caed.cjs.js → createActor-c4723a2b.cjs.js}

@@ -4120,7 +4120,10 @@ function toObserver(nextHandler, errorHandler, completionHandler) {
   return {
     next: (isObserver ? nextHandler.next : nextHandler)?.bind(self),
     error: (isObserver ? nextHandler.error : errorHandler)?.bind(self),
-    complete: (isObserver ? nextHandler.complete : completionHandler)?.bind(self)
+    complete: (isObserver ? nextHandler.complete : completionHandler)?.bind(self),
+    ...(isObserver && nextHandler.passive ? {
+      passive: true
+    } : {})
   };
 }
 function createInvokeId(stateNodeId, index) {
@@ -5018,6 +5021,8 @@ class Actor {
     this.mailbox = void 0;
     this._mailboxStarted = false;
     this.observers = void 0;
+    /** Whether a consumer subscribed to this actor's error after it errored. */
+    this._errorObserved = false;
     this.eventListeners = void 0;
     this.logger = void 0;
     /** @internal */
@@ -5212,7 +5217,15 @@ class Actor {
       const saveExecutingCustomAction = executingCustomAction;
       try {
         executingCustomAction = true;
-        void action.exec();
+        const result = action.exec();
+        if (result && typeof result.then === 'function') {
+          void Promise.resolve(result).catch(err => {
+            if (this._processingStatus === ProcessingStatus.Stopped) {
+              return;
+            }
+            this._recoverOrError(err);
+          });
+        }
       } finally {
         executingCustomAction = saveExecutingCustomAction;
       }
@@ -5422,6 +5435,9 @@ class Actor {
             if (!observer.error) {
               reportUnhandledError(err);
             } else {
+              if (!observer.passive) {
+                this._errorObserved = true;
+              }
               safeCall(observer.error, err);
             }
             break;
@@ -5676,22 +5692,41 @@ class Actor {
     this.observers?.clear();
     this.eventListeners?.clear();
   }
+
+  /**
+   * Reports an unhandled error unless a consumer observes it before the
+   * report runs. An actor can error before its creator has a chance to
+   * subscribe, so the check waits one macrotask for a subscriber with an
+   * `error` callback.
+   */
+  _reportUnlessObserved(err) {
+    setTimeout(() => {
+      if (!this._errorObserved) {
+        reportUnhandledError(err);
+      }
+    });
+  }
   _error(err) {
     this._stopProcedure();
     if (!this.observers?.size) {
       if (!this._parent) {
-        reportUnhandledError(err);
+        this._reportUnlessObserved(err);
       }
     } else {
       let reportError = false;
+      let handled = false;
       for (const observer of this.observers) {
         const errorListener = observer.error;
-        reportError ||= !errorListener;
+        if (!observer.passive) {
+          reportError ||= !errorListener;
+          handled ||= !!errorListener;
+        }
         safeCall(errorListener, err);
       }
+      reportError ||= !handled;
       this.observers.clear();
       if (reportError) {
-        reportUnhandledError(err);
+        this._reportUnlessObserved(err);
       }
     }
     this.eventListeners?.clear();

package/dist/{createActor-a7b9d1be.esm.js → createActor-c7c704c2.esm.js}

@@ -4118,7 +4118,10 @@ function toObserver(nextHandler, errorHandler, completionHandler) {
   return {
     next: (isObserver ? nextHandler.next : nextHandler)?.bind(self),
     error: (isObserver ? nextHandler.error : errorHandler)?.bind(self),
-    complete: (isObserver ? nextHandler.complete : completionHandler)?.bind(self)
+    complete: (isObserver ? nextHandler.complete : completionHandler)?.bind(self),
+    ...(isObserver && nextHandler.passive ? {
+      passive: true
+    } : {})
   };
 }
 function createInvokeId(stateNodeId, index) {
@@ -5016,6 +5019,8 @@ class Actor {
     this.mailbox = void 0;
     this._mailboxStarted = false;
     this.observers = void 0;
+    /** Whether a consumer subscribed to this actor's error after it errored. */
+    this._errorObserved = false;
     this.eventListeners = void 0;
     this.logger = void 0;
     /** @internal */
@@ -5210,7 +5215,15 @@ class Actor {
       const saveExecutingCustomAction = executingCustomAction;
       try {
         executingCustomAction = true;
-        void action.exec();
+        const result = action.exec();
+        if (result && typeof result.then === 'function') {
+          void Promise.resolve(result).catch(err => {
+            if (this._processingStatus === ProcessingStatus.Stopped) {
+              return;
+            }
+            this._recoverOrError(err);
+          });
+        }
       } finally {
         executingCustomAction = saveExecutingCustomAction;
       }
@@ -5420,6 +5433,9 @@ class Actor {
             if (!observer.error) {
               reportUnhandledError(err);
             } else {
+              if (!observer.passive) {
+                this._errorObserved = true;
+              }
               safeCall(observer.error, err);
             }
             break;
@@ -5674,22 +5690,41 @@ class Actor {
     this.observers?.clear();
     this.eventListeners?.clear();
   }
+
+  /**
+   * Reports an unhandled error unless a consumer observes it before the
+   * report runs. An actor can error before its creator has a chance to
+   * subscribe, so the check waits one macrotask for a subscriber with an
+   * `error` callback.
+   */
+  _reportUnlessObserved(err) {
+    setTimeout(() => {
+      if (!this._errorObserved) {
+        reportUnhandledError(err);
+      }
+    });
+  }
   _error(err) {
     this._stopProcedure();
     if (!this.observers?.size) {
       if (!this._parent) {
-        reportUnhandledError(err);
+        this._reportUnlessObserved(err);
       }
     } else {
       let reportError = false;
+      let handled = false;
       for (const observer of this.observers) {
         const errorListener = observer.error;
-        reportError ||= !errorListener;
+        if (!observer.passive) {
+          reportError ||= !errorListener;
+          handled ||= !!errorListener;
+        }
         safeCall(errorListener, err);
       }
+      reportError ||= !handled;
       this.observers.clear();
       if (reportError) {
-        reportUnhandledError(err);
+        this._reportUnlessObserved(err);
       }
     }
     this.eventListeners?.clear();

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

@@ -20,6 +20,14 @@ export declare class StateMachine<TContext extends MachineContext, TEvent extend
         internalEvents?: readonly string[];
     };
     validator?: ActorLogicValidator | undefined;
+    /**
+     * Type-level carriers for the machine's source maps and state schema. Type
+     * helpers in integration packages read these to walk a machine's declared
+     * actions, actors and invoked sources. They are never assigned at runtime.
+     */
+    readonly _actionMap: TActionMap;
+    readonly _actorMap: TActorMap;
+    readonly _stateSchema: TConfig;
     /** The machine's own version. */
     version?: string;
     schemas: AnyMachineSchemas | undefined;

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

@@ -38,6 +38,8 @@ export declare class Actor<TLogic extends AnyActorLogic> implements ActorInstanc
     private mailbox?;
     private _mailboxStarted;
     private observers?;
+    /** Whether a consumer subscribed to this actor's error after it errored. */
+    private _errorObserved;
     private eventListeners;
     private logger;
     private _forceDeferredActions;
@@ -161,6 +163,13 @@ export declare class Actor<TLogic extends AnyActorLogic> implements ActorInstanc
     /** Stops the Actor and unsubscribe all listeners. */
     stop(): this;
     private _complete;
+    /**
+     * Reports an unhandled error unless a consumer observes it before the
+     * report runs. An actor can error before its creator has a chance to
+     * subscribe, so the check waits one macrotask for a subscriber with an
+     * `error` callback.
+     */
+    private _reportUnlessObserved;
     private _error;
     private _stopProcedure;
     /**

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

@@ -2,7 +2,7 @@ import { SetupStateSchemas, StandardSchemaV1 } from "./schema.types.js";
 import type { ActorLogicValidator } from "./validation.types.js";
 import { StateMachine } from "./StateMachine.js";
 import { type Actor, type RequiredActorOptionsKeys } from "./createActor.js";
-import { AnyActorRef, AnyActorLogic, ActorRefFromLogic, AnyStateNode, EventObject, AnyEventObject, EventDescriptor, ExtractEvent, MachineContext, ProvidedActor, RoutableStateId, StateSchema, StateValue, StateValueFromStateSchema, ToChildren, MetaObject, Cast, Compute, EnqueueObject, DoneActorEvent, DoneStateEvent, ErrorActorEvent, SystemRegistry, RegistryKeyForLogic, ActorOptions, Observer, Subscription, OutputArg, SnapshotEvent, SingleOrArray, AfterEvent, TimeoutEvent, ErrorEvent } from "./types.js";
+import { AnyActorRef, AnyActorLogic, ActorRefFromLogic, AnyStateNode, EventObject, AnyEventObject, EventDescriptor, ExtractEvent, MachineContext, ProvidedActor, RoutableStateId, StateSchema, StateValue, StateValueFromStateSchema, ToChildren, MetaObject, Cast, Compute, EnqueueObject, DoneActorEvent, DoneStateEvent, ErrorFrom, ErrorActorEvent, SystemRegistry, RegistryKeyForLogic, ActorOptions, Observer, Subscription, OutputArg, SnapshotEvent, SingleOrArray, AfterEvent, TimeoutEvent, ErrorEvent } from "./types.js";
 import { AnyActorSystem } from "./system.js";
 import { InspectionEvent } from "./inspection.js";
 import { ActionSchemas, DelayMapFromNames, DelaySourceMap, GuardSourceMap, GuardSchemas, InferChildren, InferActions, InferGuards, Sources, InferOutput, InferEvents, InferInternalEvents, Next_MachineConfig, Next_InvokeConfig, Next_StateNodeConfig, Next_TransitionConfigOrTarget, OutputFromConfig, ValidateHistoryDefaults, ValidateStateTargets, WithDefault } from "./types.v6.js";
@@ -507,9 +507,10 @@ type StateContext<TStateSchema extends SetupStateSchema, TFallbackContext extend
     context: infer TContextSchema;
 } ? TContextSchema extends StandardSchemaV1 ? StandardSchemaV1.InferOutput<TContextSchema> & RootContext<TFallbackContext> & MachineContext & RootContextMarker<TFallbackContext> : RootContext<TFallbackContext> : RootContext<TFallbackContext>;
 declare const rootContext: unique symbol;
-type RootContextMarker<TContext> = {
+/** @public Referenced by emitted declarations of narrowed state contexts. */
+export interface RootContextMarker<TContext> {
     readonly [rootContext]?: RootContext<TContext>;
-};
+}
 type RootContext<TContext> = typeof rootContext extends keyof TContext ? TContext[typeof rootContext] : TContext;
 type StateContextShape<TStateSchema extends SetupStateSchema, TFallbackContext> = TStateSchema['schemas'] extends {
     context: infer TContextSchema;
@@ -908,10 +909,13 @@ type SetupInvokeConfig<TStateSchemas extends Record<string, SetupStateSchema>, T
     } ? [
         Extract<NonNullable<TOnDone>, (...args: any[]) => unknown>
     ] extends [never] ? undefined | StateTransitionObjectConfig<TStateSchemas, TContext, TContextShape, DoneActorEvent, TChildren, TMeta, TActionMap, TActorMap, TGuardMap, TDelayMap, TSystemRegistry, false> : StateTransitionConfigOrTarget<TStateSchemas, TContext, TContextShape, InvokeDoneEvent<TInvoke>, TEvent, TEmitted, TChildren, TMeta, TActionMap, TActorMap, TGuardMap, TDelayMap, TSystemRegistry> : never;
-    onError?: StateTransitionConfigOrTarget<TStateSchemas, TContext, TContextShape, ErrorActorEvent, TEvent, TEmitted, TChildren, TMeta, TActionMap, TActorMap, TGuardMap, TDelayMap, TSystemRegistry>;
+    onError?: StateTransitionConfigOrTarget<TStateSchemas, TContext, TContextShape, InvokeErrorEvent<TInvoke, TActorMap>, TEvent, TEmitted, TChildren, TMeta, TActionMap, TActorMap, TGuardMap, TDelayMap, TSystemRegistry>;
     onSnapshot?: StateTransitionConfigOrTarget<TStateSchemas, TContext, TContextShape, SnapshotEvent<any>, TEvent, TEmitted, TChildren, TMeta, TActionMap, TActorMap, TGuardMap, TDelayMap, TSystemRegistry>;
     onTimeout?: StateTransitionConfigOrTarget<TStateSchemas, TContext, TContextShape, TEvent, TEvent, TEmitted, TChildren, TMeta, TActionMap, TActorMap, TGuardMap, TDelayMap, TSystemRegistry>;
 } : never : never;
+type InvokeErrorEvent<TInvoke, TActorMap extends Sources['actors']> = TInvoke extends {
+    src: infer TSrc;
+} ? TSrc extends keyof TActorMap & string ? ErrorActorEvent<ErrorFrom<TActorMap[TSrc]>> : TSrc extends AnyActorLogic ? ErrorActorEvent<ErrorFrom<TSrc>> : ErrorActorEvent : ErrorActorEvent;
 type StateTransitionConfigOrTarget<TStateSchemas extends Record<string, SetupStateSchema>, TContext extends MachineContext, TContextShape, TExpressionEvent extends EventObject, TEvent extends EventObject, TEmitted extends EventObject, TChildren extends Record<string, AnyActorRef | undefined>, TMeta extends MetaObject, TActionMap extends Sources['actions'], TActorMap extends Sources['actors'], TGuardMap extends Sources['guards'], TDelayMap extends Sources['delays'], TSystemRegistry extends SystemRegistry, TInput = undefined, TTarget extends string = SetupStateTarget<TStateSchemas>, TKnownTarget extends string = KnownSetupStateTarget<TStateSchemas>> = undefined | StateTransitionObjectConfig<TStateSchemas, TContext, TContextShape, TExpressionEvent, TChildren, TMeta, TActionMap, TActorMap, TGuardMap, TDelayMap, TSystemRegistry, true, TTarget, TKnownTarget> | StateTransitionFunction<TStateSchemas, TContext, TContextShape, TExpressionEvent, TEvent, TEmitted, TChildren, TMeta, TActionMap, TActorMap, TGuardMap, TDelayMap, TSystemRegistry, TInput, TTarget, TKnownTarget>;
 type StateTransitionObjectConfig<TStateSchemas extends Record<string, SetupStateSchema>, TContext extends MachineContext, TContextShape, TExpressionEvent extends EventObject, TChildren extends Record<string, AnyActorRef | undefined>, TMeta extends MetaObject, TActionMap extends Sources['actions'], TActorMap extends Sources['actors'], TGuardMap extends Sources['guards'], TDelayMap extends Sources['delays'], TSystemRegistry extends SystemRegistry, TAllowContextMapper extends boolean = true, TTarget extends string = SetupStateTarget<TStateSchemas>, TKnownTarget extends string = KnownSetupStateTarget<TStateSchemas>> = (StateTransitionResult<TStateSchemas, TContext, TContextShape, TMeta, TExpressionEvent, TChildren, TActionMap, TActorMap, TGuardMap, TDelayMap, TSystemRegistry, TAllowContextMapper, TTarget, TKnownTarget> & {
     description?: string;

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

@@ -107,6 +107,12 @@ export type OutputFrom<T> = T extends ActorLogic<infer TSnapshot, infer _TEvent,
 })['output'] : T extends ActorRef<infer TSnapshot, infer _TEvent, infer _TEmitted> ? (TSnapshot & {
     status: 'done';
 })['output'] : never;
+type ErrorFromSnapshot<TSnapshot> = TSnapshot extends {
+    error: infer TError;
+} ? Exclude<TError, undefined> : unknown;
+export type ErrorFrom<T> = T extends {
+    transition: (snapshot: infer TSnapshot, ...args: any[]) => any;
+} ? ErrorFromSnapshot<TSnapshot> : T extends ActorRef<infer TSnapshot, infer _TEvent, infer _TEmitted> ? ErrorFromSnapshot<TSnapshot> : never;
 export type NoRequiredParams<T extends ParameterizedObject> = T extends any ? undefined extends T['params'] ? T['type'] : never : never;
 export type ConditionalRequired<T, Condition extends boolean> = Condition extends true ? Required<T> : T;
 export type WithDynamicParams<TContext extends MachineContext, TExpressionEvent extends EventObject, T extends ParameterizedObject> = T extends any ? ConditionalRequired<{
@@ -769,6 +775,13 @@ export type Observer<T> = {
     next?: (value: T) => void;
     error?: (err: unknown) => void;
     complete?: () => void;
+    /**
+     * Marks an observer that only tracks the actor's lifecycle, such as one
+     * installed by a runtime integration. A passive observer does not count as
+     * an error handler: an unhandled actor error is still reported when every
+     * observer with an `error` callback is passive.
+     */
+    passive?: boolean;
 };
 export interface Subscription {
     unsubscribe(): void;

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

@@ -1,6 +1,6 @@
 import { SetupStateSchemas, StandardSchemaV1, TypeSchema } from "./schema.types.js";
 import { MachineSnapshot } from "./State.js";
-import { Action, ActorTimeoutEvent, AfterEvent, ActorLogic, ActorRef, ActorRefFromLogic, ActorSelf, AnyActorLogic, AnyActorRef, Compute, DoneActorEvent, DoNotInfer, ErrorActorEvent, EnqueueObject, EventDescriptor, ErrorEvent, EventObject, EventPayloadPattern, ExtractEvent, InitialContext, InputFrom, IsNever, MetaObject, NonReducibleUnknown, OutputFrom, SingleOrArray, SnapshotEvent, StateValue, TODO, TransitionContextMapper, TransitionContextPatch, TransitionConfigFunction, Values, AnyStateNode, SystemRegistry, TimeoutEvent } from "./types.js";
+import { Action, ActorTimeoutEvent, AfterEvent, ActorLogic, ActorRef, ActorRefFromLogic, ActorSelf, AnyActorLogic, AnyActorRef, Compute, DoneActorEvent, DoNotInfer, ErrorFrom, ErrorActorEvent, EnqueueObject, EventDescriptor, ErrorEvent, EventObject, EventPayloadPattern, ExtractEvent, InitialContext, InputFrom, IsNever, MetaObject, NonReducibleUnknown, OutputFrom, SingleOrArray, SnapshotEvent, StateValue, TODO, TransitionContextMapper, TransitionContextPatch, TransitionConfigFunction, Values, AnyStateNode, SystemRegistry, TimeoutEvent } from "./types.js";
 import { MachineContext, Mapper } from "./types.js";
 import { LowInfer } from "./types.js";
 import { DoneStateEvent } from "./types.js";
@@ -240,7 +240,7 @@ export type Next_InvokeConfig<TContext extends MachineContext, TEvent extends Ev
     src: string | AnyActorLogic | ((args: InvokeSrcArgs<TContext, TEvent, TActorMap>) => string | AnyActorLogic);
     input?: ((args: InvokeInputArgs<TContext, TEvent, TEmitted, TChildren, TInput>) => unknown) | NonReducibleUnknown;
 } : {
-    [K in keyof TActorMap & string]: Next_InvokeConfigBase<TContext, TEvent, TEmitted, TChildren, TActionMap, TActorMap, TGuardMap, TDelayMap, TMeta, TSystemRegistry, DoneActorEvent<OutputFrom<TActorMap[K]>>> & {
+    [K in keyof TActorMap & string]: Next_InvokeConfigBase<TContext, TEvent, TEmitted, TChildren, TActionMap, TActorMap, TGuardMap, TDelayMap, TMeta, TSystemRegistry, DoneActorEvent<OutputFrom<TActorMap[K]>>, ErrorActorEvent<ErrorFrom<TActorMap[K]>>> & {
         id?: ChildIdForLogic<TActorMap[K], TChildren>;
         input?: ((args: InvokeInputArgs<TContext, TEvent, TEmitted, TChildren, TInput>) => InputFrom<TActorMap[K]>) | InputFrom<TActorMap[K]>;
     } & ({
@@ -251,11 +251,11 @@ export type Next_InvokeConfig<TContext extends MachineContext, TEvent extends Ev
         src: (args: InvokeSrcArgs<TContext, TEvent, TActorMap>) => K | TActorMap[K];
     });
 }[keyof TActorMap & string] | InlineInvokeConfig<TContext, TEvent, TEmitted, TChildren, TActionMap, TActorMap, TGuardMap, TDelayMap, TMeta, TSystemRegistry, TInput>;
-interface Next_InvokeConfigBase<TContext extends MachineContext, TEvent extends EventObject, TEmitted extends EventObject, TChildren extends Record<string, AnyActorRef | undefined>, TActionMap extends Sources['actions'], TActorMap extends Sources['actors'], TGuardMap extends Sources['guards'], TDelayMap extends Sources['delays'], TMeta extends MetaObject, TSystemRegistry extends SystemRegistry, TDoneEvent extends EventObject = [keyof TActorMap & string] extends [never] ? DoneActorEvent<any> : DoneActorEvent<OutputFrom<TActorMap[keyof TActorMap & string]>>> {
+interface Next_InvokeConfigBase<TContext extends MachineContext, TEvent extends EventObject, TEmitted extends EventObject, TChildren extends Record<string, AnyActorRef | undefined>, TActionMap extends Sources['actions'], TActorMap extends Sources['actors'], TGuardMap extends Sources['guards'], TDelayMap extends Sources['delays'], TMeta extends MetaObject, TSystemRegistry extends SystemRegistry, TDoneEvent extends EventObject = [keyof TActorMap & string] extends [never] ? DoneActorEvent<any> : DoneActorEvent<OutputFrom<TActorMap[keyof TActorMap & string]>>, TErrorEvent extends EventObject = [keyof TActorMap & string] extends [never] ? ErrorActorEvent<any> : ErrorActorEvent<ErrorFrom<TActorMap[keyof TActorMap & string]>>> {
     id?: string;
     registryKey?: keyof TSystemRegistry & string;
     onDone?: Next_TransitionConfigOrTarget<TContext, TDoneEvent, TEvent, TEmitted, TActionMap, TActorMap, TGuardMap, TDelayMap, TMeta, undefined, TChildren>;
-    onError?: Next_TransitionConfigOrTarget<TContext, ErrorActorEvent, TEvent, TEmitted, TActionMap, TActorMap, TGuardMap, TDelayMap, TMeta, undefined, TChildren>;
+    onError?: Next_TransitionConfigOrTarget<TContext, TErrorEvent, TEvent, TEmitted, TActionMap, TActorMap, TGuardMap, TDelayMap, TMeta, undefined, TChildren>;
     onSnapshot?: Next_TransitionConfigOrTarget<TContext, SnapshotEvent<any>, TEvent, TEmitted, TActionMap, TActorMap, TGuardMap, TDelayMap, TMeta, undefined, TChildren>;
     /**
      * The duration (in ms) after which this invocation will time out if it has

package/dist/{effectDescriptor-66968b91.cjs.js → effectDescriptor-3121155c.cjs.js}

@@ -1,6 +1,6 @@
 'use strict';
 
-var createActor = require('./createActor-54b4caed.cjs.js');
+var createActor = require('./createActor-c4723a2b.cjs.js');
 
 function attachMicrostepActorRefs(microsteps, actorScope, inputSnapshot) {
   if (!microsteps.length) {

package/dist/{effectDescriptor-8ab6c005.development.esm.js → effectDescriptor-95202c94.development.esm.js}

@@ -1,4 +1,4 @@
-import { a3 as createInertActorScope, a4 as setInertActorScopeSnapshot, F as finalizeTransitionResult, a6 as attachSnapshotActorRef, y as createInitEvent, av as hasAmbientInspector, a5 as beginSpawnAllocation, a7 as macrostep, ak as createSpawnEffect, al as initialMicrostep, i as isAtomicStateNode, aw as getProperAncestors, ax as isRemoteActorRef, ay as getActorIdPrefix } from './createActor-04e2ee20.development.esm.js';
+import { a3 as createInertActorScope, a4 as setInertActorScopeSnapshot, F as finalizeTransitionResult, a6 as attachSnapshotActorRef, y as createInitEvent, av as hasAmbientInspector, a5 as beginSpawnAllocation, a7 as macrostep, ak as createSpawnEffect, al as initialMicrostep, i as isAtomicStateNode, aw as getProperAncestors, ax as isRemoteActorRef, ay as getActorIdPrefix } from './createActor-3dc6cdb7.development.esm.js';
 
 function attachMicrostepActorRefs(microsteps, actorScope, inputSnapshot) {
   if (!microsteps.length) {

package/dist/{effectDescriptor-de20c07d.esm.js → effectDescriptor-9cb5c006.esm.js}

@@ -1,4 +1,4 @@
-import { a3 as createInertActorScope, a4 as setInertActorScopeSnapshot, F as finalizeTransitionResult, a6 as attachSnapshotActorRef, y as createInitEvent, av as hasAmbientInspector, a5 as beginSpawnAllocation, a7 as macrostep, ak as createSpawnEffect, al as initialMicrostep, i as isAtomicStateNode, aw as getProperAncestors, ax as isRemoteActorRef, ay as getActorIdPrefix } from './createActor-a7b9d1be.esm.js';
+import { a3 as createInertActorScope, a4 as setInertActorScopeSnapshot, F as finalizeTransitionResult, a6 as attachSnapshotActorRef, y as createInitEvent, av as hasAmbientInspector, a5 as beginSpawnAllocation, a7 as macrostep, ak as createSpawnEffect, al as initialMicrostep, i as isAtomicStateNode, aw as getProperAncestors, ax as isRemoteActorRef, ay as getActorIdPrefix } from './createActor-c7c704c2.esm.js';
 
 function attachMicrostepActorRefs(microsteps, actorScope, inputSnapshot) {
   if (!microsteps.length) {

package/dist/{effectDescriptor-ff81f016.development.cjs.js → effectDescriptor-c0976206.development.cjs.js}

@@ -1,6 +1,6 @@
 'use strict';
 
-var createActor = require('./createActor-72c06d5c.development.cjs.js');
+var createActor = require('./createActor-2213c48b.development.cjs.js');
 
 function attachMicrostepActorRefs(microsteps, actorScope, inputSnapshot) {
   if (!microsteps.length) {

package/dist/{types-e1c553c1.development.esm.js → types-33de9b3d.development.esm.js}

@@ -1,4 +1,4 @@
-import { J as resolveRegisteredActorSource, K as allocateChildId, L as assertChildIdFree, M as reserveChildId, S as STATE_DELIMITER, N as mapValues, t as toArray, O as createInvokeId, P as getDelayedTransitions, Q as getEventDescriptorKey, R as getCandidates, T as evaluateCandidate, U as formatTransition, V as NULL_EVENT, W as toTransitionConfigArray, Y as createInvokeTimeoutEventId, Z as matchesActorSession, _ as formatRouteTransitions, $ as resolveStateValue, a0 as getAllStateNodes, f as getStateNodes, a1 as createMachineSnapshot, a2 as isInFinalState, a3 as createInertActorScope, a4 as setInertActorScopeSnapshot, z as createDeadLetterEffect, a5 as beginSpawnAllocation, a6 as attachSnapshotActorRef, a7 as macrostep, a8 as isInertActorScope, a9 as setSnapshotActorRef, aa as cloneMachineSnapshot, ab as transitionNode, ac as XSTATE_TIMER, m as matchesEventDescriptor, ad as getTransitionResult, ae as hasEffect, af as createErrorPlatformEvent, ag as withActorSelf, ah as resolveActionsWithContext, ai as takeSpawnAllocationCounters, aj as mergeActorIdCounters, y as createInitEvent, ak as createSpawnEffect, al as initialMicrostep, am as toStatePath, an as isStateId, ao as getStateNodeByPath, ap as getPersistedSnapshot, aq as createRemoteActorRef, ar as resolveReferencedActor, as as createInvokeTimeoutEvent, at as parseGeneratedActorId, au as ACTOR_REF_TYPE, c as createActor } from './createActor-04e2ee20.development.esm.js';
+import { J as resolveRegisteredActorSource, K as allocateChildId, L as assertChildIdFree, M as reserveChildId, S as STATE_DELIMITER, N as mapValues, t as toArray, O as createInvokeId, P as getDelayedTransitions, Q as getEventDescriptorKey, R as getCandidates, T as evaluateCandidate, U as formatTransition, V as NULL_EVENT, W as toTransitionConfigArray, Y as createInvokeTimeoutEventId, Z as matchesActorSession, _ as formatRouteTransitions, $ as resolveStateValue, a0 as getAllStateNodes, f as getStateNodes, a1 as createMachineSnapshot, a2 as isInFinalState, a3 as createInertActorScope, a4 as setInertActorScopeSnapshot, z as createDeadLetterEffect, a5 as beginSpawnAllocation, a6 as attachSnapshotActorRef, a7 as macrostep, a8 as isInertActorScope, a9 as setSnapshotActorRef, aa as cloneMachineSnapshot, ab as transitionNode, ac as XSTATE_TIMER, m as matchesEventDescriptor, ad as getTransitionResult, ae as hasEffect, af as createErrorPlatformEvent, ag as withActorSelf, ah as resolveActionsWithContext, ai as takeSpawnAllocationCounters, aj as mergeActorIdCounters, y as createInitEvent, ak as createSpawnEffect, al as initialMicrostep, am as toStatePath, an as isStateId, ao as getStateNodeByPath, ap as getPersistedSnapshot, aq as createRemoteActorRef, ar as resolveReferencedActor, as as createInvokeTimeoutEvent, at as parseGeneratedActorId, au as ACTOR_REF_TYPE, c as createActor } from './createActor-3dc6cdb7.development.esm.js';
 import { a as assertValid } from './validation-e69470ad.development.esm.js';
 
 function createSpawner(actorScope, actors, spawnedChildren) {
@@ -485,6 +485,14 @@ class StateMachine {
     this._internalEventType = void 0;
     /** @internal Type-only marker for transition metadata. */
     this._transitionMetaType = void 0;
+    /**
+     * Type-level carriers for the machine's source maps and state schema. Type
+     * helpers in integration packages read these to walk a machine's declared
+     * actions, actors and invoked sources. They are never assigned at runtime.
+     */
+    this._actionMap = void 0;
+    this._actorMap = void 0;
+    this._stateSchema = void 0;
     /** The machine's own version. */
     this.version = void 0;
     this.schemas = void 0;

package/dist/{types-a388ae30.esm.js → types-69f39448.esm.js}

@@ -1,4 +1,4 @@
-import { J as resolveRegisteredActorSource, K as allocateChildId, L as assertChildIdFree, M as reserveChildId, S as STATE_DELIMITER, N as mapValues, t as toArray, O as createInvokeId, P as getDelayedTransitions, Q as getEventDescriptorKey, R as getCandidates, T as evaluateCandidate, U as formatTransition, V as NULL_EVENT, W as toTransitionConfigArray, Y as createInvokeTimeoutEventId, Z as matchesActorSession, _ as formatRouteTransitions, $ as resolveStateValue, a0 as getAllStateNodes, f as getStateNodes, a1 as createMachineSnapshot, a2 as isInFinalState, a3 as createInertActorScope, a4 as setInertActorScopeSnapshot, z as createDeadLetterEffect, a5 as beginSpawnAllocation, a6 as attachSnapshotActorRef, a7 as macrostep, a8 as isInertActorScope, a9 as setSnapshotActorRef, aa as cloneMachineSnapshot, ab as transitionNode, ac as XSTATE_TIMER, m as matchesEventDescriptor, ad as getTransitionResult, ae as hasEffect, af as createErrorPlatformEvent, ag as withActorSelf, ah as resolveActionsWithContext, ai as takeSpawnAllocationCounters, aj as mergeActorIdCounters, y as createInitEvent, ak as createSpawnEffect, al as initialMicrostep, am as toStatePath, an as isStateId, ao as getStateNodeByPath, ap as getPersistedSnapshot, aq as createRemoteActorRef, ar as resolveReferencedActor, as as createInvokeTimeoutEvent, at as parseGeneratedActorId, au as ACTOR_REF_TYPE, c as createActor } from './createActor-a7b9d1be.esm.js';
+import { J as resolveRegisteredActorSource, K as allocateChildId, L as assertChildIdFree, M as reserveChildId, S as STATE_DELIMITER, N as mapValues, t as toArray, O as createInvokeId, P as getDelayedTransitions, Q as getEventDescriptorKey, R as getCandidates, T as evaluateCandidate, U as formatTransition, V as NULL_EVENT, W as toTransitionConfigArray, Y as createInvokeTimeoutEventId, Z as matchesActorSession, _ as formatRouteTransitions, $ as resolveStateValue, a0 as getAllStateNodes, f as getStateNodes, a1 as createMachineSnapshot, a2 as isInFinalState, a3 as createInertActorScope, a4 as setInertActorScopeSnapshot, z as createDeadLetterEffect, a5 as beginSpawnAllocation, a6 as attachSnapshotActorRef, a7 as macrostep, a8 as isInertActorScope, a9 as setSnapshotActorRef, aa as cloneMachineSnapshot, ab as transitionNode, ac as XSTATE_TIMER, m as matchesEventDescriptor, ad as getTransitionResult, ae as hasEffect, af as createErrorPlatformEvent, ag as withActorSelf, ah as resolveActionsWithContext, ai as takeSpawnAllocationCounters, aj as mergeActorIdCounters, y as createInitEvent, ak as createSpawnEffect, al as initialMicrostep, am as toStatePath, an as isStateId, ao as getStateNodeByPath, ap as getPersistedSnapshot, aq as createRemoteActorRef, ar as resolveReferencedActor, as as createInvokeTimeoutEvent, at as parseGeneratedActorId, au as ACTOR_REF_TYPE, c as createActor } from './createActor-c7c704c2.esm.js';
 import { a as assertValid } from './validation-05f1d517.esm.js';
 
 function createSpawner(actorScope, actors, spawnedChildren) {
@@ -467,6 +467,14 @@ class StateMachine {
     this._internalEventType = void 0;
     /** @internal Type-only marker for transition metadata. */
     this._transitionMetaType = void 0;
+    /**
+     * Type-level carriers for the machine's source maps and state schema. Type
+     * helpers in integration packages read these to walk a machine's declared
+     * actions, actors and invoked sources. They are never assigned at runtime.
+     */
+    this._actionMap = void 0;
+    this._actorMap = void 0;
+    this._stateSchema = void 0;
     /** The machine's own version. */
     this.version = void 0;
     this.schemas = void 0;

package/dist/{types-744035f0.cjs.js → types-802dc45c.cjs.js}

@@ -1,6 +1,6 @@
 'use strict';
 
-var createActor = require('./createActor-54b4caed.cjs.js');
+var createActor = require('./createActor-c4723a2b.cjs.js');
 var validation = require('./validation-4561b43c.cjs.js');
 
 function createSpawner(actorScope, actors, spawnedChildren) {
@@ -469,6 +469,14 @@ class StateMachine {
     this._internalEventType = void 0;
     /** @internal Type-only marker for transition metadata. */
     this._transitionMetaType = void 0;
+    /**
+     * Type-level carriers for the machine's source maps and state schema. Type
+     * helpers in integration packages read these to walk a machine's declared
+     * actions, actors and invoked sources. They are never assigned at runtime.
+     */
+    this._actionMap = void 0;
+    this._actorMap = void 0;
+    this._stateSchema = void 0;
     /** The machine's own version. */
     this.version = void 0;
     this.schemas = void 0;

package/dist/{types-2dc94fbf.development.cjs.js → types-ec6c763a.development.cjs.js}

@@ -1,6 +1,6 @@
 'use strict';
 
-var createActor = require('./createActor-72c06d5c.development.cjs.js');
+var createActor = require('./createActor-2213c48b.development.cjs.js');
 var validation = require('./validation-f2714a35.development.cjs.js');
 
 function createSpawner(actorScope, actors, spawnedChildren) {
@@ -487,6 +487,14 @@ class StateMachine {
     this._internalEventType = void 0;
     /** @internal Type-only marker for transition metadata. */
     this._transitionMetaType = void 0;
+    /**
+     * Type-level carriers for the machine's source maps and state schema. Type
+     * helpers in integration packages read these to walk a machine's declared
+     * actions, actors and invoked sources. They are never assigned at runtime.
+     */
+    this._actionMap = void 0;
+    this._actorMap = void 0;
+    this._stateSchema = void 0;
     /** The machine's own version. */
     this.version = void 0;
     this.schemas = void 0;