xstate 5.16.0 → 5.17.0

package/dist/{raise-2cfe6b8f.esm.js → State-cdbc7940.esm.js}

@@ -321,7 +321,9 @@ function createSystem(rootActor, options) {
       const timeout = timerMap[scheduledEventId];
       delete timerMap[scheduledEventId];
       delete system._snapshot._scheduledEvents[scheduledEventId];
-      clock.clearTimeout(timeout);
+      if (timeout !== undefined) {
+        clock.clearTimeout(timeout);
+      }
     },
     cancelAll: actorRef => {
       for (const scheduledEventId in system._snapshot._scheduledEvents) {
@@ -418,6 +420,7 @@ function createSystem(rootActor, options) {
 }
 
 const $$ACTOR_TYPE = 1;
+
 // those values are currently used by @xstate/react directly so it's important to keep the assigned values in sync
 let ProcessingStatus = /*#__PURE__*/function (ProcessingStatus) {
   ProcessingStatus[ProcessingStatus["NotStarted"] = 0] = "NotStarted";
@@ -1055,10 +1058,14 @@ function createActor(logic, ...[options]) {
  * options, if any.
  *
  * @deprecated Use `createActor` instead
+ * @alias
  */
 const interpret = createActor;
 
-/** @deprecated Use `Actor` instead. */
+/**
+ * @deprecated Use `Actor` instead.
+ * @alias
+ */
 
 function resolveCancel(_, snapshot, actionArgs, actionParams, {
   sendId
@@ -1113,135 +1120,6 @@ function cancel(sendId) {
   return cancel;
 }
 
-function resolveSpawn(actorScope, snapshot, actionArgs, _actionParams, {
-  id,
-  systemId,
-  src,
-  input,
-  syncSnapshot
-}) {
-  const logic = typeof src === 'string' ? resolveReferencedActor(snapshot.machine, src) : src;
-  const resolvedId = typeof id === 'function' ? id(actionArgs) : id;
-  let actorRef;
-  if (logic) {
-    actorRef = createActor(logic, {
-      id: resolvedId,
-      src,
-      parent: actorScope.self,
-      syncSnapshot,
-      systemId,
-      input: typeof input === 'function' ? input({
-        context: snapshot.context,
-        event: actionArgs.event,
-        self: actorScope.self
-      }) : input
-    });
-  }
-  return [cloneMachineSnapshot(snapshot, {
-    children: {
-      ...snapshot.children,
-      [resolvedId]: actorRef
-    }
-  }), {
-    id,
-    actorRef
-  }];
-}
-function executeSpawn(actorScope, {
-  id,
-  actorRef
-}) {
-  if (!actorRef) {
-    return;
-  }
-  actorScope.defer(() => {
-    if (actorRef._processingStatus === ProcessingStatus.Stopped) {
-      return;
-    }
-    actorRef.start();
-  });
-}
-function spawnChild(...[src, {
-  id,
-  systemId,
-  input,
-  syncSnapshot = false
-} = {}]) {
-  function spawnChild(args, params) {
-  }
-  spawnChild.type = 'snapshot.spawnChild';
-  spawnChild.id = id;
-  spawnChild.systemId = systemId;
-  spawnChild.src = src;
-  spawnChild.input = input;
-  spawnChild.syncSnapshot = syncSnapshot;
-  spawnChild.resolve = resolveSpawn;
-  spawnChild.execute = executeSpawn;
-  return spawnChild;
-}
-
-function resolveStop(_, snapshot, args, actionParams, {
-  actorRef
-}) {
-  const actorRefOrString = typeof actorRef === 'function' ? actorRef(args, actionParams) : actorRef;
-  const resolvedActorRef = typeof actorRefOrString === 'string' ? snapshot.children[actorRefOrString] : actorRefOrString;
-  let children = snapshot.children;
-  if (resolvedActorRef) {
-    children = {
-      ...children
-    };
-    delete children[resolvedActorRef.id];
-  }
-  return [cloneMachineSnapshot(snapshot, {
-    children
-  }), resolvedActorRef];
-}
-function executeStop(actorScope, actorRef) {
-  if (!actorRef) {
-    return;
-  }
-
-  // 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);
-
-  // 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
-  if (actorRef._processingStatus !== ProcessingStatus.Running) {
-    actorScope.stopChild(actorRef);
-    return;
-  }
-  // stopping a child enqueues a stop event in the child actor's mailbox
-  // we need for all of the already enqueued events to be processed before we stop the child
-  // the parent itself might want to send some events to a child (for example from exit actions on the invoking state)
-  // and we don't want to ignore those events
-  actorScope.defer(() => {
-    actorScope.stopChild(actorRef);
-  });
-}
-/**
- * Stops a child actor.
- *
- * @param actorRef The actor to stop.
- */
-function stopChild(actorRef) {
-  function stop(args, params) {
-  }
-  stop.type = 'xstate.stopChild';
-  stop.actorRef = actorRef;
-  stop.resolve = resolveStop;
-  stop.execute = executeStop;
-  return stop;
-}
-
-/**
- * Stops a child actor.
- *
- * @deprecated Use `stopChild(...)` instead
- */
-const stop = stopChild;
-
 function checkStateIn(snapshot, _, {
   stateValue
 }) {
@@ -1430,6 +1308,196 @@ function evaluateGuard(guard, context, event, snapshot) {
   );
 }
 
+function resolveRaise(_, snapshot, args, actionParams, {
+  event: eventOrExpr,
+  id,
+  delay
+}, {
+  internalQueue
+}) {
+  const delaysMap = snapshot.machine.implementations.delays;
+  if (typeof eventOrExpr === 'string') {
+    throw new Error(`Only event objects may be used with raise; use raise({ type: "${eventOrExpr}" }) instead`);
+  }
+  const resolvedEvent = typeof eventOrExpr === 'function' ? eventOrExpr(args, actionParams) : eventOrExpr;
+  let resolvedDelay;
+  if (typeof delay === 'string') {
+    const configDelay = delaysMap && delaysMap[delay];
+    resolvedDelay = typeof configDelay === 'function' ? configDelay(args, actionParams) : configDelay;
+  } else {
+    resolvedDelay = typeof delay === 'function' ? delay(args, actionParams) : delay;
+  }
+  if (typeof resolvedDelay !== 'number') {
+    internalQueue.push(resolvedEvent);
+  }
+  return [snapshot, {
+    event: resolvedEvent,
+    id,
+    delay: resolvedDelay
+  }];
+}
+function executeRaise(actorScope, params) {
+  const {
+    event,
+    delay,
+    id
+  } = params;
+  if (typeof delay === 'number') {
+    actorScope.defer(() => {
+      const self = actorScope.self;
+      actorScope.system.scheduler.schedule(self, self, event, delay, id);
+    });
+    return;
+  }
+}
+/**
+ * Raises an event. This places the event in the internal event queue, so that
+ * the event is immediately consumed by the machine in the current step.
+ *
+ * @param eventType The event to raise.
+ */
+function raise(eventOrExpr, options) {
+  function raise(args, params) {
+  }
+  raise.type = 'xstate.raise';
+  raise.event = eventOrExpr;
+  raise.id = options?.id;
+  raise.delay = options?.delay;
+  raise.resolve = resolveRaise;
+  raise.execute = executeRaise;
+  return raise;
+}
+
+function resolveSpawn(actorScope, snapshot, actionArgs, _actionParams, {
+  id,
+  systemId,
+  src,
+  input,
+  syncSnapshot
+}) {
+  const logic = typeof src === 'string' ? resolveReferencedActor(snapshot.machine, src) : src;
+  const resolvedId = typeof id === 'function' ? id(actionArgs) : id;
+  let actorRef;
+  if (logic) {
+    actorRef = createActor(logic, {
+      id: resolvedId,
+      src,
+      parent: actorScope.self,
+      syncSnapshot,
+      systemId,
+      input: typeof input === 'function' ? input({
+        context: snapshot.context,
+        event: actionArgs.event,
+        self: actorScope.self
+      }) : input
+    });
+  }
+  return [cloneMachineSnapshot(snapshot, {
+    children: {
+      ...snapshot.children,
+      [resolvedId]: actorRef
+    }
+  }), {
+    id,
+    actorRef
+  }];
+}
+function executeSpawn(actorScope, {
+  id,
+  actorRef
+}) {
+  if (!actorRef) {
+    return;
+  }
+  actorScope.defer(() => {
+    if (actorRef._processingStatus === ProcessingStatus.Stopped) {
+      return;
+    }
+    actorRef.start();
+  });
+}
+function spawnChild(...[src, {
+  id,
+  systemId,
+  input,
+  syncSnapshot = false
+} = {}]) {
+  function spawnChild(args, params) {
+  }
+  spawnChild.type = 'snapshot.spawnChild';
+  spawnChild.id = id;
+  spawnChild.systemId = systemId;
+  spawnChild.src = src;
+  spawnChild.input = input;
+  spawnChild.syncSnapshot = syncSnapshot;
+  spawnChild.resolve = resolveSpawn;
+  spawnChild.execute = executeSpawn;
+  return spawnChild;
+}
+
+function resolveStop(_, snapshot, args, actionParams, {
+  actorRef
+}) {
+  const actorRefOrString = typeof actorRef === 'function' ? actorRef(args, actionParams) : actorRef;
+  const resolvedActorRef = typeof actorRefOrString === 'string' ? snapshot.children[actorRefOrString] : actorRefOrString;
+  let children = snapshot.children;
+  if (resolvedActorRef) {
+    children = {
+      ...children
+    };
+    delete children[resolvedActorRef.id];
+  }
+  return [cloneMachineSnapshot(snapshot, {
+    children
+  }), resolvedActorRef];
+}
+function executeStop(actorScope, actorRef) {
+  if (!actorRef) {
+    return;
+  }
+
+  // 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);
+
+  // 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
+  if (actorRef._processingStatus !== ProcessingStatus.Running) {
+    actorScope.stopChild(actorRef);
+    return;
+  }
+  // stopping a child enqueues a stop event in the child actor's mailbox
+  // we need for all of the already enqueued events to be processed before we stop the child
+  // the parent itself might want to send some events to a child (for example from exit actions on the invoking state)
+  // and we don't want to ignore those events
+  actorScope.defer(() => {
+    actorScope.stopChild(actorRef);
+  });
+}
+/**
+ * Stops a child actor.
+ *
+ * @param actorRef The actor to stop.
+ */
+function stopChild(actorRef) {
+  function stop(args, params) {
+  }
+  stop.type = 'xstate.stopChild';
+  stop.actorRef = actorRef;
+  stop.resolve = resolveStop;
+  stop.execute = executeStop;
+  return stop;
+}
+
+/**
+ * Stops a child actor.
+ *
+ * @deprecated Use `stopChild(...)` instead
+ * @alias
+ */
+const stop = stopChild;
+
 const isAtomicStateNode = stateNode => stateNode.type === 'atomic' || stateNode.type === 'final';
 function getChildren(stateNode) {
   return Object.values(stateNode.states).filter(sn => sn.type !== 'history');
@@ -2534,64 +2602,4 @@ function persistContext(contextPart) {
   return copy ?? contextPart;
 }
 
-function resolveRaise(_, snapshot, args, actionParams, {
-  event: eventOrExpr,
-  id,
-  delay
-}, {
-  internalQueue
-}) {
-  const delaysMap = snapshot.machine.implementations.delays;
-  if (typeof eventOrExpr === 'string') {
-    throw new Error(`Only event objects may be used with raise; use raise({ type: "${eventOrExpr}" }) instead`);
-  }
-  const resolvedEvent = typeof eventOrExpr === 'function' ? eventOrExpr(args, actionParams) : eventOrExpr;
-  let resolvedDelay;
-  if (typeof delay === 'string') {
-    const configDelay = delaysMap && delaysMap[delay];
-    resolvedDelay = typeof configDelay === 'function' ? configDelay(args, actionParams) : configDelay;
-  } else {
-    resolvedDelay = typeof delay === 'function' ? delay(args, actionParams) : delay;
-  }
-  if (typeof resolvedDelay !== 'number') {
-    internalQueue.push(resolvedEvent);
-  }
-  return [snapshot, {
-    event: resolvedEvent,
-    id,
-    delay: resolvedDelay
-  }];
-}
-function executeRaise(actorScope, params) {
-  const {
-    event,
-    delay,
-    id
-  } = params;
-  if (typeof delay === 'number') {
-    actorScope.defer(() => {
-      const self = actorScope.self;
-      actorScope.system.scheduler.schedule(self, self, event, delay, id);
-    });
-    return;
-  }
-}
-/**
- * Raises an event. This places the event in the internal event queue, so that
- * the event is immediately consumed by the machine in the current step.
- *
- * @param eventType The event to raise.
- */
-function raise(eventOrExpr, options) {
-  function raise(args, params) {
-  }
-  raise.type = 'xstate.raise';
-  raise.event = eventOrExpr;
-  raise.id = options?.id;
-  raise.delay = options?.delay;
-  raise.resolve = resolveRaise;
-  raise.execute = executeRaise;
-  return raise;
-}
-
-export { $$ACTOR_TYPE as $, createActor as A, Actor as B, interpret as C, isMachineSnapshot as D, and as E, not as F, or as G, stateIn as H, getAllOwnEventDescriptors as I, matchesState as J, pathToStateValue as K, toObserver as L, cancel as M, NULL_EVENT as N, raise as O, spawnChild as P, stop as Q, stopChild as R, STATE_DELIMITER as S, ProcessingStatus as T, cloneMachineSnapshot as U, XSTATE_ERROR as V, createErrorActorEvent as W, XSTATE_STOP as X, toTransitionConfigArray as a, formatTransition as b, createInvokeId as c, formatInitialTransition as d, evaluateGuard as e, formatTransitions as f, getDelayedTransitions as g, getCandidates as h, getAllStateNodes as i, getStateNodes as j, createMachineSnapshot as k, isInFinalState as l, mapValues as m, macrostep as n, transitionNode as o, resolveActionsAndContext as p, createInitEvent as q, resolveStateValue as r, microstep as s, toArray as t, getInitialStateNodes as u, toStatePath as v, isStateId as w, getStateNodeByPath as x, getPersistedSnapshot as y, resolveReferencedActor as z };
+export { $$ACTOR_TYPE as $, createActor as A, isMachineSnapshot as B, Actor as C, interpret as D, and as E, not as F, or as G, stateIn as H, getAllOwnEventDescriptors as I, matchesState as J, pathToStateValue as K, toObserver as L, cancel as M, NULL_EVENT as N, raise as O, spawnChild as P, stop as Q, stopChild as R, STATE_DELIMITER as S, ProcessingStatus as T, cloneMachineSnapshot as U, XSTATE_ERROR as V, createErrorActorEvent as W, XSTATE_STOP as X, toTransitionConfigArray as a, formatTransition as b, createInvokeId as c, formatInitialTransition as d, evaluateGuard as e, formatTransitions as f, getDelayedTransitions as g, getCandidates as h, getAllStateNodes as i, getStateNodes as j, createMachineSnapshot as k, isInFinalState as l, mapValues as m, macrostep as n, transitionNode as o, resolveActionsAndContext as p, createInitEvent as q, resolveStateValue as r, microstep as s, toArray as t, getInitialStateNodes as u, toStatePath as v, isStateId as w, getStateNodeByPath as x, getPersistedSnapshot as y, resolveReferencedActor as z };

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

@@ -1,11 +1,11 @@
 import type { StateNode } from "./StateNode.js";
 import type { StateMachine } from "./StateMachine.js";
-import type { ProvidedActor, AnyMachineSnapshot, AnyStateMachine, EventObject, HistoryValue, MachineContext, StateConfig, StateValue, AnyActorRef, Snapshot, ParameterizedObject, IsNever, MetaObject, SnapshotStatus } from "./types.js";
+import type { ProvidedActor, AnyMachineSnapshot, AnyStateMachine, EventObject, HistoryValue, MachineContext, StateConfig, StateValue, AnyActorRef, Snapshot, ParameterizedObject, IsNever, MetaObject, StateSchema, StateId, SnapshotStatus } from "./types.js";
 type ToTestStateValue<TStateValue extends StateValue> = TStateValue extends string ? TStateValue : IsNever<keyof TStateValue> extends true ? never : keyof TStateValue | {
     [K in keyof TStateValue]?: ToTestStateValue<NonNullable<TStateValue[K]>>;
 };
 export declare function isMachineSnapshot<TContext extends MachineContext, TEvent extends EventObject>(value: unknown): value is AnyMachineSnapshot;
-interface MachineSnapshotBase<TContext extends MachineContext, TEvent extends EventObject, TChildren extends Record<string, AnyActorRef | undefined>, TStateValue extends StateValue, TTag extends string, TOutput, TMeta, _TUnusedButLeftForCompatReasons = never> {
+interface MachineSnapshotBase<TContext extends MachineContext, TEvent extends EventObject, TChildren extends Record<string, AnyActorRef | undefined>, TStateValue extends StateValue, TTag extends string, TOutput, TMeta, TConfig extends StateSchema = StateSchema> {
     /** The state machine that produced this state snapshot. */
     machine: StateMachine<TContext, TEvent, TChildren, ProvidedActor, ParameterizedObject, ParameterizedObject, string, TStateValue, TTag, unknown, TOutput, EventObject, // TEmitted
     any>;
@@ -64,30 +64,30 @@ interface MachineSnapshotBase<TContext extends MachineContext, TEvent extends Ev
      * @returns Whether the event will cause a transition
      */
     can: (event: TEvent) => boolean;
-    getMeta: () => Record<string, TMeta | undefined>;
+    getMeta: () => Record<StateId<TConfig> & 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> extends MachineSnapshotBase<TContext, TEvent, TChildren, TStateValue, TTag, TOutput, TMeta> {
+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> {
     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> extends MachineSnapshotBase<TContext, TEvent, TChildren, TStateValue, TTag, TOutput, TMeta> {
+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> {
     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> extends MachineSnapshotBase<TContext, TEvent, TChildren, TStateValue, TTag, TOutput, TMeta> {
+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 = StateSchema> extends MachineSnapshotBase<TContext, TEvent, TChildren, TStateValue, TTag, TOutput, TMeta, TConfig> {
     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> extends MachineSnapshotBase<TContext, TEvent, TChildren, TStateValue, TTag, TOutput, TMeta> {
+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 = StateSchema> extends MachineSnapshotBase<TContext, TEvent, TChildren, TStateValue, TTag, TOutput, TMeta, TConfig> {
     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, _TUnusedButLeftForCompatReasons = never> = ActiveMachineSnapshot<TContext, TEvent, TChildren, TStateValue, TTag, TOutput, TMeta> | DoneMachineSnapshot<TContext, TEvent, TChildren, TStateValue, TTag, TOutput, TMeta> | ErrorMachineSnapshot<TContext, TEvent, TChildren, TStateValue, TTag, TOutput, TMeta> | StoppedMachineSnapshot<TContext, TEvent, TChildren, TStateValue, TTag, TOutput, TMeta>;
+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 = 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 declare function createMachineSnapshot<TContext extends MachineContext, TEvent extends EventObject, TChildren extends Record<string, AnyActorRef | undefined>, TStateValue extends StateValue, TTag extends string, TMeta extends MetaObject>(config: StateConfig<TContext, TEvent>, machine: AnyStateMachine): MachineSnapshot<TContext, TEvent, TChildren, TStateValue, TTag, undefined, TMeta>;
 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>, options?: unknown): Snapshot<unknown>;

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

@@ -1,11 +1,9 @@
 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, SnapshotStatus } from "./types.js";
-export declare const STATE_IDENTIFIER = "#";
-export declare const WILDCARD = "*";
+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 = EventObject, // TODO: remove default
-TMeta extends MetaObject = MetaObject> implements ActorLogic<MachineSnapshot<TContext, TEvent, TChildren, TStateValue, TTag, TOutput, TMeta>, TEvent, TInput, AnyActorSystem, TEmitted> {
+TMeta extends MetaObject = MetaObject, TConfig extends StateSchema = StateSchema> implements ActorLogic<MachineSnapshot<TContext, TEvent, TChildren, TStateValue, TTag, TOutput, TMeta, TConfig>, TEvent, TInput, AnyActorSystem, TEmitted> {
     /** The raw config used to create the machine. */
     config: MachineConfig<TContext, TEvent, any, any, any, any, any, any, TOutput, any, // TEmitted
     any> & {
@@ -43,7 +41,7 @@ TMeta extends MetaObject = MetaObject> implements ActorLogic<MachineSnapshot<TCo
         error?: unknown;
     } & (Equals<TContext, MachineContext> extends false ? {
         context: unknown;
-    } : {})): MachineSnapshot<TContext, TEvent, TChildren, TStateValue, TTag, TOutput, TMeta>;
+    } : {})): MachineSnapshot<TContext, TEvent, TChildren, TStateValue, TTag, TOutput, TMeta, TConfig>;
     /**
      * Determines the next snapshot given the current `snapshot` and received
      * `event`. Calculates a full macrostep from all microsteps.
@@ -51,7 +49,7 @@ TMeta extends MetaObject = MetaObject> implements ActorLogic<MachineSnapshot<TCo
      * @param snapshot The current snapshot
      * @param event The received event
      */
-    transition(snapshot: MachineSnapshot<TContext, TEvent, TChildren, TStateValue, TTag, TOutput, TMeta>, event: TEvent, actorScope: ActorScope<typeof snapshot, TEvent, AnyActorSystem, TEmitted>): MachineSnapshot<TContext, TEvent, TChildren, TStateValue, TTag, TOutput, TMeta>;
+    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>;
     /**
      * Determines the next state given the current `state` and `event`. Calculates
      * a microstep.
@@ -59,8 +57,8 @@ TMeta extends MetaObject = MetaObject> implements ActorLogic<MachineSnapshot<TCo
      * @param state The current state
      * @param event The received event
      */
-    microstep(snapshot: MachineSnapshot<TContext, TEvent, TChildren, TStateValue, TTag, TOutput, TMeta>, event: TEvent, actorScope: AnyActorScope): Array<MachineSnapshot<TContext, TEvent, TChildren, TStateValue, TTag, TOutput, TMeta>>;
-    getTransitionData(snapshot: MachineSnapshot<TContext, TEvent, TChildren, TStateValue, TTag, TOutput, TMeta>, event: TEvent): Array<TransitionDefinition<TContext, TEvent>>;
+    microstep(snapshot: MachineSnapshot<TContext, TEvent, TChildren, TStateValue, TTag, TOutput, TMeta, TConfig>, event: TEvent, actorScope: AnyActorScope): Array<MachineSnapshot<TContext, TEvent, TChildren, TStateValue, TTag, TOutput, TMeta, TConfig>>;
+    getTransitionData(snapshot: MachineSnapshot<TContext, TEvent, TChildren, TStateValue, TTag, TOutput, TMeta, TConfig>, event: TEvent): 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.
@@ -70,11 +68,11 @@ TMeta extends MetaObject = MetaObject> implements ActorLogic<MachineSnapshot<TCo
      * Returns the initial `State` instance, with reference to `self` as an
      * `ActorRef`.
      */
-    getInitialSnapshot(actorScope: ActorScope<MachineSnapshot<TContext, TEvent, TChildren, TStateValue, TTag, TOutput, TMeta>, TEvent, AnyActorSystem, TEmitted>, input?: TInput): MachineSnapshot<TContext, TEvent, TChildren, TStateValue, TTag, TOutput, TMeta>;
-    start(snapshot: MachineSnapshot<TContext, TEvent, TChildren, TStateValue, TTag, TOutput, TMeta>): void;
+    getInitialSnapshot(actorScope: ActorScope<MachineSnapshot<TContext, TEvent, TChildren, TStateValue, TTag, TOutput, TMeta, TConfig>, TEvent, AnyActorSystem, TEmitted>, input?: TInput): MachineSnapshot<TContext, TEvent, TChildren, TStateValue, TTag, TOutput, TMeta, TConfig>;
+    start(snapshot: MachineSnapshot<TContext, TEvent, TChildren, TStateValue, TTag, TOutput, TMeta, TConfig>): void;
     getStateNodeById(stateId: string): StateNode<TContext, TEvent>;
     get definition(): StateMachineDefinition<TContext, TEvent>;
     toJSON(): StateMachineDefinition<TContext, TEvent>;
-    getPersistedSnapshot(snapshot: MachineSnapshot<TContext, TEvent, TChildren, TStateValue, TTag, TOutput, TMeta>, options?: unknown): Snapshot<unknown>;
-    restoreSnapshot(snapshot: Snapshot<unknown>, _actorScope: ActorScope<MachineSnapshot<TContext, TEvent, TChildren, TStateValue, TTag, TOutput, TMeta>, TEvent, AnyActorSystem, TEmitted>): MachineSnapshot<TContext, TEvent, TChildren, TStateValue, TTag, TOutput, TMeta>;
+    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>;
 }

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

@@ -13,6 +13,7 @@ export declare function stopChild<TContext extends MachineContext, TExpressionEv
  * Stops a child actor.
  *
  * @deprecated Use `stopChild(...)` instead
+ * @alias
  */
 export declare const stop: typeof stopChild;
 export {};

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

@@ -39,10 +39,10 @@ export type CallbackActorLogic<TEvent extends EventObject, TInput = NonReducible
  * @see {@link fromCallback}
  */
 export type CallbackActorRef<TEvent extends EventObject, TInput = NonReducibleUnknown> = ActorRefFrom<CallbackActorLogic<TEvent, TInput>>;
-export type Receiver<TEvent extends EventObject> = (listener: {
+type Receiver<TEvent extends EventObject> = (listener: {
     bivarianceHack(event: TEvent): void;
 }['bivarianceHack']) => void;
-export type InvokeCallback<TEvent extends EventObject = AnyEventObject, TSentEvent extends EventObject = AnyEventObject, TInput = NonReducibleUnknown, TEmitted extends EventObject = EventObject> = ({ input, system, self, sendBack, receive, emit }: {
+type InvokeCallback<TEvent extends EventObject = AnyEventObject, TSentEvent extends EventObject = AnyEventObject, TInput = NonReducibleUnknown, TEmitted extends EventObject = EventObject> = ({ input, system, self, sendBack, receive, emit }: {
     /**
      * Data that was provided to the callback actor
      *
@@ -130,3 +130,4 @@ export type InvokeCallback<TEvent extends EventObject = AnyEventObject, TSentEve
  * @see {@link https://stately.ai/docs/input | Input docs} for more information about how input is passed
  */
 export declare function fromCallback<TEvent extends EventObject, TInput = NonReducibleUnknown, TEmitted extends EventObject = EventObject>(invokeCallback: InvokeCallback<TEvent, AnyEventObject, TInput, TEmitted>): CallbackActorLogic<TEvent, TInput, TEmitted>;
+export {};

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

@@ -1,12 +1,8 @@
 import { symbolObservable } from "./symbolObservable.js";
 import { AnyActorSystem, Clock } from "./system.js";
 import type { AnyActorLogic, AnyActorRef, ConditionalRequired, EmittedFrom, EventFromLogic, InputFrom, IsNotNever, Snapshot, SnapshotFrom } from "./types.js";
-import { ActorOptions, ActorRef, EventObject, InteropSubscribable, Observer, Subscription } from "./types.js";
+import { ActorOptions, ActorRef, InteropSubscribable, Observer, Subscription } from "./types.js";
 export declare const $$ACTOR_TYPE = 1;
-export type SnapshotListener<TLogic extends AnyActorLogic> = (snapshot: SnapshotFrom<TLogic>) => void;
-export type EventListener<TEvent extends EventObject = EventObject> = (event: TEvent) => void;
-export type Listener = () => void;
-export type ErrorListener = (error: any) => void;
 export declare enum ProcessingStatus {
     NotStarted = 0,
     Running = 1,
@@ -219,8 +215,12 @@ export declare function createActor<TLogic extends AnyActorLogic>(logic: TLogic,
  * options, if any.
  *
  * @deprecated Use `createActor` instead
+ * @alias
  */
 export declare const interpret: typeof createActor;
-/** @deprecated Use `Actor` instead. */
+/**
+ * @deprecated Use `Actor` instead.
+ * @alias
+ */
 export type Interpreter = typeof Actor;
 export {};

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

@@ -1,24 +1,23 @@
-export * from "./actions.js";
-export * from "./actors/index.js";
 export { SimulatedClock } from "./SimulatedClock.js";
-export { type Spawner } from "./spawn.js";
 export { isMachineSnapshot, type MachineSnapshot } from "./State.js";
 export { StateMachine } from "./StateMachine.js";
-export { getStateNodes } from "./stateUtils.js";
-export * from "./types.js";
-export { waitFor } from "./waitFor.js";
-import { createMachine } from "./createMachine.js";
+export { StateNode } from "./StateNode.js";
+export * from "./actions.js";
+export * from "./actors/index.js";
+export { assertEvent } from "./assert.js";
+export { Actor, createActor, interpret, type Interpreter } from "./createActor.js";
+export { createMachine } from "./createMachine.js";
 export { getInitialSnapshot, getNextSnapshot } from "./getNextSnapshot.js";
-import { Actor, createActor, interpret, type Interpreter } from "./createActor.js";
-import { StateNode } from "./StateNode.js";
 export { and, not, or, stateIn } from "./guards.js";
+export type { InspectedActorEvent, InspectedEventEvent, InspectedSnapshotEvent, InspectionEvent } from "./inspection.js";
 export { setup } from "./setup.js";
+export { type Spawner } from "./spawn.js";
+export { getStateNodes } from "./stateUtils.js";
 export type { ActorSystem } from "./system.js";
-export type { InspectedActorEvent, InspectedEventEvent, InspectedSnapshotEvent, InspectionEvent } from "./inspection.js";
 export { toPromise } from "./toPromise.js";
+export * from "./types.js";
 export { getAllOwnEventDescriptors as __unsafe_getAllOwnEventDescriptors, matchesState, pathToStateValue, toObserver } from "./utils.js";
-export { Actor, createActor, createMachine, interpret, StateNode, type Interpreter };
-export { assertEvent } from "./assert.js";
+export { waitFor } from "./waitFor.js";
 declare global {
     interface SymbolConstructor {
         readonly observable: symbol;

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

@@ -1,6 +1,6 @@
 import { AnyActorRef, AnyEventObject, AnyTransitionDefinition, Snapshot } from "./types.js";
 export type InspectionEvent = InspectedSnapshotEvent | InspectedEventEvent | InspectedActorEvent | InspectedMicrostepEvent | InspectedActionEvent;
-export interface BaseInspectionEventProperties {
+interface BaseInspectionEventProperties {
     rootId: string;
     /**
      * The relevant actorRef for the inspection event.
@@ -16,7 +16,7 @@ export interface InspectedSnapshotEvent extends BaseInspectionEventProperties {
     event: AnyEventObject;
     snapshot: Snapshot<unknown>;
 }
-export interface InspectedMicrostepEvent extends BaseInspectionEventProperties {
+interface InspectedMicrostepEvent extends BaseInspectionEventProperties {
     type: '@xstate.microstep';
     event: AnyEventObject;
     snapshot: Snapshot<unknown>;
@@ -37,3 +37,4 @@ export interface InspectedEventEvent extends BaseInspectionEventProperties {
 export interface InspectedActorEvent extends BaseInspectionEventProperties {
     type: '@xstate.actor';
 }
+export {};