xstate 5.24.0 → 5.25.1

package/dist/{assign-dea9f7c8.cjs.js → assign-592716a8.cjs.js}

@@ -1,6 +1,6 @@
 'use strict';
 
-var guards_dist_xstateGuards = require('./raise-da5b247f.cjs.js');
+var guards_dist_xstateGuards = require('./raise-577e4163.cjs.js');
 
 function createSpawner(actorScope, {
   machine,

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

@@ -68,27 +68,27 @@ interface MachineSnapshotBase<TContext extends MachineContext, TEvent extends Ev
     getMeta: () => Record<StateId<TStateSchema> & string, TMeta | undefined>;
     toJSON: () => unknown;
 }
-interface ActiveMachineSnapshot<TContext extends MachineContext, TEvent extends EventObject, TChildren extends Record<string, AnyActorRef | undefined>, TStateValue extends StateValue, TTag extends string, TOutput, TMeta extends MetaObject, TConfig extends StateSchema> extends MachineSnapshotBase<TContext, TEvent, TChildren, TStateValue, TTag, TOutput, TMeta, TConfig> {
+interface ActiveMachineSnapshot<TContext extends MachineContext, TEvent extends EventObject, TChildren extends Record<string, AnyActorRef | undefined>, TStateValue extends StateValue, TTag extends string, TOutput, TMeta extends MetaObject, TStateSchema extends StateSchema> extends MachineSnapshotBase<TContext, TEvent, TChildren, TStateValue, TTag, TOutput, TMeta, TStateSchema> {
     status: 'active';
     output: undefined;
     error: undefined;
 }
-interface DoneMachineSnapshot<TContext extends MachineContext, TEvent extends EventObject, TChildren extends Record<string, AnyActorRef | undefined>, TStateValue extends StateValue, TTag extends string, TOutput, TMeta extends MetaObject, TConfig extends StateSchema> extends MachineSnapshotBase<TContext, TEvent, TChildren, TStateValue, TTag, TOutput, TMeta, TConfig> {
+interface DoneMachineSnapshot<TContext extends MachineContext, TEvent extends EventObject, TChildren extends Record<string, AnyActorRef | undefined>, TStateValue extends StateValue, TTag extends string, TOutput, TMeta extends MetaObject, TStateSchema extends StateSchema> extends MachineSnapshotBase<TContext, TEvent, TChildren, TStateValue, TTag, TOutput, TMeta, TStateSchema> {
     status: 'done';
     output: TOutput;
     error: undefined;
 }
-interface ErrorMachineSnapshot<TContext extends MachineContext, TEvent extends EventObject, TChildren extends Record<string, AnyActorRef | undefined>, TStateValue extends StateValue, TTag extends string, TOutput, TMeta extends MetaObject, TConfig extends StateSchema> extends MachineSnapshotBase<TContext, TEvent, TChildren, TStateValue, TTag, TOutput, TMeta, TConfig> {
+interface ErrorMachineSnapshot<TContext extends MachineContext, TEvent extends EventObject, TChildren extends Record<string, AnyActorRef | undefined>, TStateValue extends StateValue, TTag extends string, TOutput, TMeta extends MetaObject, TStateSchema extends StateSchema> extends MachineSnapshotBase<TContext, TEvent, TChildren, TStateValue, TTag, TOutput, TMeta, TStateSchema> {
     status: 'error';
     output: undefined;
     error: unknown;
 }
-interface StoppedMachineSnapshot<TContext extends MachineContext, TEvent extends EventObject, TChildren extends Record<string, AnyActorRef | undefined>, TStateValue extends StateValue, TTag extends string, TOutput, TMeta extends MetaObject, TConfig extends StateSchema> extends MachineSnapshotBase<TContext, TEvent, TChildren, TStateValue, TTag, TOutput, TMeta, TConfig> {
+interface StoppedMachineSnapshot<TContext extends MachineContext, TEvent extends EventObject, TChildren extends Record<string, AnyActorRef | undefined>, TStateValue extends StateValue, TTag extends string, TOutput, TMeta extends MetaObject, TStateSchema extends StateSchema> extends MachineSnapshotBase<TContext, TEvent, TChildren, TStateValue, TTag, TOutput, TMeta, TStateSchema> {
     status: 'stopped';
     output: undefined;
     error: undefined;
 }
-export type MachineSnapshot<TContext extends MachineContext, TEvent extends EventObject, TChildren extends Record<string, AnyActorRef | undefined>, TStateValue extends StateValue, TTag extends string, TOutput, TMeta extends MetaObject, TConfig extends StateSchema> = ActiveMachineSnapshot<TContext, TEvent, TChildren, TStateValue, TTag, TOutput, TMeta, TConfig> | DoneMachineSnapshot<TContext, TEvent, TChildren, TStateValue, TTag, TOutput, TMeta, TConfig> | ErrorMachineSnapshot<TContext, TEvent, TChildren, TStateValue, TTag, TOutput, TMeta, TConfig> | StoppedMachineSnapshot<TContext, TEvent, TChildren, TStateValue, TTag, TOutput, TMeta, TConfig>;
+export type MachineSnapshot<TContext extends MachineContext, TEvent extends EventObject, TChildren extends Record<string, AnyActorRef | undefined>, TStateValue extends StateValue, TTag extends string, TOutput, TMeta extends MetaObject, TStateSchema extends StateSchema> = ActiveMachineSnapshot<TContext, TEvent, TChildren, TStateValue, TTag, TOutput, TMeta, TStateSchema> | DoneMachineSnapshot<TContext, TEvent, TChildren, TStateValue, TTag, TOutput, TMeta, TStateSchema> | ErrorMachineSnapshot<TContext, TEvent, TChildren, TStateValue, TTag, TOutput, TMeta, TStateSchema> | StoppedMachineSnapshot<TContext, TEvent, TChildren, TStateValue, TTag, TOutput, TMeta, TStateSchema>;
 export declare function createMachineSnapshot<TContext extends MachineContext, TEvent extends EventObject, TChildren extends Record<string, AnyActorRef | undefined>, TStateValue extends StateValue, TTag extends string, TMeta extends MetaObject, TStateSchema extends StateSchema>(config: StateConfig<TContext, TEvent>, machine: AnyStateMachine): MachineSnapshot<TContext, TEvent, TChildren, TStateValue, TTag, undefined, TMeta, TStateSchema>;
 export declare function cloneMachineSnapshot<TState extends AnyMachineSnapshot>(snapshot: TState, config?: Partial<StateConfig<any, any>>): TState;
 export declare function getPersistedSnapshot<TContext extends MachineContext, TEvent extends EventObject, TChildren extends Record<string, AnyActorRef | undefined>, TStateValue extends StateValue, TTag extends string, TOutput, TMeta extends MetaObject>(snapshot: MachineSnapshot<TContext, TEvent, TChildren, TStateValue, TTag, TOutput, TMeta, any>, options?: unknown): Snapshot<unknown>;

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

@@ -2,7 +2,7 @@ import { MachineSnapshot } from "./State.js";
 import { StateNode } from "./StateNode.js";
 import { AnyActorSystem } from "./system.js";
 import type { ActorLogic, ActorScope, AnyActorRef, AnyActorScope, DoNotInfer, Equals, EventDescriptor, EventObject, HistoryValue, InternalMachineImplementations, MachineConfig, MachineContext, MachineImplementationsSimplified, MetaObject, ParameterizedObject, ProvidedActor, Snapshot, StateMachineDefinition, StateValue, TransitionDefinition, ResolvedStateMachineTypes, StateSchema, SnapshotStatus } from "./types.js";
-export declare class StateMachine<TContext extends MachineContext, TEvent extends EventObject, TChildren extends Record<string, AnyActorRef | undefined>, TActor extends ProvidedActor, TAction extends ParameterizedObject, TGuard extends ParameterizedObject, TDelay extends string, TStateValue extends StateValue, TTag extends string, TInput, TOutput, TEmitted extends EventObject, TMeta extends MetaObject, TConfig extends StateSchema> implements ActorLogic<MachineSnapshot<TContext, TEvent, TChildren, TStateValue, TTag, TOutput, TMeta, TConfig>, TEvent, TInput, AnyActorSystem, TEmitted> {
+export declare class StateMachine<TContext extends MachineContext, TEvent extends EventObject, TChildren extends Record<string, AnyActorRef | undefined>, TActor extends ProvidedActor, TAction extends ParameterizedObject, TGuard extends ParameterizedObject, TDelay extends string, TStateValue extends StateValue, TTag extends string, TInput, TOutput, TEmitted extends EventObject, TMeta extends MetaObject, TStateSchema extends StateSchema> implements ActorLogic<MachineSnapshot<TContext, TEvent, TChildren, TStateValue, TTag, TOutput, TMeta, TStateSchema>, TEvent, TInput, AnyActorSystem, TEmitted> {
     /** The raw config used to create the machine. */
     config: MachineConfig<TContext, TEvent, any, any, any, any, any, any, TOutput, any, // TEmitted
     any> & {
@@ -29,7 +29,7 @@ export declare class StateMachine<TContext extends MachineContext, TEvent extend
      *   recursively merge with the existing options.
      * @returns A new `StateMachine` instance with the provided implementations.
      */
-    provide(implementations: InternalMachineImplementations<ResolvedStateMachineTypes<TContext, DoNotInfer<TEvent>, TActor, TAction, TGuard, TDelay, TTag, TEmitted>>): StateMachine<TContext, TEvent, TChildren, TActor, TAction, TGuard, TDelay, TStateValue, TTag, TInput, TOutput, TEmitted, TMeta, TConfig>;
+    provide(implementations: InternalMachineImplementations<ResolvedStateMachineTypes<TContext, DoNotInfer<TEvent>, TActor, TAction, TGuard, TDelay, TTag, TEmitted>>): StateMachine<TContext, TEvent, TChildren, TActor, TAction, TGuard, TDelay, TStateValue, TTag, TInput, TOutput, TEmitted, TMeta, TStateSchema>;
     resolveState(config: {
         value: StateValue;
         context?: TContext;
@@ -39,7 +39,7 @@ export declare class StateMachine<TContext extends MachineContext, TEvent extend
         error?: unknown;
     } & (Equals<TContext, MachineContext> extends false ? {
         context: unknown;
-    } : {})): MachineSnapshot<TContext, TEvent, TChildren, TStateValue, TTag, TOutput, TMeta, TConfig>;
+    } : {})): MachineSnapshot<TContext, TEvent, TChildren, TStateValue, TTag, TOutput, TMeta, TStateSchema>;
     /**
      * Determines the next snapshot given the current `snapshot` and received
      * `event`. Calculates a full macrostep from all microsteps.
@@ -47,7 +47,7 @@ export declare class StateMachine<TContext extends MachineContext, TEvent extend
      * @param snapshot The current snapshot
      * @param event The received event
      */
-    transition(snapshot: MachineSnapshot<TContext, TEvent, TChildren, TStateValue, TTag, TOutput, TMeta, TConfig>, event: TEvent, actorScope: ActorScope<typeof snapshot, TEvent, AnyActorSystem, TEmitted>): MachineSnapshot<TContext, TEvent, TChildren, TStateValue, TTag, TOutput, TMeta, TConfig>;
+    transition(snapshot: MachineSnapshot<TContext, TEvent, TChildren, TStateValue, TTag, TOutput, TMeta, TStateSchema>, event: TEvent, actorScope: ActorScope<typeof snapshot, TEvent, AnyActorSystem, TEmitted>): MachineSnapshot<TContext, TEvent, TChildren, TStateValue, TTag, TOutput, TMeta, TStateSchema>;
     /**
      * Determines the next state given the current `state` and `event`. Calculates
      * a microstep.
@@ -55,8 +55,8 @@ export declare class StateMachine<TContext extends MachineContext, TEvent extend
      * @param state The current state
      * @param event The received event
      */
-    microstep(snapshot: MachineSnapshot<TContext, TEvent, TChildren, TStateValue, TTag, TOutput, TMeta, TConfig>, event: TEvent, actorScope: AnyActorScope): Array<MachineSnapshot<TContext, TEvent, TChildren, TStateValue, TTag, TOutput, TMeta, TConfig>>;
-    getTransitionData(snapshot: MachineSnapshot<TContext, TEvent, TChildren, TStateValue, TTag, TOutput, TMeta, TConfig>, event: TEvent): Array<TransitionDefinition<TContext, TEvent>>;
+    microstep(snapshot: MachineSnapshot<TContext, TEvent, TChildren, TStateValue, TTag, TOutput, TMeta, TStateSchema>, event: TEvent, actorScope: AnyActorScope): Array<MachineSnapshot<TContext, TEvent, TChildren, TStateValue, TTag, TOutput, TMeta, TStateSchema>>;
+    getTransitionData(snapshot: MachineSnapshot<TContext, TEvent, TChildren, TStateValue, TTag, TOutput, TMeta, TStateSchema>, event: TEvent): Array<TransitionDefinition<TContext, TEvent>>;
     /**
      * The initial state _before_ evaluating any microsteps. This "pre-initial"
      * state is provided to initial actions executed in the initial state.
@@ -66,11 +66,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>;
-    start(snapshot: MachineSnapshot<TContext, TEvent, TChildren, TStateValue, TTag, TOutput, TMeta, TConfig>): void;
+    getInitialSnapshot(actorScope: ActorScope<MachineSnapshot<TContext, TEvent, TChildren, TStateValue, TTag, TOutput, TMeta, TStateSchema>, TEvent, AnyActorSystem, TEmitted>, input?: TInput): MachineSnapshot<TContext, TEvent, TChildren, TStateValue, TTag, TOutput, TMeta, TStateSchema>;
+    start(snapshot: MachineSnapshot<TContext, TEvent, TChildren, TStateValue, TTag, TOutput, TMeta, TStateSchema>): void;
     getStateNodeById(stateId: string): StateNode<TContext, TEvent>;
     get definition(): StateMachineDefinition<TContext, TEvent>;
     toJSON(): StateMachineDefinition<TContext, TEvent>;
-    getPersistedSnapshot(snapshot: MachineSnapshot<TContext, TEvent, TChildren, TStateValue, TTag, TOutput, TMeta, 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>;
+    getPersistedSnapshot(snapshot: MachineSnapshot<TContext, TEvent, TChildren, TStateValue, TTag, TOutput, TMeta, TStateSchema>, options?: unknown): Snapshot<unknown>;
+    restoreSnapshot(snapshot: Snapshot<unknown>, _actorScope: ActorScope<MachineSnapshot<TContext, TEvent, TChildren, TStateValue, TTag, TOutput, TMeta, TStateSchema>, TEvent, AnyActorSystem, TEmitted>): MachineSnapshot<TContext, TEvent, TChildren, TStateValue, TTag, TOutput, TMeta, TStateSchema>;
 }

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

@@ -1,4 +1,4 @@
-import { EventObject } from "./types.js";
+import { EventDescriptor, EventObject, ExtractEvent } from "./types.js";
 /**
  * Asserts that the given event object is of the specified type or types. Throws
  * an error if the event object is not of the specified types.
@@ -22,6 +22,4 @@ import { EventObject } from "./types.js";
  * },
  * ```
  */
-export declare function assertEvent<TEvent extends EventObject, TAssertedType extends TEvent['type']>(event: TEvent, type: TAssertedType | TAssertedType[]): asserts event is TEvent & {
-    type: TAssertedType;
-};
+export declare function assertEvent<TEvent extends EventObject, TAssertedDescriptor extends EventDescriptor<TEvent>>(event: TEvent, type: TAssertedDescriptor | readonly TAssertedDescriptor[]): asserts event is ExtractEvent<TEvent, TAssertedDescriptor>;

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

@@ -9,20 +9,25 @@ import { sendTo } from "./actions/send.js";
 import { spawnChild } from "./actions/spawnChild.js";
 import { stopChild } from "./actions/stopChild.js";
 import { GuardPredicate } from "./guards.js";
-import { ActionFunction, AnyActorRef, AnyEventObject, Cast, DelayConfig, EventObject, Invert, IsNever, MachineConfig, MachineContext, MetaObject, NonReducibleUnknown, ParameterizedObject, SetupTypes, StateNodeConfig, ToChildren, ToStateValue, UnknownActorLogic, Values } from "./types.js";
-type ToParameterizedObject<TParameterizedMap extends Record<string, ParameterizedObject['params'] | undefined>> = IsNever<TParameterizedMap> extends true ? never : Values<{
-    [K in keyof TParameterizedMap & string]: {
-        type: K;
+import { ActionFunction, AnyActorRef, AnyEventObject, Cast, DelayConfig, EventObject, Invert, IsNever, MachineConfig, MachineContext, MetaObject, NonReducibleUnknown, ParameterizedObject, SetupTypes, StateNodeConfig, StateSchema, ToChildren, ToStateValue, UnknownActorLogic, Values } from "./types.js";
+type ToParameterizedObject<TParameterizedMap extends Record<string, ParameterizedObject['params'] | undefined>> = Values<{
+    [K in keyof TParameterizedMap as K & string]: {
+        type: K & string;
         params: TParameterizedMap[K];
     };
 }>;
-type ToProvidedActor<TChildrenMap extends Record<string, string>, TActors extends Record<string, UnknownActorLogic>> = IsNever<TActors> extends true ? never : Values<{
-    [K in keyof TActors & string]: {
-        src: K;
+type ToProvidedActor<TChildrenMap extends Record<string, string>, TActors extends Record<string, UnknownActorLogic>> = Values<{
+    [K in keyof TActors as K & string]: {
+        src: K & string;
         logic: TActors[K];
         id: IsNever<TChildrenMap> extends true ? string | undefined : K extends keyof Invert<TChildrenMap> ? Invert<TChildrenMap>[K] & string : string | undefined;
     };
 }>;
+type ToStateSchema<TSchema extends StateSchema> = {
+    -readonly [K in keyof TSchema as K & ('id' | 'states')]: K extends 'states' ? {
+        [SK in keyof TSchema['states']]: ToStateSchema<NonNullable<TSchema['states'][SK]>>;
+    } : TSchema[K];
+};
 type RequiredSetupKeys<TChildrenMap> = IsNever<keyof TChildrenMap> extends true ? never : 'actors';
 type SetupReturn<TContext extends MachineContext, TEvent extends AnyEventObject, TActors extends Record<string, UnknownActorLogic>, TChildrenMap extends Record<string, string>, TActions extends Record<string, ParameterizedObject['params'] | undefined>, TGuards extends Record<string, ParameterizedObject['params'] | undefined>, TDelay extends string, TTag extends string, TInput, TOutput extends NonReducibleUnknown, TEmitted extends EventObject, TMeta extends MetaObject> = {
     extend: <TExtendActions extends Record<string, ParameterizedObject['params'] | undefined> = {}, TExtendGuards extends Record<string, ParameterizedObject['params'] | undefined> = {}, TExtendDelays extends string = never>({ actions, guards, delays }: {
@@ -91,7 +96,7 @@ type SetupReturn<TContext extends MachineContext, TEvent extends AnyEventObject,
      * ```
      */
     createAction: (action: ActionFunction<TContext, TEvent, TEvent, unknown, ToProvidedActor<TChildrenMap, TActors>, ToParameterizedObject<TActions>, ToParameterizedObject<TGuards>, TDelay, TEmitted>) => typeof action;
-    createMachine: <const TConfig extends MachineConfig<TContext, TEvent, ToProvidedActor<TChildrenMap, TActors>, ToParameterizedObject<TActions>, ToParameterizedObject<TGuards>, TDelay, TTag, TInput, TOutput, TEmitted, TMeta>>(config: TConfig) => StateMachine<TContext, TEvent, Cast<ToChildren<ToProvidedActor<TChildrenMap, TActors>>, Record<string, AnyActorRef | undefined>>, ToProvidedActor<TChildrenMap, TActors>, ToParameterizedObject<TActions>, ToParameterizedObject<TGuards>, TDelay, ToStateValue<TConfig>, TTag, TInput, TOutput, TEmitted, TMeta, TConfig>;
+    createMachine: <const TConfig extends MachineConfig<TContext, TEvent, ToProvidedActor<TChildrenMap, TActors>, ToParameterizedObject<TActions>, ToParameterizedObject<TGuards>, TDelay, TTag, TInput, TOutput, TEmitted, TMeta>>(config: TConfig) => StateMachine<TContext, TEvent, Cast<ToChildren<ToProvidedActor<TChildrenMap, TActors>>, Record<string, AnyActorRef | undefined>>, ToProvidedActor<TChildrenMap, TActors>, ToParameterizedObject<TActions>, ToParameterizedObject<TGuards>, TDelay, ToStateValue<TConfig>, TTag, TInput, TOutput, TEmitted, TMeta, ToStateSchema<TConfig>>;
     assign: typeof assign<TContext, TEvent, undefined, TEvent, ToProvidedActor<TChildrenMap, TActors>>;
     sendTo: <TTargetActor extends AnyActorRef>(...args: Parameters<typeof sendTo<TContext, TEvent, undefined, TTargetActor, TEvent, TDelay, TDelay>>) => ReturnType<typeof sendTo<TContext, TEvent, undefined, TTargetActor, TEvent, TDelay, TDelay>>;
     raise: typeof raise<TContext, TEvent, TEvent, undefined, TDelay, TDelay>;

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

@@ -989,7 +989,7 @@ export interface ExecutableSpawnAction extends ExecutableActionObject {
     };
 }
 export type SpecialExecutableAction = ExecutableSpawnAction | ExecutableRaiseAction | ExecutableSendToAction;
-export type ExecutableActionsFrom<T extends AnyActorLogic> = T extends StateMachine<infer _TContext, infer _TEvent, infer _TChildren, infer _TActor, infer TAction, infer _TGuard, infer _TDelay, infer _TStateValue, infer _TTag, infer _TInput, infer _TOutput, infer _TEmitted, infer _TMeta, infer _TConfig> ? SpecialExecutableAction | (string extends TAction['type'] ? never : ToExecutableAction<TAction>) : never;
+export type ExecutableActionsFrom<T extends AnyActorLogic> = T extends StateMachine<infer _TContext, infer _TEvent, infer _TChildren, infer _TActor, infer TAction, infer _TGuard, infer _TDelay, infer _TStateValue, infer _TTag, infer _TInput, infer _TOutput, infer _TEmitted, infer _TMeta, infer _TStateSchema> ? SpecialExecutableAction | (string extends TAction['type'] ? never : ToExecutableAction<TAction>) : never;
 export type ActionExecutor = (actionToExecute: ExecutableActionObject) => void;
 export type BuiltinActionResolution = [
     AnyMachineSnapshot,

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

@@ -15,3 +15,16 @@ export declare function toObserver<T>(nextHandler?: Observer<T> | ((value: T) =>
 export declare function createInvokeId(stateNodeId: string, index: number): string;
 export declare function resolveReferencedActor(machine: AnyStateMachine, src: string): any;
 export declare function getAllOwnEventDescriptors(snapshot: AnyMachineSnapshot): any[];
+/**
+ * Checks if an event type matches an event descriptor, supporting wildcards.
+ * Event descriptors can be:
+ *
+ * - Exact matches: "event.type"
+ * - Wildcard: "*"
+ * - Partial matches: "event.*"
+ *
+ * @param eventType - The actual event type string
+ * @param descriptor - The event descriptor to match against
+ * @returns True if the event type matches the descriptor
+ */
+export declare function matchesEventDescriptor(eventType: string, descriptor: string): boolean;

package/dist/{log-cbac1abc.development.cjs.js → log-3827c227.development.cjs.js}

@@ -1,7 +1,7 @@
 'use strict';
 
-var guards_dist_xstateGuards = require('./raise-f777a9e8.development.cjs.js');
-var assign = require('./assign-9e730107.development.cjs.js');
+var guards_dist_xstateGuards = require('./raise-ed7c6f3d.development.cjs.js');
+var assign = require('./assign-577bb842.development.cjs.js');
 
 function resolveEmit(_, snapshot, args, actionParams, {
   event: eventOrExpr

package/dist/{log-ec8d4df4.cjs.js → log-9c9f917d.cjs.js}

@@ -1,7 +1,7 @@
 'use strict';
 
-var guards_dist_xstateGuards = require('./raise-da5b247f.cjs.js');
-var assign = require('./assign-dea9f7c8.cjs.js');
+var guards_dist_xstateGuards = require('./raise-577e4163.cjs.js');
+var assign = require('./assign-592716a8.cjs.js');
 
 function resolveEmit(_, snapshot, args, actionParams, {
   event: eventOrExpr

package/dist/{log-2aa3642a.development.esm.js → log-b8ca474e.development.esm.js}

@@ -1,5 +1,5 @@
-import { T as executingCustomAction, U as XSTATE_ERROR, V as createErrorActorEvent, w as evaluateGuard, a as cancel, r as raise, b as spawnChild, s as stopChild } from './raise-c096f887.development.esm.js';
-import { a as assign } from './assign-445527dc.development.esm.js';
+import { U as executingCustomAction, V as XSTATE_ERROR, W as createErrorActorEvent, x as evaluateGuard, a as cancel, r as raise, b as spawnChild, s as stopChild } from './raise-13a60c49.development.esm.js';
+import { a as assign } from './assign-541a432d.development.esm.js';
 
 function resolveEmit(_, snapshot, args, actionParams, {
   event: eventOrExpr

package/dist/{log-7cbae384.esm.js → log-ce14fc9a.esm.js}

@@ -1,5 +1,5 @@
-import { T as XSTATE_ERROR, U as createErrorActorEvent, w as evaluateGuard, a as cancel, r as raise, b as spawnChild, s as stopChild } from './raise-9ad1c5c6.esm.js';
-import { a as assign } from './assign-ab9cc19e.esm.js';
+import { U as XSTATE_ERROR, V as createErrorActorEvent, x as evaluateGuard, a as cancel, r as raise, b as spawnChild, s as stopChild } from './raise-f5c7cb5b.esm.js';
+import { a as assign } from './assign-37a2fc1e.esm.js';
 
 function resolveEmit(_, snapshot, args, actionParams, {
   event: eventOrExpr

package/dist/{raise-c096f887.development.esm.js → raise-13a60c49.development.esm.js}

@@ -286,6 +286,50 @@ function getAllOwnEventDescriptors(snapshot) {
   return [...new Set([...snapshot._nodes.flatMap(sn => sn.ownEvents)])];
 }
 
+/**
+ * Checks if an event type matches an event descriptor, supporting wildcards.
+ * Event descriptors can be:
+ *
+ * - Exact matches: "event.type"
+ * - Wildcard: "*"
+ * - Partial matches: "event.*"
+ *
+ * @param eventType - The actual event type string
+ * @param descriptor - The event descriptor to match against
+ * @returns True if the event type matches the descriptor
+ */
+function matchesEventDescriptor(eventType, descriptor) {
+  if (descriptor === eventType) {
+    return true;
+  }
+  if (descriptor === WILDCARD) {
+    return true;
+  }
+  if (!descriptor.endsWith('.*')) {
+    return false;
+  }
+  if (/.*\*.+/.test(descriptor)) {
+    console.warn(`Wildcards can only be the last token of an event descriptor (e.g., "event.*") or the entire event descriptor ("*"). Check the "${descriptor}" event.`);
+  }
+  const partialEventTokens = descriptor.split('.');
+  const eventTokens = eventType.split('.');
+  for (let tokenIndex = 0; tokenIndex < partialEventTokens.length; tokenIndex++) {
+    const partialEventToken = partialEventTokens[tokenIndex];
+    const eventToken = eventTokens[tokenIndex];
+    if (partialEventToken === '*') {
+      const isLastToken = tokenIndex === partialEventTokens.length - 1;
+      if (!isLastToken) {
+        console.warn(`Infix wildcards in transition events are not allowed. Check the "${descriptor}" transition.`);
+      }
+      return isLastToken;
+    }
+    if (partialEventToken !== eventToken) {
+      return false;
+    }
+  }
+  return true;
+}
+
 function createScheduledEventId(actorRef, id) {
   return `${actorRef.sessionId}.${id}`;
 }
@@ -924,12 +968,14 @@ class Actor {
       }
     }
     this.observers.clear();
+    this.eventListeners.clear();
   }
   _reportError(err) {
     if (!this.observers.size) {
       if (!this._parent) {
         reportUnhandledError(err);
       }
+      this.eventListeners.clear();
       return;
     }
     let reportError = false;
@@ -943,6 +989,7 @@ class Actor {
       }
     }
     this.observers.clear();
+    this.eventListeners.clear();
     if (reportError) {
       reportUnhandledError(err);
     }
@@ -1271,6 +1318,16 @@ function resolveStop(_, snapshot, args, actionParams, {
     children
   }), resolvedActorRef, undefined];
 }
+function unregisterRecursively(actorScope, actorRef) {
+  // unregister children first (depth-first)
+  const snapshot = actorRef.getSnapshot();
+  if (snapshot && 'children' in snapshot) {
+    for (const child of Object.values(snapshot.children)) {
+      unregisterRecursively(actorScope, child);
+    }
+  }
+  actorScope.system._unregister(actorRef);
+}
 function executeStop(actorScope, actorRef) {
   if (!actorRef) {
     return;
@@ -1279,7 +1336,8 @@ function executeStop(actorScope, actorRef) {
   // we need to eagerly unregister it here so a new actor with the same systemId can be registered immediately
   // since we defer actual stopping of the actor but we don't defer actor creations (and we can't do that)
   // this could throw on `systemId` collision, for example, when dealing with reentering transitions
-  actorScope.system._unregister(actorRef);
+  // we also need to recursively unregister all nested children's systemIds
+  unregisterRecursively(actorScope, actorRef);
 
   // this allows us to prevent an actor from being started if it gets stopped within the same macrostep
   // this can happen, for example, when the invoking state is being exited immediately by an always transition
@@ -1622,36 +1680,7 @@ function isInFinalState(stateNodeSet, stateNode) {
 }
 const isStateId = str => str[0] === STATE_IDENTIFIER;
 function getCandidates(stateNode, receivedEventType) {
-  const candidates = stateNode.transitions.get(receivedEventType) || [...stateNode.transitions.keys()].filter(eventDescriptor => {
-    // check if transition is a wildcard transition,
-    // which matches any non-transient events
-    if (eventDescriptor === WILDCARD) {
-      return true;
-    }
-    if (!eventDescriptor.endsWith('.*')) {
-      return false;
-    }
-    if (/.*\*.+/.test(eventDescriptor)) {
-      console.warn(`Wildcards can only be the last token of an event descriptor (e.g., "event.*") or the entire event descriptor ("*"). Check the "${eventDescriptor}" event.`);
-    }
-    const partialEventTokens = eventDescriptor.split('.');
-    const eventTokens = receivedEventType.split('.');
-    for (let tokenIndex = 0; tokenIndex < partialEventTokens.length; tokenIndex++) {
-      const partialEventToken = partialEventTokens[tokenIndex];
-      const eventToken = eventTokens[tokenIndex];
-      if (partialEventToken === '*') {
-        const isLastToken = tokenIndex === partialEventTokens.length - 1;
-        if (!isLastToken) {
-          console.warn(`Infix wildcards in transition events are not allowed. Check the "${eventDescriptor}" transition.`);
-        }
-        return isLastToken;
-      }
-      if (partialEventToken !== eventToken) {
-        return false;
-      }
-    }
-    return true;
-  }).sort((a, b) => b.length - a.length).flatMap(key => stateNode.transitions.get(key));
+  const candidates = stateNode.transitions.get(receivedEventType) || [...stateNode.transitions.keys()].filter(eventDescriptor => matchesEventDescriptor(receivedEventType, eventDescriptor)).sort((a, b) => b.length - a.length).flatMap(key => stateNode.transitions.get(key));
   return candidates;
 }
 
@@ -2712,4 +2741,4 @@ function raise(eventOrExpr, options) {
   return raise;
 }
 
-export { $$ACTOR_TYPE as $, Actor as A, getCandidates as B, resolveStateValue as C, getAllStateNodes as D, createMachineSnapshot as E, isInFinalState as F, macrostep as G, transitionNode as H, resolveActionsAndContext as I, createInitEvent as J, microstep as K, getInitialStateNodes as L, toStatePath as M, NULL_EVENT as N, isStateId as O, getStateNodeByPath as P, getPersistedSnapshot as Q, resolveReferencedActor as R, STATE_DELIMITER as S, executingCustomAction as T, XSTATE_ERROR as U, createErrorActorEvent as V, ProcessingStatus as W, XSTATE_STOP as X, cloneMachineSnapshot as Y, cancel as a, spawnChild as b, createActor as c, and as d, stateIn as e, isMachineSnapshot as f, getStateNodes as g, getAllOwnEventDescriptors as h, interpret as i, toObserver as j, stop as k, mapValues as l, matchesState as m, not as n, or as o, pathToStateValue as p, formatTransitions as q, raise as r, stopChild as s, toArray as t, toTransitionConfigArray as u, formatTransition as v, evaluateGuard as w, createInvokeId as x, getDelayedTransitions as y, formatInitialTransition as z };
+export { $$ACTOR_TYPE as $, Actor as A, formatInitialTransition as B, getCandidates as C, resolveStateValue as D, getAllStateNodes as E, createMachineSnapshot as F, isInFinalState as G, macrostep as H, transitionNode as I, resolveActionsAndContext as J, createInitEvent as K, microstep as L, getInitialStateNodes as M, NULL_EVENT as N, toStatePath as O, isStateId as P, getStateNodeByPath as Q, getPersistedSnapshot as R, STATE_DELIMITER as S, resolveReferencedActor as T, executingCustomAction as U, XSTATE_ERROR as V, createErrorActorEvent as W, XSTATE_STOP as X, ProcessingStatus as Y, cloneMachineSnapshot as Z, cancel as a, spawnChild as b, createActor as c, and as d, stateIn as e, isMachineSnapshot as f, getStateNodes as g, getAllOwnEventDescriptors as h, interpret as i, matchesState as j, toObserver as k, stop as l, matchesEventDescriptor as m, not as n, or as o, pathToStateValue as p, mapValues as q, raise as r, stopChild as s, toArray as t, formatTransitions as u, toTransitionConfigArray as v, formatTransition as w, evaluateGuard as x, createInvokeId as y, getDelayedTransitions as z };

package/dist/{raise-da5b247f.cjs.js → raise-577e4163.cjs.js}

@@ -285,6 +285,44 @@ function getAllOwnEventDescriptors(snapshot) {
   return [...new Set([...snapshot._nodes.flatMap(sn => sn.ownEvents)])];
 }
 
+/**
+ * Checks if an event type matches an event descriptor, supporting wildcards.
+ * Event descriptors can be:
+ *
+ * - Exact matches: "event.type"
+ * - Wildcard: "*"
+ * - Partial matches: "event.*"
+ *
+ * @param eventType - The actual event type string
+ * @param descriptor - The event descriptor to match against
+ * @returns True if the event type matches the descriptor
+ */
+function matchesEventDescriptor(eventType, descriptor) {
+  if (descriptor === eventType) {
+    return true;
+  }
+  if (descriptor === WILDCARD) {
+    return true;
+  }
+  if (!descriptor.endsWith('.*')) {
+    return false;
+  }
+  const partialEventTokens = descriptor.split('.');
+  const eventTokens = eventType.split('.');
+  for (let tokenIndex = 0; tokenIndex < partialEventTokens.length; tokenIndex++) {
+    const partialEventToken = partialEventTokens[tokenIndex];
+    const eventToken = eventTokens[tokenIndex];
+    if (partialEventToken === '*') {
+      const isLastToken = tokenIndex === partialEventTokens.length - 1;
+      return isLastToken;
+    }
+    if (partialEventToken !== eventToken) {
+      return false;
+    }
+  }
+  return true;
+}
+
 function createScheduledEventId(actorRef, id) {
   return `${actorRef.sessionId}.${id}`;
 }
@@ -923,12 +961,14 @@ class Actor {
       }
     }
     this.observers.clear();
+    this.eventListeners.clear();
   }
   _reportError(err) {
     if (!this.observers.size) {
       if (!this._parent) {
         reportUnhandledError(err);
       }
+      this.eventListeners.clear();
       return;
     }
     let reportError = false;
@@ -942,6 +982,7 @@ class Actor {
       }
     }
     this.observers.clear();
+    this.eventListeners.clear();
     if (reportError) {
       reportUnhandledError(err);
     }
@@ -1248,6 +1289,16 @@ function resolveStop(_, snapshot, args, actionParams, {
     children
   }), resolvedActorRef, undefined];
 }
+function unregisterRecursively(actorScope, actorRef) {
+  // unregister children first (depth-first)
+  const snapshot = actorRef.getSnapshot();
+  if (snapshot && 'children' in snapshot) {
+    for (const child of Object.values(snapshot.children)) {
+      unregisterRecursively(actorScope, child);
+    }
+  }
+  actorScope.system._unregister(actorRef);
+}
 function executeStop(actorScope, actorRef) {
   if (!actorRef) {
     return;
@@ -1256,7 +1307,8 @@ function executeStop(actorScope, actorRef) {
   // we need to eagerly unregister it here so a new actor with the same systemId can be registered immediately
   // since we defer actual stopping of the actor but we don't defer actor creations (and we can't do that)
   // this could throw on `systemId` collision, for example, when dealing with reentering transitions
-  actorScope.system._unregister(actorRef);
+  // we also need to recursively unregister all nested children's systemIds
+  unregisterRecursively(actorScope, actorRef);
 
   // this allows us to prevent an actor from being started if it gets stopped within the same macrostep
   // this can happen, for example, when the invoking state is being exited immediately by an always transition
@@ -1588,30 +1640,7 @@ function isInFinalState(stateNodeSet, stateNode) {
 }
 const isStateId = str => str[0] === STATE_IDENTIFIER;
 function getCandidates(stateNode, receivedEventType) {
-  const candidates = stateNode.transitions.get(receivedEventType) || [...stateNode.transitions.keys()].filter(eventDescriptor => {
-    // check if transition is a wildcard transition,
-    // which matches any non-transient events
-    if (eventDescriptor === WILDCARD) {
-      return true;
-    }
-    if (!eventDescriptor.endsWith('.*')) {
-      return false;
-    }
-    const partialEventTokens = eventDescriptor.split('.');
-    const eventTokens = receivedEventType.split('.');
-    for (let tokenIndex = 0; tokenIndex < partialEventTokens.length; tokenIndex++) {
-      const partialEventToken = partialEventTokens[tokenIndex];
-      const eventToken = eventTokens[tokenIndex];
-      if (partialEventToken === '*') {
-        const isLastToken = tokenIndex === partialEventTokens.length - 1;
-        return isLastToken;
-      }
-      if (partialEventToken !== eventToken) {
-        return false;
-      }
-    }
-    return true;
-  }).sort((a, b) => b.length - a.length).flatMap(key => stateNode.transitions.get(key));
+  const candidates = stateNode.transitions.get(receivedEventType) || [...stateNode.transitions.keys()].filter(eventDescriptor => matchesEventDescriptor(receivedEventType, eventDescriptor)).sort((a, b) => b.length - a.length).flatMap(key => stateNode.transitions.get(key));
   return candidates;
 }
 
@@ -2685,6 +2714,7 @@ exports.isMachineSnapshot = isMachineSnapshot;
 exports.isStateId = isStateId;
 exports.macrostep = macrostep;
 exports.mapValues = mapValues;
+exports.matchesEventDescriptor = matchesEventDescriptor;
 exports.matchesState = matchesState;
 exports.microstep = microstep;
 exports.not = not;