xstate 6.0.0-alpha.2 → 6.0.0-alpha.4

package/dist/xstate-actors.umd.min.js.map

@@ -1 +1 @@
-{"version":3,"file":"xstate-actors.umd.min.js","sources":["../src/Mailbox.ts","../src/constants.ts","../src/eventUtils.ts","../src/reportUnhandledError.ts","../src/symbolObservable.ts","../src/actors/attached.ts","../src/actors/listener.ts","../src/utils.ts","../src/atom.ts","../src/actors/subscription.ts","../src/delay.ts","../src/system.ts","../src/actors/logic.ts","../src/createActor.ts","../src/actors/callback.ts","../src/actors/observable.ts","../src/actors/promise.ts","../src/actors/index.ts"],"sourcesContent":["interface MailboxItem<T> {\n  value: T;\n  next: MailboxItem<T> | null;\n}\n\nexport class Mailbox<T> {\n  private _active: boolean = false;\n  private _current: MailboxItem<T> | null = null;\n  private _last: MailboxItem<T> | null = null;\n\n  constructor(private _process: (ev: T) => void) {}\n\n  public start() {\n    this._active = true;\n    this.flush();\n  }\n\n  public clear(): void {\n    // we can't set _current to null because we might be currently processing\n    // and enqueue following clear shouldn't start processing the enqueued item immediately\n    if (this._current) {\n      this._current.next = null;\n      this._last = this._current;\n    }\n  }\n\n  public enqueue(event: T): void {\n    const enqueued = {\n      value: event,\n      next: null\n    };\n\n    if (this._current) {\n      this._last!.next = enqueued;\n      this._last = enqueued;\n      return;\n    }\n\n    this._current = enqueued;\n    this._last = enqueued;\n\n    if (this._active) {\n      this.flush();\n    }\n  }\n\n  private flush() {\n    while (this._current) {\n      // atm the given _process is responsible for implementing proper try/catch handling\n      // we assume here that this won't throw in a way that can affect this mailbox\n      const consumed = this._current;\n      this._process(consumed.value);\n      this._current = consumed.next;\n    }\n    this._last = null;\n  }\n}\n","export const STATE_DELIMITER = '.';\nexport const TARGETLESS_KEY = '';\nexport const NULL_EVENT = '';\nexport const STATE_IDENTIFIER = '#';\nexport const WILDCARD = '*';\nexport const XSTATE_INIT = '@xstate.init';\nexport const XSTATE_STOP = '@xstate.stop';\n","import { XSTATE_INIT } from './constants.ts';\nimport { DoneActorEvent, DoneStateEvent, ErrorActorEvent } from './types.ts';\n\n/**\n * Returns an event that represents an implicit event that is sent after the\n * specified `delay`.\n *\n * @param delayRef The delay in milliseconds\n * @param id The state node ID where this event is handled\n */\nexport function createAfterEvent(delayRef: number | string, id: string) {\n  return { type: `xstate.after.${delayRef}.${id}` } as const;\n}\n\n/**\n * Returns an event that represents an implicit state-level timeout. Fired when\n * a state's `timeout` duration elapses without the state being exited.\n *\n * @param id The state node ID where this timeout is configured\n */\nexport function createTimeoutEvent(id: string) {\n  return { type: `xstate.timeout.${id}` } as const;\n}\n\n/**\n * Returns an event that represents an implicit invoke-level timeout. Fired when\n * an invoked actor has not completed within its `timeout` duration.\n *\n * @param invokeId The invoked actor's ID\n */\nexport function createInvokeTimeoutEvent(invokeId: string) {\n  return { type: `xstate.timeout.actor.${invokeId}` } as const;\n}\n\n/**\n * Returns an event that represents that a final state node has been reached in\n * the parent state node.\n *\n * @param id The final state node's parent state node `id`\n * @param output The data to pass into the event\n */\nexport function createDoneStateEvent(\n  id: string,\n  output?: unknown\n): DoneStateEvent {\n  return {\n    type: `xstate.done.state.${id}`,\n    output\n  };\n}\n\n/**\n * Returns an event that represents that an invoked service has terminated.\n *\n * An invoked service is terminated when it has reached a top-level final state\n * node, but not when it is canceled.\n *\n * @param invokeId The invoked service ID\n * @param output The data to pass into the event\n */\nexport function createDoneActorEvent(\n  invokeId: string,\n  output?: unknown\n): DoneActorEvent {\n  return {\n    type: `xstate.done.actor.${invokeId}`,\n    output,\n    actorId: invokeId\n  };\n}\n\nexport function createErrorActorEvent(\n  id: string,\n  error?: unknown\n): ErrorActorEvent {\n  return { type: `xstate.error.actor.${id}`, error, actorId: id };\n}\n\nexport function createInitEvent(input: unknown) {\n  return { type: XSTATE_INIT, input } as const;\n}\n","/**\n * This function makes sure that unhandled errors are thrown in a separate\n * macrotask. It allows those errors to be detected by global error handlers and\n * reported to bug tracking services without interrupting our own stack of\n * execution.\n *\n * @param err Error to be thrown\n */\nexport function reportUnhandledError(err: unknown) {\n  setTimeout(() => {\n    throw err;\n  });\n}\n","export const symbolObservable: typeof Symbol.observable = (() =>\n  (typeof Symbol === 'function' && Symbol.observable) ||\n  '@@observable')() as any;\n","import { XSTATE_STOP } from '../constants.ts';\nimport type { AnyActorSystem } from '../system.ts';\nimport type {\n  AnyActor,\n  EventObject,\n  Snapshot,\n  Subscription\n} from '../types.ts';\n\nconst subscriptions = /* #__PURE__ */ new WeakMap<AnyActor, Subscription>();\n\n/**\n * Internal factory for actor logic that attaches to another actor on start\n * (`enq.listen()` / `enq.subscribeTo()`) and detaches when stopped.\n */\nexport function createAttachedLogic(\n  attach: (\n    input: any,\n    scope: { self: AnyActor; system: AnyActorSystem }\n  ) => Subscription | undefined\n): any {\n  return {\n    start: (state: any, { self, system }: any) => {\n      // Don't attach if the target doesn't exist, or (for actors) is stopped.\n      // Atoms have no `getSnapshot` / lifecycle, so they always attach.\n      const target = state.input.actor;\n      if (\n        !target ||\n        (typeof target.getSnapshot === 'function' &&\n          target.getSnapshot().status === 'stopped')\n      ) {\n        return;\n      }\n      const subscription = attach(state.input, { self, system });\n      if (!subscription) {\n        return;\n      }\n\n      // Attached actors are not registered as children (their `input` holds\n      // non-serializable function mappers), so a parent stop does not cascade\n      // to them. Subscribe to the parent and tear down when it stops/errors,\n      // so the subscription never relays to a stopped parent or leaks the\n      // source subscription.\n      let parentSubscription: Subscription | undefined;\n      let torndown = false;\n      const teardown = () => {\n        if (torndown) {\n          return;\n        }\n        torndown = true;\n        subscription.unsubscribe();\n        parentSubscription?.unsubscribe();\n      };\n\n      const parent: AnyActor | undefined = self._parent;\n      if (parent) {\n        parentSubscription = parent.subscribe({\n          complete: teardown,\n          error: teardown\n        });\n      }\n\n      subscriptions.set(self, { unsubscribe: teardown });\n    },\n    transition: (state: any, event: EventObject, { self }: any) => {\n      if (event.type === XSTATE_STOP) {\n        subscriptions.get(self)?.unsubscribe();\n        subscriptions.delete(self);\n        return {\n          ...state,\n          status: 'stopped',\n          error: undefined\n        };\n      }\n      return state;\n    },\n    getInitialSnapshot: (_: unknown, input: unknown) => ({\n      status: 'active',\n      output: undefined,\n      error: undefined,\n      input\n    }),\n    getPersistedSnapshot: (snapshot: Snapshot<unknown>) => snapshot,\n    restoreSnapshot: (snapshot: Snapshot<unknown>) => snapshot\n  };\n}\n\n/**\n * Relays a mapped event to the attached actor's parent, unless the attached\n * actor has been stopped (the mapper is not called in that case).\n */\nexport function relayMappedToParent(\n  self: AnyActor,\n  system: AnyActorSystem,\n  getEvent: () => EventObject\n): void {\n  if (self.getSnapshot().status === 'stopped' || !self._parent) {\n    return;\n  }\n  system._relay(self, self._parent, getEvent());\n}\n","import { AnyActorSystem } from '../system.ts';\nimport { matchesEventDescriptor } from '../utils.ts';\nimport {\n  ActorLogic,\n  ActorRefFromLogic,\n  AnyActor,\n  EventObject,\n  Snapshot\n} from '../types';\nimport { createAttachedLogic, relayMappedToParent } from './attached.ts';\n\nexport type ListenerSnapshot = Snapshot<undefined> & {\n  input: ListenerInput<any, any>;\n};\n\nexport interface ListenerInput<\n  TEmitted extends EventObject,\n  TMappedEvent extends EventObject\n> {\n  actor: AnyActor;\n  eventType: string;\n  mapper: (event: TEmitted) => TMappedEvent;\n}\n\nexport type ListenerActorLogic<\n  TEmitted extends EventObject = EventObject,\n  TMappedEvent extends EventObject = EventObject\n> = ActorLogic<\n  ListenerSnapshot,\n  EventObject,\n  ListenerInput<TEmitted, TMappedEvent>,\n  AnyActorSystem,\n  EventObject\n>;\n\nexport type ListenerActorRef<\n  TEmitted extends EventObject = EventObject,\n  TMappedEvent extends EventObject = EventObject\n> = ActorRefFromLogic<ListenerActorLogic<TEmitted, TMappedEvent>>;\n\n/**\n * Creates actor logic for listening to emitted events from another actor. Used\n * internally by `enq.listen()`.\n */\nexport function createListenerLogic<\n  TEmitted extends EventObject = EventObject,\n  TMappedEvent extends EventObject = EventObject\n>(): ListenerActorLogic<TEmitted, TMappedEvent> {\n  return createAttachedLogic(\n    (\n      { actor, eventType, mapper }: ListenerInput<TEmitted, TMappedEvent>,\n      { self, system }\n    ) => {\n      // Determine the subscription type:\n      // - For exact matches or '*', subscribe directly\n      // - For partial wildcards ('data.*'), subscribe to '*' and filter\n      const isPartialWildcard = eventType !== '*' && eventType.endsWith('.*');\n\n      return actor.on(isPartialWildcard ? '*' : eventType, (emittedEvent) => {\n        if (\n          isPartialWildcard &&\n          !matchesEventDescriptor(emittedEvent.type, eventType)\n        ) {\n          return;\n        }\n        relayMappedToParent(self, system, () =>\n          mapper(emittedEvent as TEmitted)\n        );\n      });\n    }\n  );\n}\n\n// Singleton logic instance\nexport const listenerLogic = /* #__PURE__ */ createListenerLogic();\n","import isDevelopment from '#is-development';\nimport { isMachineSnapshot } from './State.ts';\nimport type { StateNode } from './StateNode.ts';\nimport { TARGETLESS_KEY, WILDCARD } from './constants.ts';\nimport { isStateId } from './stateUtils.ts';\nimport type {\n  AnyActor,\n  AnyEventObject,\n  AnyMachineSnapshot,\n  AnyStateMachine,\n  AnyTransitionConfig,\n  AnyTransitionConfigFunction,\n  ErrorActorEvent,\n  EventObject,\n  InvokeConfig,\n  MachineContext,\n  Mapper,\n  NonReducibleUnknown,\n  Observer,\n  SingleOrArray,\n  StateLike,\n  StateValue,\n  TransitionConfigTarget\n} from './types.ts';\n\nexport function matchesState(\n  parentStateId: StateValue,\n  childStateId: StateValue\n): boolean {\n  const parentStateValue = toStateValue(parentStateId);\n  const childStateValue = toStateValue(childStateId);\n\n  if (typeof childStateValue === 'string') {\n    if (typeof parentStateValue === 'string') {\n      return childStateValue === parentStateValue;\n    }\n\n    // Parent more specific than child\n    return false;\n  }\n\n  if (typeof parentStateValue === 'string') {\n    return parentStateValue in childStateValue;\n  }\n\n  return Object.keys(parentStateValue).every((key) => {\n    if (!(key in childStateValue)) {\n      return false;\n    }\n\n    return matchesState(parentStateValue[key]!, childStateValue[key]!);\n  });\n}\n\nexport function checkStateIn(\n  snapshot: AnyMachineSnapshot,\n  stateValue: StateValue\n) {\n  if (typeof stateValue === 'string' && isStateId(stateValue)) {\n    const target = snapshot.machine.getStateNodeById(stateValue);\n    return snapshot._nodes.some((sn) => sn === target);\n  }\n\n  return snapshot.matches(stateValue);\n}\n\nexport function toStatePath(stateId: string | string[]): string[] {\n  if (isArray(stateId)) {\n    return stateId;\n  }\n\n  const result: string[] = [];\n  let segment = '';\n\n  for (let i = 0; i < stateId.length; i++) {\n    const char = stateId.charCodeAt(i);\n    switch (char) {\n      // \\\n      case 92:\n        // consume the next character\n        segment += stateId[i + 1];\n        // and skip over it\n        i++;\n        continue;\n      // .\n      case 46:\n        result.push(segment);\n        segment = '';\n        continue;\n    }\n    segment += stateId[i];\n  }\n\n  result.push(segment);\n\n  return result;\n}\n\nfunction toStateValue(stateValue: StateLike<any> | StateValue): StateValue {\n  if (isMachineSnapshot(stateValue)) {\n    return stateValue.value;\n  }\n\n  if (typeof stateValue !== 'string') {\n    return stateValue as StateValue;\n  }\n\n  const statePath = toStatePath(stateValue);\n\n  return pathToStateValue(statePath);\n}\n\nexport function pathToStateValue(statePath: string[]): StateValue {\n  if (statePath.length === 1) {\n    return statePath[0];\n  }\n\n  const value: StateValue = {};\n  let marker = value;\n\n  for (let i = 0; i < statePath.length - 1; i++) {\n    if (i === statePath.length - 2) {\n      marker[statePath[i]] = statePath[i + 1];\n    } else {\n      const previous = marker;\n      marker = {};\n      previous[statePath[i]] = marker;\n    }\n  }\n\n  return value;\n}\n\nexport function mapValues<P, O extends Record<string, unknown>>(\n  collection: O,\n  iteratee: (item: O[keyof O], key: keyof O, collection: O, i: number) => P\n): { [key in keyof O]: P };\nexport function mapValues(\n  collection: Record<string, unknown>,\n  iteratee: (\n    item: unknown,\n    key: string,\n    collection: Record<string, unknown>,\n    i: number\n  ) => unknown\n) {\n  const result: Record<string, unknown> = {};\n\n  const collectionKeys = Object.keys(collection);\n  for (let i = 0; i < collectionKeys.length; i++) {\n    const key = collectionKeys[i];\n    result[key] = iteratee(collection[key], key, collection, i);\n  }\n\n  return result;\n}\n\nfunction toArrayStrict<T>(value: readonly T[] | T): readonly T[] {\n  if (isArray(value)) {\n    return value;\n  }\n  return [value];\n}\n\nexport function toArray<T>(value: readonly T[] | T | undefined): readonly T[] {\n  if (value === undefined) {\n    return [];\n  }\n  return toArrayStrict(value);\n}\n\nexport function resolveOutput<\n  TContext extends MachineContext,\n  TExpressionEvent extends EventObject\n>(\n  mapper:\n    | Mapper<TContext, TExpressionEvent, unknown, EventObject>\n    | NonReducibleUnknown,\n  context: TContext,\n  event: TExpressionEvent,\n  self: AnyActor\n): unknown {\n  if (typeof mapper === 'function') {\n    return mapper({ context, event, self });\n  }\n\n  if (\n    isDevelopment &&\n    !!mapper &&\n    typeof mapper === 'object' &&\n    Object.values(mapper).some((val) => typeof val === 'function')\n  ) {\n    console.warn(\n      `Dynamically mapping values to individual properties is deprecated. Use a single function that returns the mapped object instead.\\nFound object containing properties whose values are possibly mapping functions: ${Object.entries(\n        mapper\n      )\n        .filter(([, value]) => typeof value === 'function')\n        .map(\n          ([key, value]) =>\n            `\\n - ${key}: ${(value as () => any)\n              .toString()\n              .replace(/\\n\\s*/g, '')}`\n        )\n        .join('')}`\n    );\n  }\n\n  return mapper;\n}\n\nfunction isArray(value: any): value is readonly any[] {\n  return Array.isArray(value);\n}\n\nexport function isErrorActorEvent(\n  event: AnyEventObject\n): event is ErrorActorEvent {\n  return event.type.startsWith('xstate.error.actor');\n}\n\nexport function toTransitionConfigArray(\n  configLike: SingleOrArray<\n    AnyTransitionConfig | TransitionConfigTarget | AnyTransitionConfigFunction\n  >\n): Array<AnyTransitionConfig> {\n  return toArrayStrict(configLike).map((transitionLike) => {\n    if (\n      typeof transitionLike === 'undefined' ||\n      typeof transitionLike === 'string'\n    ) {\n      return { target: transitionLike };\n    }\n\n    if (typeof transitionLike === 'function') {\n      return { to: transitionLike };\n    }\n\n    return transitionLike;\n  });\n}\n\nexport function normalizeTarget<\n  TContext extends MachineContext,\n  TEvent extends EventObject\n>(\n  target: SingleOrArray<string | StateNode<TContext, TEvent>> | undefined\n): ReadonlyArray<string | StateNode<TContext, TEvent>> | undefined {\n  if (target === undefined || target === TARGETLESS_KEY) {\n    return undefined;\n  }\n  return toArray(target);\n}\n\nexport function toObserver<T>(\n  nextHandler?: Observer<T> | ((value: T) => void),\n  errorHandler?: (error: any) => void,\n  completionHandler?: () => void\n): Observer<T> {\n  const isObserver = typeof nextHandler === 'object';\n  const self = isObserver ? nextHandler : undefined;\n\n  return {\n    next: (isObserver ? nextHandler.next : nextHandler)?.bind(self),\n    error: (isObserver ? nextHandler.error : errorHandler)?.bind(self),\n    complete: (isObserver ? nextHandler.complete : completionHandler)?.bind(\n      self\n    )\n  };\n}\n\nexport function createInvokeId(stateNodeId: string, index: number): string {\n  return `${index}.${stateNodeId}`;\n}\n\nexport function resolveReferencedActor(machine: AnyStateMachine, src: string) {\n  const match = src.match(/^xstate\\.invoke\\.(\\d+)\\.(.*)/)!;\n  if (!match) {\n    return machine.implementations.actors[src];\n  }\n  const [, indexStr, nodeId] = match;\n  const node = machine.getStateNodeById(nodeId);\n  const invokeConfig = node.config.invoke!;\n  const configSrc = (\n    Array.isArray(invokeConfig)\n      ? invokeConfig[indexStr as any]\n      : (invokeConfig as InvokeConfig<\n          any,\n          any,\n          any,\n          any,\n          any,\n          any,\n          any, // TEmitted\n          any // TMeta\n        >)\n  ).src;\n  // A referenced actor may itself be registered by name.\n  return typeof configSrc === 'string'\n    ? machine.implementations.actors[configSrc]\n    : configSrc;\n}\n\nexport function getAllOwnEventDescriptors(snapshot: AnyMachineSnapshot) {\n  return [...new Set([...snapshot._nodes.flatMap((sn) => sn.ownEvents)])];\n}\n\n/**\n * Checks if an event type matches an event descriptor, supporting wildcards.\n * Event descriptors can be:\n *\n * - Exact matches: \"event.type\"\n * - Wildcard: \"*\"\n * - Partial matches: \"event.*\"\n *\n * @param eventType - The actual event type string\n * @param descriptor - The event descriptor to match against\n * @returns True if the event type matches the descriptor\n */\nexport function matchesEventDescriptor(\n  eventType: string,\n  descriptor: string\n): boolean {\n  if (descriptor === eventType) {\n    return true;\n  }\n\n  if (descriptor === WILDCARD) {\n    return true;\n  }\n\n  if (!descriptor.endsWith('.*')) {\n    return false;\n  }\n\n  if (isDevelopment && /.*\\*.+/.test(descriptor)) {\n    console.warn(\n      `Wildcards can only be the last token of an event descriptor (e.g., \"event.*\") or the entire event descriptor (\"*\"). Check the \"${descriptor}\" event.`\n    );\n  }\n\n  const partialEventTokens = descriptor.split('.');\n  const eventTokens = eventType.split('.');\n\n  for (\n    let tokenIndex = 0;\n    tokenIndex < partialEventTokens.length;\n    tokenIndex++\n  ) {\n    const partialEventToken = partialEventTokens[tokenIndex];\n    const eventToken = eventTokens[tokenIndex];\n\n    if (partialEventToken === '*') {\n      const isLastToken = tokenIndex === partialEventTokens.length - 1;\n\n      if (isDevelopment && !isLastToken) {\n        console.warn(\n          `Infix wildcards in transition events are not allowed. Check the \"${descriptor}\" transition.`\n        );\n      }\n\n      return isLastToken;\n    }\n\n    if (partialEventToken !== eventToken) {\n      return false;\n    }\n  }\n\n  return true;\n}\n","import {\n  createReactiveSystem,\n  type ReactiveNode,\n  ReactiveFlags\n} from './alien.ts';\nimport { installActorReadHook } from './interop.ts';\nimport { reportUnhandledError } from './reportUnhandledError.ts';\nimport type { AnyActorRef } from './types.ts';\n\ntype Observer<T> = {\n  next?: (value: T) => void;\n  error?: (err: unknown) => void;\n  complete?: () => void;\n};\n\ninterface Subscription {\n  unsubscribe(): void;\n}\n\ninterface Readable<T> extends Subscribable<T> {\n  get: () => T;\n}\n\ninterface Subscribable<T> {\n  subscribe(observer: Observer<T>): Subscription;\n  subscribe(\n    next: (value: T) => void,\n    error?: (error: any) => void,\n    complete?: () => void\n  ): Subscription;\n}\n\n/**\n * Nominal brand (phantom, compile-time only) marking a value as an XState atom.\n * Real atoms get the runtime brand ({@link $$atom}) in `createAtom`; this type\n * brand keeps atom-only APIs (e.g. `enq.subscribeTo`) from structurally\n * accepting plain readables like `actor.select(...)` that would be dispatched\n * down the non-atom path at runtime.\n */\ndeclare const $$atomBrand: unique symbol;\n\nexport interface BaseAtom<T> extends Subscribable<T>, Readable<T> {\n  /** @internal */\n  readonly [$$atomBrand]: true;\n}\n\nexport interface Atom<T> extends BaseAtom<T> {\n  set: (valueOrFn: T | ((prev: T) => T)) => void;\n}\n\nexport interface ReducerAtom<TState, TEvent> extends BaseAtom<TState> {\n  send: (event: TEvent) => void;\n}\n\nexport interface AtomOptions<T> {\n  compare?: (a: T, b: T) => boolean;\n}\n\nexport interface AtomConfig<TValue, TInput> {\n  createAtom: undefined extends TInput\n    ? (input?: TInput) => Atom<TValue>\n    : (input: TInput) => Atom<TValue>;\n}\n\nexport type AnyAtomConfig = AtomConfig<any, any>;\n\nexport type ValueFromAtomConfig<TConfig extends AnyAtomConfig> =\n  TConfig extends AtomConfig<infer TValue, any> ? TValue : never;\n\nexport type InputFromAtomConfig<TConfig extends AnyAtomConfig> =\n  TConfig extends AtomConfig<any, infer TInput> ? TInput : never;\n\nexport type AnyAtom = BaseAtom<any>;\n\nexport interface ReadonlyAtom<T> extends BaseAtom<T> {}\n\n/** Brand marking an object as an atom, so it can be detected structurally. */\nconst $$atom = /* #__PURE__ */ Symbol.for('xstate.atom');\n\n/**\n * Returns `true` if the value is an atom (writable, computed, async, or\n * reducer). Lets actor-consuming APIs (e.g. `enq.subscribeTo`) accept atoms\n * directly.\n */\nexport function isAtom(value: unknown): value is AnyAtom {\n  return (\n    !!value && typeof value === 'object' && ($$atom as any) in (value as any)\n  );\n}\n\ninterface InternalAtom<T> extends ReactiveNode {\n  _snapshot: T;\n  _update(getValue?: T | ((snapshot: T) => T)): boolean;\n  get(): T;\n  subscribe(observerOrFn: Observer<T> | ((value: T) => void)): Subscription;\n}\n\nconst queuedEffects: (Effect | undefined)[] = [];\nlet cycle = 0;\n\ntype ReactiveSystem = ReturnType<typeof createReactiveSystem>;\n// Initialized lazily on first atom creation (instead of at module evaluation)\n// so the reactive system stays tree-shakeable for apps that never use atoms —\n// flat dist chunks lose `#__PURE__` annotations, so a top-level call here\n// would be retained by consumer bundlers even when atoms are unused.\nlet link: ReactiveSystem['link'];\nlet unlink: ReactiveSystem['unlink'];\nlet propagate: ReactiveSystem['propagate'];\nlet checkDirty: ReactiveSystem['checkDirty'];\nlet shallowPropagate: ReactiveSystem['shallowPropagate'];\nlet reactiveSystemInstalled = false;\n\nfunction ensureReactiveSystem() {\n  if (reactiveSystemInstalled) {\n    return;\n  }\n  reactiveSystemInstalled = true;\n  ({ link, unlink, propagate, checkDirty, shallowPropagate } =\n    createReactiveSystem({\n      update(atom: InternalAtom<any>): boolean {\n        return atom._update();\n      },\n      notify(effect: Effect): void {\n        queuedEffects[queuedEffectsLength++] = effect;\n        effect.flags &= ~ReactiveFlags.Watching;\n      },\n      unwatched(atom: InternalAtom<any>): void {\n        if (atom.depsTail !== undefined) {\n          atom.depsTail = undefined;\n          atom.flags = ReactiveFlags.Mutable | ReactiveFlags.Dirty;\n          purgeDeps(atom);\n        }\n      }\n    }));\n}\n\nlet notifyIndex = 0;\nlet queuedEffectsLength = 0;\nlet activeSub: ReactiveNode | undefined;\n\nfunction purgeDeps(sub: ReactiveNode) {\n  const depsTail = sub.depsTail;\n  let dep = depsTail !== undefined ? depsTail.nextDep : sub.deps;\n  while (dep !== undefined) {\n    dep = unlink(dep, sub);\n  }\n}\n\nfunction flush(): void {\n  while (notifyIndex < queuedEffectsLength) {\n    const effect = queuedEffects[notifyIndex]!;\n    queuedEffects[notifyIndex++] = undefined;\n    effect.notify();\n  }\n  notifyIndex = 0;\n  queuedEffectsLength = 0;\n}\n\n/** The current state of an async atom. */\nexport type AsyncAtomState<Data, Error = unknown> =\n  | { status: 'pending' }\n  | { status: 'done'; data: Data }\n  | { status: 'error'; error: Error };\n\n/** Options passed to an async atom getter. */\nexport interface AsyncAtomOptions {\n  /** Signal aborted when the async atom recomputes before this run settles. */\n  signal: AbortSignal;\n}\n\nfunction compareAsyncAtomState<T>(\n  a: AsyncAtomState<T>,\n  b: AsyncAtomState<T>\n): boolean {\n  if (a.status !== b.status) {\n    return false;\n  }\n  if (a.status === 'done' && b.status === 'done') {\n    return Object.is(a.data, b.data);\n  }\n  if (a.status === 'error' && b.status === 'error') {\n    return Object.is(a.error, b.error);\n  }\n  // both 'pending'\n  return true;\n}\n\nfunction updateAsyncAtom<T>(\n  atom: InternalAtom<AsyncAtomState<T>>,\n  nextValue: AsyncAtomState<T>\n): void {\n  if (atom._update(nextValue)) {\n    const subs = atom.subs;\n    if (subs !== undefined) {\n      propagate(subs);\n      shallowPropagate(subs);\n      flush();\n    }\n  }\n}\n\n/**\n * Creates a read-only atom whose value is loaded from an async getter.\n *\n * The getter receives an `AbortSignal`; when the async atom recomputes, the\n * previous signal is aborted and stale resolutions are ignored.\n */\nexport function createAsyncAtom<T>(\n  getValue: (options: AsyncAtomOptions) => Promise<T>,\n  options?: AtomOptions<AsyncAtomState<T>>\n): ReadonlyAtom<AsyncAtomState<T>> {\n  const ref: { current?: InternalAtom<AsyncAtomState<T>> } = {};\n  let currentController: AbortController | undefined;\n  let currentRunId = 0;\n\n  const atom = createAtom<AsyncAtomState<T>>(\n    () => {\n      currentController?.abort();\n\n      const controller = new AbortController();\n      const runId = ++currentRunId;\n      currentController = controller;\n\n      getValue({ signal: controller.signal }).then(\n        (data) => {\n          if (runId !== currentRunId || controller.signal.aborted) {\n            return;\n          }\n          updateAsyncAtom(ref.current!, { status: 'done', data });\n        },\n        (error) => {\n          if (runId !== currentRunId || controller.signal.aborted) {\n            return;\n          }\n          updateAsyncAtom(ref.current!, { status: 'error', error });\n        }\n      );\n\n      return { status: 'pending' } satisfies AsyncAtomState<T>;\n    },\n    { compare: compareAsyncAtomState, ...options }\n  );\n  ref.current = atom as unknown as InternalAtom<AsyncAtomState<T>>;\n\n  return atom;\n}\n\n/**\n * Mirror atoms that bump a version whenever a tracked actor emits a snapshot,\n * letting computed atoms depend on `actor.get()` reads.\n *\n * The hook is installed lazily on first atom creation (not at module\n * evaluation) so that it remains tree-shakeable for apps that never use atoms —\n * any tracked read necessarily happens inside an atom computation, so first-use\n * installation is always early enough.\n */\nlet actorInteropInstalled = false;\n\nfunction ensureActorInterop() {\n  if (actorInteropInstalled) {\n    return;\n  }\n  actorInteropInstalled = true;\n  const actorVersions = new WeakMap<AnyActorRef, Atom<number>>();\n  installActorReadHook((actorRef) => {\n    if (activeSub === undefined) {\n      return;\n    }\n    let version = actorVersions.get(actorRef);\n    if (version === undefined) {\n      version = createAtom(0);\n      actorVersions.set(actorRef, version);\n      actorRef.subscribe({\n        next: () => version!.set((v) => v + 1),\n        error: () => {}\n      });\n    }\n    version.get();\n  });\n}\n\n/**\n * Creates an atom.\n *\n * Pass a value for a writable atom or a getter for a computed read-only atom.\n */\nexport function createAtom<T>(\n  getValue: (prev?: T) => T,\n  options?: AtomOptions<T>\n): ReadonlyAtom<T>;\nexport function createAtom<T>(\n  initialValue: T,\n  options?: AtomOptions<T>\n): Atom<T>;\nexport function createAtom<T>(\n  valueOrFn: T | ((prev?: T) => T),\n  optionsOrInput?: AtomOptions<T>\n): Atom<T> | ReadonlyAtom<T> {\n  ensureReactiveSystem();\n  ensureActorInterop();\n  const isComputed = typeof valueOrFn === 'function';\n  const getter = valueOrFn as (prev?: T) => T;\n\n  // Create plain object atom\n  const atom: InternalAtom<T> = {\n    _snapshot: isComputed ? undefined! : valueOrFn,\n\n    subs: undefined,\n    subsTail: undefined,\n    deps: undefined,\n    depsTail: undefined,\n    flags: isComputed ? ReactiveFlags.None : ReactiveFlags.Mutable,\n\n    get(): T {\n      if (activeSub !== undefined) {\n        link(atom, activeSub, cycle);\n      }\n      return atom._snapshot;\n    },\n\n    subscribe(observerOrFn: Observer<T> | ((value: T) => void)) {\n      const observer =\n        typeof observerOrFn === 'function'\n          ? { next: observerOrFn }\n          : observerOrFn;\n      const observed = { current: false };\n      const e = effect(() => {\n        atom.get();\n        if (!observed.current) {\n          observed.current = true;\n        } else {\n          const prevSub = activeSub;\n          activeSub = undefined;\n          try {\n            observer.next?.(atom._snapshot);\n          } catch (err) {\n            reportUnhandledError(err);\n          } finally {\n            activeSub = prevSub;\n          }\n\n          // If the observer synchronously updates any of our deps we'll be\n          // marked as dirty preventing this effect from re-running. Request\n          // the value again to reconcile any dirty deps.\n          atom.get();\n        }\n      });\n\n      return {\n        unsubscribe: () => {\n          e.stop();\n        }\n      };\n    },\n    _update(getValue?: T | ((snapshot: T) => T)): boolean {\n      const prevSub = activeSub;\n      const compare = optionsOrInput?.compare ?? Object.is;\n      activeSub = atom;\n      ++cycle;\n      atom.depsTail = undefined;\n      if (isComputed) {\n        atom.flags = ReactiveFlags.Mutable | ReactiveFlags.RecursedCheck;\n      }\n      try {\n        const oldValue = atom._snapshot;\n        const newValue =\n          typeof getValue === 'function'\n            ? (getValue as (snapshot: T) => T)(oldValue)\n            : getValue === undefined && isComputed\n              ? getter(oldValue)\n              : getValue!;\n        if (oldValue === undefined || !compare(oldValue, newValue)) {\n          atom._snapshot = newValue;\n          return true;\n        }\n        return false;\n      } finally {\n        activeSub = prevSub;\n        if (isComputed) {\n          atom.flags &= ~ReactiveFlags.RecursedCheck;\n        }\n        purgeDeps(atom);\n      }\n    }\n  };\n\n  if (isComputed) {\n    atom.flags = ReactiveFlags.Mutable | ReactiveFlags.Dirty;\n    atom.get = function (): T {\n      const flags = atom.flags;\n      if (\n        flags & ReactiveFlags.Dirty ||\n        (flags & ReactiveFlags.Pending && checkDirty(atom.deps!, atom))\n      ) {\n        if (atom._update()) {\n          const subs = atom.subs;\n          if (subs !== undefined) {\n            shallowPropagate(subs);\n          }\n        }\n      } else if (flags & ReactiveFlags.Pending) {\n        atom.flags = flags & ~ReactiveFlags.Pending;\n      }\n      if (activeSub !== undefined) {\n        link(atom, activeSub, cycle);\n      }\n      return atom._snapshot;\n    };\n  } else {\n    (atom as unknown as Atom<T>).set = function (\n      valueOrFn: T | ((prev: T) => T)\n    ): void {\n      if (atom._update(valueOrFn)) {\n        const subs = atom.subs;\n        if (subs !== undefined) {\n          propagate(subs);\n          shallowPropagate(subs);\n          flush();\n        }\n      }\n    };\n  }\n\n  (atom as any)[$$atom] = true;\n\n  return atom as unknown as Atom<T> | ReadonlyAtom<T>;\n}\n\n/**\n * Creates an inert atom config that can be instantiated later.\n *\n * Useful for framework hooks that need to create a stable local atom from\n * component input.\n */\nexport function createAtomConfig<T, TInput>(\n  getInitialValue: (input: TInput) => T,\n  options?: AtomOptions<T>\n): AtomConfig<T, TInput>;\nexport function createAtomConfig<T>(\n  initialValue: T,\n  options?: AtomOptions<T>\n): AtomConfig<T, undefined>;\nexport function createAtomConfig<T, TInput>(\n  initialValueOrFn: T | ((input: TInput) => T),\n  options?: AtomOptions<T>\n): AtomConfig<T, TInput | undefined> {\n  return {\n    createAtom(input?: TInput) {\n      const initialValue =\n        typeof initialValueOrFn === 'function'\n          ? (initialValueOrFn as (input: TInput) => T)(input as TInput)\n          : initialValueOrFn;\n\n      return createAtom(initialValue, options);\n    }\n  };\n}\n\n/** Creates an atom whose updates are handled by a reducer function. */\nexport function createReducerAtom<TState, TEvent>(\n  initialValue: TState,\n  reducer: (state: TState, event: TEvent) => TState,\n  options?: AtomOptions<TState>\n): ReducerAtom<TState, TEvent> {\n  const atom = createAtom(initialValue, options);\n\n  return {\n    [$$atom]: true,\n    get: atom.get.bind(atom),\n    subscribe: atom.subscribe.bind(atom),\n    send(event: TEvent) {\n      const prevSub = activeSub;\n      activeSub = undefined;\n      let nextState: TState;\n      try {\n        nextState = reducer(atom.get(), event);\n      } finally {\n        activeSub = prevSub;\n      }\n      atom.set(nextState);\n    }\n  } as unknown as ReducerAtom<TState, TEvent>;\n}\n\ninterface Effect extends ReactiveNode {\n  notify(): void;\n  stop(): void;\n}\n\nfunction effect<T>(fn: () => T): Effect {\n  const run = (): T => {\n    const prevSub = activeSub;\n    activeSub = effectObj;\n    ++cycle;\n    effectObj.depsTail = undefined;\n    effectObj.flags = ReactiveFlags.Watching | ReactiveFlags.RecursedCheck;\n    try {\n      return fn();\n    } finally {\n      activeSub = prevSub;\n      effectObj.flags &= ~ReactiveFlags.RecursedCheck;\n      purgeDeps(effectObj);\n    }\n  };\n  const effectObj: Effect = {\n    deps: undefined,\n    depsTail: undefined,\n    subs: undefined,\n    subsTail: undefined,\n    flags: ReactiveFlags.Watching | ReactiveFlags.RecursedCheck,\n\n    notify(): void {\n      const flags = this.flags;\n      if (\n        flags & ReactiveFlags.Dirty ||\n        (flags & ReactiveFlags.Pending && checkDirty(this.deps!, this))\n      ) {\n        run();\n      } else {\n        this.flags = ReactiveFlags.Watching;\n      }\n    },\n\n    stop(): void {\n      this.flags = ReactiveFlags.None;\n      this.depsTail = undefined;\n      purgeDeps(this);\n    }\n  };\n\n  run();\n\n  return effectObj;\n}\n","import { AnyActorSystem } from '../system.ts';\nimport {\n  ActorLogic,\n  ActorRefFromLogic,\n  AnyActorRef,\n  EventObject,\n  Snapshot\n} from '../types';\nimport { createAttachedLogic, relayMappedToParent } from './attached.ts';\nimport { isAtom } from '../atom.ts';\n\nexport type SubscriptionSnapshot = Snapshot<undefined> & {\n  input: SubscriptionInput<any, any, any, any>;\n};\n\nexport interface SubscriptionMappers<\n  TSnapshot extends Snapshot<unknown>,\n  TOutput,\n  TMappedEvent extends EventObject\n> {\n  snapshot?: (snapshot: TSnapshot) => TMappedEvent;\n  done?: (output: TOutput) => TMappedEvent;\n  error?: (error: unknown) => TMappedEvent;\n}\n\nexport interface SubscriptionInput<\n  TSnapshot extends Snapshot<unknown>,\n  TOutput,\n  TMappedEvent extends EventObject,\n  TMappers extends SubscriptionMappers<TSnapshot, TOutput, TMappedEvent>\n> {\n  actor: AnyActorRef;\n  mappers: TMappers;\n}\n\nexport type SubscriptionActorLogic<\n  TSnapshot extends Snapshot<unknown> = Snapshot<unknown>,\n  TOutput = unknown,\n  TMappedEvent extends EventObject = EventObject\n> = ActorLogic<\n  SubscriptionSnapshot,\n  EventObject,\n  SubscriptionInput<\n    TSnapshot,\n    TOutput,\n    TMappedEvent,\n    SubscriptionMappers<TSnapshot, TOutput, TMappedEvent>\n  >,\n  AnyActorSystem,\n  EventObject\n>;\n\nexport type SubscriptionActorRef<\n  TSnapshot extends Snapshot<unknown> = Snapshot<unknown>,\n  TOutput = unknown,\n  TMappedEvent extends EventObject = EventObject\n> = ActorRefFromLogic<SubscriptionActorLogic<TSnapshot, TOutput, TMappedEvent>>;\n\n/**\n * Creates actor logic for subscribing to lifecycle events (done/error/snapshot)\n * from another actor. Used internally by `enq.subscribeTo()`.\n */\nexport function createSubscriptionLogic<\n  TSnapshot extends Snapshot<unknown> = Snapshot<unknown>,\n  TOutput = unknown,\n  TMappedEvent extends EventObject = EventObject\n>(): SubscriptionActorLogic<TSnapshot, TOutput, TMappedEvent> {\n  return createAttachedLogic(({ actor, mappers }, { self, system }) => {\n    const { done, error, snapshot: onSnapshot } = mappers;\n\n    // Atoms emit a raw value (no `status`) and have no done/error lifecycle —\n    // pass the value straight to the `snapshot` mapper.\n    if (isAtom(actor)) {\n      if (!onSnapshot) {\n        return;\n      }\n      return actor.subscribe((value) =>\n        relayMappedToParent(self, system, () => onSnapshot(value as TSnapshot))\n      );\n    }\n\n    return actor.subscribe({\n      next: (snapshot: TSnapshot) => {\n        if (snapshot.status === 'done' && done) {\n          relayMappedToParent(self, system, () =>\n            done(snapshot.output as TOutput)\n          );\n        } else if (snapshot.status === 'error' && error) {\n          relayMappedToParent(self, system, () => error(snapshot.error));\n        } else if (snapshot.status === 'active' && onSnapshot) {\n          relayMappedToParent(self, system, () => onSnapshot(snapshot));\n        }\n      },\n      error: (err: unknown) => {\n        if (error) {\n          relayMappedToParent(self, system, () => error(err));\n        }\n      },\n      complete: () => {\n        // Actor completed without output (stopped); no action needed\n      }\n    });\n  });\n}\n\n// Singleton logic instance\nexport const subscriptionLogic = /* #__PURE__ */ createSubscriptionLogic();\n","export function parseDurationToMilliseconds(\n  duration: string\n): number | undefined {\n  const normalizedDuration = duration.trim();\n\n  const millisecondsMatch = normalizedDuration.match(/^(\\d+)ms$/i);\n  if (millisecondsMatch) {\n    return parseInt(millisecondsMatch[1], 10);\n  }\n\n  const secondsMatch = normalizedDuration.match(/^(\\d*)(\\.?)(\\d*)s$/i);\n  if (secondsMatch) {\n    const wholePart = secondsMatch[1] ? parseInt(secondsMatch[1], 10) : 0;\n    const hasDecimal = !!secondsMatch[2];\n    const fracPart = secondsMatch[3]\n      ? parseInt(secondsMatch[3].padEnd(3, '0').slice(0, 3), 10)\n      : 0;\n\n    return wholePart * 1000 + (hasDecimal ? fracPart : 0);\n  }\n\n  const iso8601DurationMatch = normalizedDuration.match(\n    /^P(?:(?<weeks>\\d+(?:[.,]\\d+)?)W)?(?:(?<days>\\d+(?:[.,]\\d+)?)D)?(?:T(?:(?<hours>\\d+(?:[.,]\\d+)?)H)?(?:(?<minutes>\\d+(?:[.,]\\d+)?)M)?(?:(?<seconds>\\d+(?:[.,]\\d+)?)S)?)?$/i\n  );\n\n  if (!iso8601DurationMatch?.groups) {\n    return undefined;\n  }\n\n  const { weeks, days, hours, minutes, seconds } = iso8601DurationMatch.groups;\n  if (!weeks && !days && !hours && !minutes && !seconds) {\n    return undefined;\n  }\n\n  const toNumber = (value: string | undefined) =>\n    value ? Number(value.replace(',', '.')) : 0;\n\n  return (\n    toNumber(weeks) * 7 * 24 * 60 * 60 * 1000 +\n    toNumber(days) * 24 * 60 * 60 * 1000 +\n    toNumber(hours) * 60 * 60 * 1000 +\n    toNumber(minutes) * 60 * 1000 +\n    toNumber(seconds) * 1000\n  );\n}\n\nexport function parseDelayToMilliseconds(\n  delay: string | number | undefined\n): number | undefined {\n  if (delay === undefined) {\n    return undefined;\n  }\n\n  if (typeof delay === 'number') {\n    return delay;\n  }\n\n  return parseDurationToMilliseconds(delay);\n}\n","import { InspectionEvent } from './inspection.ts';\nimport {\n  AnyEventObject,\n  ActorSystemInfo,\n  AnyActor,\n  Observer,\n  HomomorphicOmit,\n  EventObject,\n  Subscription,\n  TimersRestoreStrategy\n} from './types.ts';\nimport { toObserver } from './utils.ts';\n\ninterface ScheduledEvent {\n  id: string;\n  event: EventObject;\n  startedAt: number; // timestamp\n  delay: number;\n  source: AnyActor;\n  target: AnyActor;\n}\n\nexport interface Clock {\n  setTimeout(fn: (...args: any[]) => void, timeout: number): any;\n  clearTimeout(id: any): void;\n}\n\ninterface Scheduler {\n  schedule(\n    source: AnyActor,\n    target: AnyActor,\n    event: EventObject,\n    delay: number,\n    id: string | undefined\n  ): void;\n  cancel(source: AnyActor, id: string): void;\n  cancelAll(actor: AnyActor): void;\n}\n\ntype ScheduledEventId = string & { __scheduledEventId: never };\n\nfunction createScheduledEventId(actor: AnyActor, id: string): ScheduledEventId {\n  return `${actor.sessionId}.${id}` as ScheduledEventId;\n}\n\nexport interface ActorSystem<T extends ActorSystemInfo> {\n  /** @internal */\n  children: Map<string, AnyActor>;\n  /** @internal */\n  reverseKeyedActors: WeakMap<AnyActor, keyof T['actors']>;\n  /** @internal */\n  keyedActors: Map<keyof T['actors'], AnyActor | undefined>;\n  /** @internal */\n  _bookId: () => string;\n  /** @internal */\n  _register: (sessionId: string, actor: AnyActor) => string;\n  /** @internal */\n  _unregister: (actor: AnyActor) => void;\n  /** @internal */\n  _set: <K extends keyof T['actors']>(key: K, actor: AnyActor) => void;\n  get: <K extends keyof T['actors']>(key: K) => T['actors'][K] | undefined;\n  getAll: () => Partial<T['actors']>;\n\n  inspect: (\n    observer:\n      | Observer<InspectionEvent>\n      | ((inspectionEvent: InspectionEvent) => void)\n  ) => Subscription;\n  /** @internal */\n  _sendInspectionEvent: (\n    event: HomomorphicOmit<InspectionEvent, 'rootId'>\n  ) => void;\n  /** @internal */\n  _relay: (\n    source: AnyActor | undefined,\n    target: AnyActor,\n    event: AnyEventObject\n  ) => void;\n  scheduler: Scheduler;\n  getSnapshot: () => {\n    _scheduledEvents: Record<string, ScheduledEvent>;\n  };\n  /** @internal */\n  _snapshot: {\n    _scheduledEvents: Record<ScheduledEventId, ScheduledEvent>;\n  };\n  start: () => void;\n  _clock: Clock;\n  _logger: (...args: any[]) => void;\n  /**\n   * How rehydrated actors in this system restore persisted timers.\n   *\n   * @internal\n   */\n  _timerStrategy?: TimersRestoreStrategy;\n}\n\nexport type AnyActorSystem = ActorSystem<any>;\n\nexport function createSystem<T extends ActorSystemInfo>(\n  rootActor: AnyActor,\n  options: {\n    clock: Clock;\n    logger: (...args: any[]) => void;\n    snapshot?: unknown;\n    timers?: TimersRestoreStrategy;\n  }\n): ActorSystem<T> {\n  let idCounter = 0;\n  const children = new Map<string, AnyActor>();\n  const keyedActors = new Map<keyof T['actors'], AnyActor | undefined>();\n  const reverseKeyedActors = new WeakMap<AnyActor, keyof T['actors']>();\n  const inspectionObservers = new Set<Observer<InspectionEvent>>();\n  const timerMap: { [id: ScheduledEventId]: number } = {};\n  const { clock, logger } = options;\n\n  // Records a send on the *sender's* transition for the `sent[]` inspection\n  // facet. Captures the send when it is initiated (including delayed sends that\n  // may never deliver), keyed to the source actor's in-flight transition.\n  const recordSent = (\n    source: AnyActor | undefined,\n    target: AnyActor,\n    event: AnyEventObject,\n    delay?: number,\n    id?: string\n  ) => {\n    if (!inspectionObservers.size || !source) {\n      return;\n    }\n    const collected = ((source as any)._collectedSent ??= []);\n    collected.push({\n      targetRef: target,\n      targetId: target.id,\n      event,\n      delay,\n      id\n    });\n  };\n\n  const scheduler: Scheduler = {\n    schedule: (\n      source,\n      target,\n      event,\n      delay,\n      id = Math.random().toString(36).slice(2)\n    ) => {\n      recordSent(source, target, event, delay, id);\n      const scheduledEvent: ScheduledEvent = {\n        source,\n        target,\n        event,\n        delay,\n        id,\n        startedAt: Date.now()\n      };\n      const scheduledEventId = createScheduledEventId(source, id);\n      system._snapshot._scheduledEvents[scheduledEventId] = scheduledEvent;\n\n      const timeout = clock.setTimeout(() => {\n        delete timerMap[scheduledEventId];\n        delete system._snapshot._scheduledEvents[scheduledEventId];\n\n        // The send was already recorded at schedule time on the sender's\n        // transition, so deliver without re-recording.\n        deliver(source, target, event);\n      }, delay);\n\n      timerMap[scheduledEventId] = timeout;\n    },\n    cancel: (source, id: string) => {\n      const scheduledEventId = createScheduledEventId(source, id);\n      const timeout = timerMap[scheduledEventId];\n\n      delete timerMap[scheduledEventId];\n      delete system._snapshot._scheduledEvents[scheduledEventId];\n\n      if (timeout !== undefined) {\n        clock.clearTimeout(timeout);\n      }\n    },\n    cancelAll: (actor) => {\n      for (const scheduledEventId in system._snapshot._scheduledEvents) {\n        const scheduledEvent =\n          system._snapshot._scheduledEvents[\n            scheduledEventId as ScheduledEventId\n          ];\n        if (scheduledEvent.source === actor) {\n          scheduler.cancel(actor, scheduledEvent.id);\n        }\n      }\n    }\n  };\n  // Delivers an event to the target actor. Used by both `_relay` (which also\n  // records the send) and the scheduler's timer (which already recorded it).\n  const deliver = (\n    source: AnyActor | undefined,\n    target: AnyActor,\n    event: AnyEventObject\n  ) => {\n    const targetMachine = (target as any).logic;\n    const isInternalEvent =\n      typeof targetMachine?.isInternalEventType === 'function' &&\n      targetMachine.isInternalEventType(event.type);\n\n    if (isInternalEvent && source !== target) {\n      throw new Error(\n        `Internal event \"${event.type}\" cannot be sent to actor \"${target.id}\" from outside.`\n      );\n    }\n\n    // remember the last source for unified transition inspect event\n    (target as any)._lastSourceRef = source;\n    target._send(event);\n  };\n\n  const sendInspectionEvent = (event: InspectionEvent) => {\n    if (!inspectionObservers.size) {\n      return;\n    }\n    const resolvedInspectionEvent: InspectionEvent = {\n      ...event,\n      rootId: rootActor.sessionId!\n    };\n    inspectionObservers.forEach((observer) =>\n      observer.next?.(resolvedInspectionEvent)\n    );\n  };\n\n  const system: ActorSystem<T> = {\n    children,\n    reverseKeyedActors,\n    keyedActors,\n    _snapshot: {\n      _scheduledEvents:\n        (options?.snapshot && (options.snapshot as any).scheduler) ?? {}\n    },\n    _bookId: () => `x:${idCounter++}`,\n    _register: (sessionId, actor) => {\n      children.set(sessionId, actor);\n      return sessionId;\n    },\n    _unregister: (actor) => {\n      children.delete(actor.sessionId!);\n      const systemId = reverseKeyedActors.get(actor);\n\n      if (systemId !== undefined) {\n        keyedActors.delete(systemId);\n        reverseKeyedActors.delete(actor);\n      }\n    },\n    get: (systemId) => {\n      return keyedActors.get(systemId) as T['actors'][any] | undefined;\n    },\n    getAll: () => {\n      return Object.fromEntries(keyedActors.entries()) as Partial<T['actors']>;\n    },\n    _set: (systemId, actor) => {\n      const existing = keyedActors.get(systemId);\n      if (existing && existing !== actor) {\n        throw new Error(\n          `Actor with system ID '${systemId as string}' already exists.`\n        );\n      }\n\n      keyedActors.set(systemId, actor);\n      reverseKeyedActors.set(actor, systemId);\n    },\n    inspect: (observerOrFn) => {\n      const observer = toObserver(observerOrFn);\n      inspectionObservers.add(observer);\n\n      return {\n        unsubscribe() {\n          inspectionObservers.delete(observer);\n        }\n      };\n    },\n    _sendInspectionEvent: sendInspectionEvent as any,\n    _relay: (source, target, event) => {\n      recordSent(source, target, event);\n      deliver(source, target, event);\n    },\n    scheduler,\n    getSnapshot: () => {\n      return {\n        _scheduledEvents: { ...system._snapshot._scheduledEvents }\n      };\n    },\n    start: () => {\n      const scheduledEvents = system._snapshot._scheduledEvents;\n      system._snapshot._scheduledEvents = {};\n      for (const scheduledId in scheduledEvents) {\n        const { source, target, event, delay, id } =\n          scheduledEvents[scheduledId as ScheduledEventId];\n        scheduler.schedule(source, target, event, delay, id);\n      }\n    },\n    _clock: clock,\n    _logger: logger,\n    _timerStrategy: options.timers\n  };\n\n  return system;\n}\n","import { XSTATE_STOP } from '../constants.ts';\nimport { createInitEvent } from '../eventUtils.ts';\nimport { StandardSchemaV1 } from '../schema.types.ts';\nimport { AnyActorSystem } from '../system.ts';\nimport {\n  ActorLogic,\n  ActorRefFromLogic,\n  ActorScope,\n  AnyActorRef,\n  EventObject,\n  NonReducibleUnknown,\n  Snapshot\n} from '../types.ts';\n\nexport type LogicSnapshot<TContext, TOutput, TInput> = Snapshot<TOutput> & {\n  context: TContext;\n  input: TInput | undefined;\n  effects?: Record<string, LogicEffectState>;\n};\n\nexport type LogicEffectState =\n  | { status: 'active' }\n  | { status: 'done'; output?: unknown }\n  | { status: 'error'; error: unknown };\n\nexport interface LogicArgs<TContext, TEvent extends EventObject, TInput> {\n  context: TContext;\n  event: TEvent;\n  input: TInput;\n  system: AnyActorSystem;\n  self: LogicActorRef<TContext, unknown, TEvent, TInput>;\n}\n\nexport type LogicEffect<\n  TEvent extends EventObject,\n  TEmitted extends EventObject\n> =\n  | { type: 'emit'; event: TEmitted }\n  | { type: 'sendBack'; event: EventObject }\n  | { type: 'raise'; event: TEvent }\n  | { type: 'effect'; key?: string; exec: () => void | (() => void) }\n  | { type: 'cleanupEffects' };\n\nexport interface LogicEnqueue<\n  TEvent extends EventObject,\n  TEmitted extends EventObject\n> {\n  emit: (emitted: TEmitted) => void;\n  sendBack: (event: EventObject) => void;\n  raise: (event: TEvent) => void;\n  effect: {\n    (exec: () => void | (() => void)): void;\n    (key: string, exec: () => void | (() => void)): void;\n  };\n}\n\nexport type LogicPatch<TContext, TOutput, TInput> = Partial<{\n  context: TContext;\n  input: TInput | undefined;\n  status: LogicSnapshot<TContext, TOutput, TInput>['status'];\n  output: TOutput;\n  error: unknown;\n  effects: Record<string, LogicEffectState>;\n}>;\n\nexport type LogicFunction<\n  TContext,\n  TOutput,\n  TEvent extends EventObject,\n  TInput,\n  TEmitted extends EventObject\n> = (\n  args: LogicArgs<TContext, TEvent, TInput>,\n  enq: LogicEnqueue<TEvent, TEmitted>\n) => void | LogicPatch<TContext, TOutput, TInput>;\n\nexport interface LogicConfig<\n  TContext,\n  TOutput,\n  TEvent extends EventObject,\n  TInput,\n  TEmitted extends EventObject,\n  TInputSchema extends StandardSchemaV1 = StandardSchemaV1,\n  TOutputSchema extends StandardSchemaV1 = StandardSchemaV1\n> {\n  id?: string;\n  schemas?: {\n    input?: TInputSchema;\n    output?: TOutputSchema;\n  };\n  context: TContext | ((args: { input: TInput }) => TContext);\n  run: LogicFunction<TContext, TOutput, TEvent, TInput, TEmitted>;\n}\n\ninterface LogicTransition<\n  TContext,\n  TOutput,\n  TEvent extends EventObject,\n  TInput,\n  TEmitted extends EventObject\n> {\n  (\n    snapshot: LogicSnapshot<TContext, TOutput, TInput>,\n    event: TEvent,\n    actorScope: ActorScope<\n      LogicSnapshot<TContext, TOutput, TInput>,\n      TEvent,\n      AnyActorSystem,\n      TEmitted\n    >\n  ): [\n    LogicSnapshot<TContext, TOutput, TInput>,\n    LogicEffect<TEvent, TEmitted>[]\n  ];\n  (\n    snapshot: LogicSnapshot<TContext, TOutput, TInput>,\n    event: TEvent,\n    actorScope: ActorScope<\n      LogicSnapshot<TContext, TOutput, TInput>,\n      TEvent,\n      AnyActorSystem,\n      TEmitted\n    >\n  ): LogicSnapshot<TContext, TOutput, TInput>;\n}\n\nexport type LogicActorLogic<\n  TContext,\n  TOutput,\n  TEvent extends EventObject = EventObject,\n  TInput = NonReducibleUnknown,\n  TEmitted extends EventObject = EventObject\n> = Omit<\n  ActorLogic<\n    LogicSnapshot<TContext, TOutput, TInput>,\n    TEvent,\n    TInput,\n    AnyActorSystem,\n    TEmitted\n  >,\n  'transition'\n> & {\n  id?: string;\n  transition: LogicTransition<TContext, TOutput, TEvent, TInput, TEmitted>;\n};\n\nexport type LogicActorRef<\n  TContext,\n  TOutput,\n  TEvent extends EventObject,\n  TInput\n> = ActorRefFromLogic<LogicActorLogic<TContext, TOutput, TEvent, TInput>>;\n\nconst effectStates = new WeakMap<\n  AnyActorRef,\n  Map<PropertyKey, { cleanup?: () => void }>\n>();\n\nexport const XSTATE_LOGIC_EFFECT_RESOLVE = 'xstate.logic.effect.resolve';\nexport const XSTATE_LOGIC_EFFECT_REJECT = 'xstate.logic.effect.reject';\nexport const XSTATE_LOGIC_EFFECT_START = 'xstate.logic.effect.start';\n\nfunction getEffectState(self: AnyActorRef) {\n  let state = effectStates.get(self);\n  if (!state) {\n    state = new Map();\n    effectStates.set(self, state);\n  }\n  return state;\n}\n\nexport function executeLogicEffects(\n  effects: readonly unknown[] | undefined,\n  actorScope: ActorScope<any, any, any, any>\n) {\n  if (!effects?.length) {\n    return;\n  }\n\n  for (const effect of effects as LogicEffect<EventObject, EventObject>[]) {\n    switch (effect.type) {\n      case 'emit':\n        actorScope.emit(effect.event);\n        break;\n      case 'sendBack': {\n        const parent = (actorScope.self as any)._parent;\n        if (parent) {\n          actorScope.system._relay(actorScope.self, parent, effect.event);\n        }\n        break;\n      }\n      case 'raise':\n        actorScope.system._relay(\n          actorScope.self,\n          actorScope.self,\n          effect.event\n        );\n        break;\n      case 'effect': {\n        if (!effect.key) {\n          const cleanup = effect.exec();\n          if (typeof cleanup === 'function') {\n            getEffectState(actorScope.self).set(Symbol(), { cleanup });\n          }\n          break;\n        }\n\n        const state = getEffectState(actorScope.self);\n        if (state.has(effect.key)) {\n          break;\n        }\n        const cleanup = effect.exec();\n        state.set(effect.key, {\n          cleanup: typeof cleanup === 'function' ? cleanup : undefined\n        });\n        break;\n      }\n      case 'cleanupEffects': {\n        const state = effectStates.get(actorScope.self);\n        if (!state) {\n          break;\n        }\n        for (const { cleanup } of state.values()) {\n          cleanup?.();\n        }\n        effectStates.delete(actorScope.self);\n        break;\n      }\n    }\n  }\n}\n\nfunction resolveContext<TContext, TInput>(\n  context: TContext | ((args: { input: TInput }) => TContext),\n  input: TInput\n) {\n  return typeof context === 'function'\n    ? (context as (args: { input: TInput }) => TContext)({ input })\n    : context;\n}\n\nexport function createLogic<\n  TContext,\n  const TInputSchema extends StandardSchemaV1,\n  const TOutputSchema extends StandardSchemaV1,\n  TEvent extends EventObject = EventObject,\n  TEmitted extends EventObject = EventObject\n>(\n  config: LogicConfig<\n    TContext,\n    StandardSchemaV1.InferOutput<TOutputSchema>,\n    TEvent,\n    StandardSchemaV1.InferOutput<TInputSchema>,\n    TEmitted,\n    TInputSchema,\n    TOutputSchema\n  > & {\n    schemas: {\n      input: TInputSchema;\n      output: TOutputSchema;\n    };\n  }\n): LogicActorLogic<\n  TContext,\n  StandardSchemaV1.InferOutput<TOutputSchema>,\n  TEvent,\n  StandardSchemaV1.InferOutput<TInputSchema>,\n  TEmitted\n>;\nexport function createLogic<\n  TContext,\n  TOutput,\n  const TInputSchema extends StandardSchemaV1,\n  TEvent extends EventObject = EventObject,\n  TEmitted extends EventObject = EventObject\n>(\n  config: LogicConfig<\n    TContext,\n    TOutput,\n    TEvent,\n    StandardSchemaV1.InferOutput<TInputSchema>,\n    TEmitted,\n    TInputSchema\n  > & {\n    schemas: {\n      input: TInputSchema;\n      output?: undefined;\n    };\n  }\n): LogicActorLogic<\n  TContext,\n  TOutput,\n  TEvent,\n  StandardSchemaV1.InferOutput<TInputSchema>,\n  TEmitted\n>;\nexport function createLogic<\n  TContext,\n  const TOutputSchema extends StandardSchemaV1,\n  TEvent extends EventObject = EventObject,\n  TInput = NonReducibleUnknown,\n  TEmitted extends EventObject = EventObject\n>(\n  config: LogicConfig<\n    TContext,\n    StandardSchemaV1.InferOutput<TOutputSchema>,\n    TEvent,\n    TInput,\n    TEmitted,\n    StandardSchemaV1,\n    TOutputSchema\n  > & {\n    schemas: {\n      input?: undefined;\n      output: TOutputSchema;\n    };\n  }\n): LogicActorLogic<\n  TContext,\n  StandardSchemaV1.InferOutput<TOutputSchema>,\n  TEvent,\n  TInput,\n  TEmitted\n>;\nexport function createLogic<\n  TContext,\n  TOutput = unknown,\n  TEvent extends EventObject = EventObject,\n  TInput = NonReducibleUnknown,\n  TEmitted extends EventObject = EventObject\n>(\n  config: LogicConfig<TContext, TOutput, TEvent, TInput, TEmitted>\n): LogicActorLogic<TContext, TOutput, TEvent, TInput, TEmitted>;\nexport function createLogic<\n  TContext,\n  TOutput = unknown,\n  TEvent extends EventObject = EventObject,\n  TInput = NonReducibleUnknown,\n  TEmitted extends EventObject = EventObject\n>(\n  config: LogicConfig<TContext, TOutput, TEvent, TInput, TEmitted>\n): LogicActorLogic<TContext, TOutput, TEvent, TInput, TEmitted> {\n  const transition = ((snapshot, event, actorScope) => {\n    if (snapshot.status !== 'active') {\n      return [snapshot, []];\n    }\n\n    if (event.type === XSTATE_STOP) {\n      return [\n        {\n          ...snapshot,\n          status: 'stopped',\n          input: undefined\n        },\n        [{ type: 'cleanupEffects' }]\n      ];\n    }\n\n    if (event.type === XSTATE_LOGIC_EFFECT_START) {\n      return [\n        {\n          ...snapshot,\n          effects: {\n            ...snapshot.effects,\n            [(event as any).key]: { status: 'active' }\n          }\n        },\n        []\n      ];\n    }\n\n    if (event.type === XSTATE_LOGIC_EFFECT_RESOLVE) {\n      return [\n        {\n          ...snapshot,\n          effects: {\n            ...snapshot.effects,\n            [(event as any).key]: {\n              status: 'done',\n              output: (event as any).output\n            }\n          }\n        },\n        []\n      ];\n    }\n\n    if (event.type === XSTATE_LOGIC_EFFECT_REJECT) {\n      return [\n        {\n          ...snapshot,\n          effects: {\n            ...snapshot.effects,\n            [(event as any).key]: {\n              status: 'error',\n              error: (event as any).error\n            }\n          }\n        },\n        []\n      ];\n    }\n\n    const effects: LogicEffect<TEvent, TEmitted>[] = [];\n    const trackedEffects: Record<string, LogicEffectState> = {};\n    const enqueueEffect = (key: string, exec: () => void | (() => void)) => {\n      if (snapshot.effects?.[key]) {\n        return;\n      }\n      effects.push({ type: 'effect', key, exec });\n      trackedEffects[key] = { status: 'active' };\n    };\n    const enq: LogicEnqueue<TEvent, TEmitted> = {\n      emit: (emitted) => {\n        effects.push({ type: 'emit', event: emitted });\n      },\n      sendBack: (sentEvent) => {\n        effects.push({ type: 'sendBack', event: sentEvent });\n      },\n      raise: (raisedEvent) => {\n        effects.push({ type: 'raise', event: raisedEvent });\n      },\n      effect: ((keyOrExec, maybeExec) => {\n        if (typeof keyOrExec === 'string') {\n          enqueueEffect(keyOrExec, maybeExec);\n          return;\n        }\n        effects.push({ type: 'effect', exec: keyOrExec });\n      }) as LogicEnqueue<TEvent, TEmitted>['effect']\n    };\n\n    const patch = config.run(\n      {\n        context: snapshot.context,\n        event,\n        input: snapshot.input!,\n        system: actorScope.system,\n        self: actorScope.self as any,\n        emit: actorScope.emit\n      } as LogicArgs<TContext, TEvent, TInput>,\n      enq\n    );\n\n    const nextSnapshot = {\n      ...snapshot,\n      ...(patch || {})\n    };\n\n    if ('context' in snapshot || patch?.context !== undefined) {\n      (nextSnapshot as any).context = patch?.context ?? snapshot.context;\n    }\n    if (patch?.effects || Object.keys(trackedEffects).length) {\n      (nextSnapshot as any).effects = {\n        ...snapshot.effects,\n        ...patch?.effects,\n        ...trackedEffects\n      };\n    }\n\n    return [nextSnapshot, effects];\n  }) as LogicTransition<TContext, TOutput, TEvent, TInput, TEmitted>;\n\n  const logic: LogicActorLogic<TContext, TOutput, TEvent, TInput, TEmitted> = {\n    id: config.id,\n    config,\n    transition,\n    start: (snapshot, actorScope) => {\n      const [nextSnapshot, effects] = transition(\n        snapshot,\n        createInitEvent(snapshot.input) as unknown as TEvent,\n        actorScope\n      );\n      Object.assign(snapshot, nextSnapshot);\n      executeLogicEffects(effects, actorScope);\n    },\n    getInitialSnapshot: (_, input) => {\n      const context = resolveContext(config.context, input);\n      const snapshot = {\n        status: 'active' as const,\n        output: undefined,\n        error: undefined,\n        input\n      };\n\n      if (context !== undefined) {\n        (snapshot as any).context = context;\n      }\n\n      return {\n        ...snapshot\n      } as LogicSnapshot<TContext, TOutput, TInput>;\n    },\n    getPersistedSnapshot: (snapshot) => snapshot,\n    restoreSnapshot: (snapshot: any) => snapshot\n  };\n\n  return logic;\n}\n","import isDevelopment from '#is-development';\nimport type { ActionRecord, SentRecord } from './inspection.ts';\nimport { onActorRead } from './interop.ts';\nimport { Mailbox } from './Mailbox.ts';\nimport { XSTATE_STOP } from './constants.ts';\nimport {\n  createDoneActorEvent,\n  createErrorActorEvent,\n  createInitEvent\n} from './eventUtils.ts';\nimport { reportUnhandledError } from './reportUnhandledError.ts';\nimport { symbolObservable } from './symbolObservable.ts';\nimport { AnyActorSystem, Clock, createSystem } from './system.ts';\nimport { executeLogicEffects } from './actors/logic.ts';\n\n// those are needed to make JSDoc `@link` work properly\nimport type {\n  createObservableLogic,\n  createEventObservableLogic\n} from './actors/observable.ts';\nimport type { createCallbackLogic } from './actors/callback.ts';\nimport type { createLogic } from './actors/logic.ts';\nimport type { createAsyncLogic } from './actors/promise.ts';\nimport type { createMachine } from './createMachine.ts';\n\nlet executingCustomAction: boolean = false;\n\nimport type {\n  ActorScope,\n  AnyActor,\n  AnyActorLogic,\n  EmittedFrom,\n  EventFromLogic,\n  SendableEventFromLogic,\n  InputFrom,\n  Snapshot,\n  SnapshotFrom,\n  AnyTransitionDefinition,\n  Readable\n} from './types.ts';\nimport {\n  ActorOptions,\n  ActorInstance,\n  ActorRef,\n  EventObject,\n  InteropSubscribable,\n  Observer,\n  PendingEffect,\n  Subscription,\n  TimersRestoreStrategy\n} from './types.ts';\nimport { toObserver } from './utils.ts';\n\nexport const $$ACTOR_TYPE = 1;\n\n// those values are currently used by @xstate/react directly so it's important to keep the assigned values in sync\nexport enum ProcessingStatus {\n  NotStarted = 0,\n  Running = 1,\n  Stopped = 2\n}\n\nconst defaultOptions = {\n  clock: {\n    setTimeout: (fn, ms) => {\n      return setTimeout(fn, ms);\n    },\n    clearTimeout: (id) => {\n      return clearTimeout(id);\n    }\n  } as Clock,\n  logger: console.log.bind(console)\n};\n\n/**\n * An Actor is a running process that can receive events, send events and change\n * its behavior based on the events it receives, which can cause effects outside\n * of the actor. When you run a state machine, it becomes an actor.\n *\n * An `Actor` is the concrete runtime instance with lifecycle methods and\n * system-owned internals. It also satisfies the narrower `ActorRef` contract,\n * so consumer APIs should accept `ActorRef` when they only need to send events\n * or read snapshots.\n */\nexport class Actor<TLogic extends AnyActorLogic>\n  implements\n    ActorInstance<\n      SnapshotFrom<TLogic>,\n      EventFromLogic<TLogic>,\n      EmittedFrom<TLogic>,\n      SendableEventFromLogic<TLogic>\n    >\n{\n  /** The current internal state of the actor. */\n  private _snapshot!: SnapshotFrom<TLogic>;\n  /**\n   * The clock that is responsible for setting and clearing timeouts, such as\n   * delayed events and transitions.\n   */\n  public clock: Clock;\n  public options: Readonly<ActorOptions<TLogic>>;\n\n  /** The unique identifier for this actor relative to its parent. */\n  public id: string;\n\n  private readonly _boundProcess = this._process.bind(this);\n\n  private mailbox: Mailbox<EventFromLogic<TLogic>> = new Mailbox(\n    this._boundProcess\n  );\n\n  private observers: Set<Observer<SnapshotFrom<TLogic>>> = new Set();\n  private eventListeners: Map<\n    string,\n    Set<(emittedEvent: EmittedFrom<TLogic>) => void>\n  > = new Map();\n  private logger: (...args: any[]) => void;\n\n  /** @internal */\n  public _processingStatus: ProcessingStatus = ProcessingStatus.NotStarted;\n\n  // Actor Ref\n  public _parent?: AnyActor;\n  /** @internal */\n  public _syncSnapshot?: boolean;\n  public ref: ActorRef<\n    SnapshotFrom<TLogic>,\n    EventFromLogic<TLogic>,\n    EmittedFrom<TLogic>,\n    SendableEventFromLogic<TLogic>\n  >;\n  // TODO: add typings for system\n  private _actorScope: ActorScope<\n    SnapshotFrom<TLogic>,\n    EventFromLogic<TLogic>,\n    AnyActorSystem,\n    EmittedFrom<TLogic>,\n    SendableEventFromLogic<TLogic>\n  >;\n\n  /** @internal */\n  public _lastSourceRef?: AnyActor;\n  /** @internal */\n  public _collectedMicrosteps: AnyTransitionDefinition[] = [] as any;\n  /** @internal Actions executed during the in-flight transition. */\n  public _collectedActions: ActionRecord[] = [];\n  /** @internal Events relayed to other actors during the in-flight transition. */\n  public _collectedSent: SentRecord[] = [];\n  public systemId: string | undefined;\n\n  /** The globally unique process ID for this invocation. */\n  public sessionId: string;\n\n  /** The system to which this actor belongs. */\n  public system: AnyActorSystem;\n\n  public trigger: {\n    [K in SendableEventFromLogic<TLogic>['type']]: {} extends Omit<\n      Extract<SendableEventFromLogic<TLogic>, { type: K }>,\n      'type'\n    >\n      ? () => void\n      : (\n          payload: Omit<\n            Extract<SendableEventFromLogic<TLogic>, { type: K }>,\n            'type'\n          >\n        ) => void;\n  };\n\n  public src: string | AnyActorLogic;\n\n  /**\n   * Creates a new actor instance for the given logic with the provided options,\n   * if any.\n   *\n   * @param logic The logic to create an actor from\n   * @param options Actor options\n   */\n  constructor(\n    public logic: TLogic,\n    options?: ActorOptions<TLogic>\n  ) {\n    const resolvedOptions = {\n      ...defaultOptions,\n      ...options\n    };\n\n    const { clock, logger, parent, syncSnapshot, id, systemId, inspect } =\n      resolvedOptions;\n\n    this.system = parent\n      ? parent.system\n      : createSystem(this, {\n          clock,\n          logger,\n          timers: resolvedOptions.timers\n        });\n\n    if (inspect && !parent) {\n      // Always inspect at the system-level\n      this.system.inspect(toObserver(inspect));\n    }\n\n    this.sessionId = this.system._bookId();\n    this.id = id ?? this.sessionId;\n    this.logger = options?.logger ?? this.system._logger;\n    this.clock = options?.clock ?? this.system._clock;\n    this._parent = parent;\n    this._syncSnapshot = syncSnapshot;\n    this.options = resolvedOptions as ActorOptions<TLogic> &\n      typeof defaultOptions;\n    this.src = resolvedOptions.src ?? logic;\n    this.ref = this;\n    this._actorScope = {\n      self: this,\n      id: this.id,\n      sessionId: this.sessionId,\n      logger: this.logger,\n      defer: (fn) => {\n        this._deferred.push(fn);\n      },\n      system: this.system,\n      stopChild: (child) => {\n        if (child._parent !== this) {\n          throw new Error(\n            `Cannot stop child actor ${child.id} of ${this.id} because it is not a child`\n          );\n        }\n        (child as Actor<AnyActorLogic>)._stop();\n      },\n      emit: (emittedEvent) => {\n        const listeners = this.eventListeners.get(emittedEvent.type);\n        const wildcardListener = this.eventListeners.get('*');\n        if (!listeners && !wildcardListener) {\n          return;\n        }\n        if (listeners) {\n          for (const handler of listeners) {\n            try {\n              handler(emittedEvent);\n            } catch (err) {\n              reportUnhandledError(err);\n            }\n          }\n        }\n        if (!wildcardListener) {\n          return;\n        }\n        for (const handler of wildcardListener) {\n          try {\n            handler(emittedEvent);\n          } catch (err) {\n            reportUnhandledError(err);\n          }\n        }\n      },\n      actionExecutor: (action) => {\n        const exec = () => {\n          // Record every executed action for the '@xstate.transition' inspection\n          // event's `actions[]` facet (replaces the v5 '@xstate.action' event).\n          this._collectedActions.push({\n            type: action.type,\n            params: action.params\n          });\n          if (!action.exec) {\n            return;\n          }\n          const saveExecutingCustomAction = executingCustomAction;\n          try {\n            executingCustomAction = true;\n\n            action.exec();\n          } finally {\n            executingCustomAction = saveExecutingCustomAction;\n          }\n        };\n        if (this._processingStatus === ProcessingStatus.Running) {\n          exec();\n        } else {\n          this._deferred.push(exec);\n        }\n      }\n    };\n\n    // Ensure that the send method is bound to this Actor instance\n    // if destructured\n    this.send = this.send.bind(this);\n    this.trigger = new Proxy({} as Actor<TLogic>['trigger'], {\n      get: (_, eventType: string) => {\n        return (payload?: any) => {\n          this.send({ ...payload, type: eventType });\n        };\n      }\n    });\n\n    // unified '@xstate.transition' event replaces '@xstate.actor'\n\n    if (systemId) {\n      this.systemId = systemId;\n      this.system._set(systemId, this);\n    }\n\n    // prepare to collect initial microsteps during getInitialSnapshot\n    this._collectedMicrosteps = [] as any;\n    let persistedState = options?.snapshot ?? options?.state;\n    if (\n      persistedState &&\n      typeof persistedState === 'object' &&\n      '_pendingEffects' in persistedState\n    ) {\n      // Pending effects are restored by this actor on `start()`; the logic\n      // only sees the rest of the persisted snapshot.\n      const { _pendingEffects, ...rest } = persistedState as any;\n      this._pendingEffects = _pendingEffects;\n      persistedState = rest;\n    }\n    try {\n      this._snapshot = persistedState\n        ? this.logic.restoreSnapshot\n          ? this.logic.restoreSnapshot(persistedState, this._actorScope)\n          : persistedState\n        : this.logic.getInitialSnapshot(this._actorScope, this.options?.input);\n    } catch (err) {\n      // if we get here then it means that we assign a value to this._snapshot that is not of the correct type\n      // we can't get the true `TSnapshot & { status: 'error'; }`, it's impossible\n      // so right now this is a lie of sorts\n      this._snapshot = {\n        status: 'error',\n        output: undefined,\n        error: err\n      } as any;\n      // discard any functions deferred during the failed initial snapshot\n      // computation so they can't run against an inconsistent actor\n      this._deferred.length = 0;\n    }\n\n    if (systemId && (this._snapshot as any).status !== 'active') {\n      this.system._unregister(this);\n    }\n\n    // Announce actor topology: emitted once for every actor (root and every\n    // spawned/invoked child) so the actor graph can be drawn before any\n    // transitions occur. This is the only place actor identity is announced.\n    this.system._sendInspectionEvent({\n      type: '@xstate.actor',\n      actorRef: this as any,\n      parentRef: this._parent,\n      id: this.id,\n      src: this.src,\n      snapshot: this._snapshot\n    });\n  }\n\n  // array of functions to defer\n  private _deferred: Array<() => void> = [];\n\n  // pending effects (timers) from a persisted snapshot, rescheduled on `start()`\n  private _pendingEffects?: PendingEffect[];\n\n  private _setErrorSnapshot(\n    err: unknown,\n    snapshot: SnapshotFrom<TLogic> = this._snapshot\n  ) {\n    this._snapshot = {\n      ...(snapshot as any),\n      status: 'error',\n      error: err\n    };\n  }\n\n  private _next(snapshot: SnapshotFrom<TLogic>) {\n    for (const observer of this.observers) {\n      try {\n        observer.next?.(snapshot);\n      } catch (err) {\n        reportUnhandledError(err);\n      }\n    }\n  }\n\n  private update(snapshot: SnapshotFrom<TLogic>, event: EventObject): void {\n    // Update state\n    this._snapshot = snapshot;\n\n    // Execute deferred effects\n    for (let i = 0; i < this._deferred.length; i++) {\n      const deferredFn = this._deferred[i];\n      try {\n        deferredFn();\n      } catch (err) {\n        // this error can only be caught when executing *initial* actions\n        // it's the only time when we call actions provided by the user through those deferreds\n        // when the actor is already running we always execute them synchronously while transitioning\n        // no \"builtin deferred\" should actually throw an error since they are either safe\n        // or the control flow is passed through the mailbox and errors should be caught by the `_process` used by the mailbox\n        this._deferred.length = 0;\n        this._setErrorSnapshot(err, snapshot);\n        break;\n      }\n    }\n    this._deferred.length = 0;\n\n    switch ((this._snapshot as any).status) {\n      case 'active':\n        this._next(snapshot);\n        break;\n      case 'done': {\n        // next observers are meant to be notified about done snapshots\n        // this can be seen as something that is different from how observable work\n        // but with observables `complete` callback is called without any arguments\n        // it's more ergonomic for XState to treat a done snapshot as a \"next\" value\n        // and the completion event as something that is separate,\n        // something that merely follows emitting that done snapshot\n        this._next(snapshot);\n\n        this._stopProcedure();\n        this._complete();\n        const doneEvent = createDoneActorEvent(\n          this.id,\n          (this._snapshot as any).output\n        );\n        if (this._parent) {\n          this.system._relay(this, this._parent, doneEvent);\n        }\n\n        break;\n      }\n      case 'error':\n        this._error((this._snapshot as any).error);\n        break;\n    }\n    this.system._sendInspectionEvent({\n      type: '@xstate.transition',\n      actorRef: this as any,\n      event,\n      sourceRef: this._lastSourceRef,\n      targetRef: this as any,\n      snapshot,\n      microsteps: this._collectedMicrosteps as any,\n      actions: this._collectedActions,\n      sent: this._collectedSent,\n      eventType: event.type\n    });\n    // reset facets after emission\n    this._collectedMicrosteps = [] as any;\n    this._collectedActions = [];\n    this._collectedSent = [];\n  }\n\n  /**\n   * Subscribe an observer to an actor’s snapshot values.\n   *\n   * @remarks\n   * The observer will receive the actor’s snapshot value when it is emitted.\n   * The observer can be:\n   *\n   * - A plain function that receives the latest snapshot, or\n   * - An observer object whose `.next(snapshot)` method receives the latest\n   *   snapshot\n   *\n   * @example\n   *\n   * ```ts\n   * // Observer as a plain function\n   * const subscription = actor.subscribe((snapshot) => {\n   *   console.log(snapshot);\n   * });\n   * ```\n   *\n   * @example\n   *\n   * ```ts\n   * // Observer as an object\n   * const subscription = actor.subscribe({\n   *   next(snapshot) {\n   *     console.log(snapshot);\n   *   },\n   *   error(err) {\n   *     // ...\n   *   },\n   *   complete() {\n   *     // ...\n   *   }\n   * });\n   * ```\n   *\n   * The return value of `actor.subscribe(observer)` is a subscription object\n   * that has an `.unsubscribe()` method. You can call\n   * `subscription.unsubscribe()` to unsubscribe the observer:\n   *\n   * @example\n   *\n   * ```ts\n   * const subscription = actor.subscribe((snapshot) => {\n   *   // ...\n   * });\n   *\n   * // Unsubscribe the observer\n   * subscription.unsubscribe();\n   * ```\n   *\n   * When the actor is stopped, all of its observers will automatically be\n   * unsubscribed.\n   *\n   * @param observer - Either a plain function that receives the latest\n   *   snapshot, or an observer object whose `.next(snapshot)` method receives\n   *   the latest snapshot\n   */\n  public subscribe(observer: Observer<SnapshotFrom<TLogic>>): Subscription;\n  public subscribe(\n    nextListener?: (snapshot: SnapshotFrom<TLogic>) => void,\n    errorListener?: (error: any) => void,\n    completeListener?: () => void\n  ): Subscription;\n  public subscribe(\n    nextListenerOrObserver?:\n      | ((snapshot: SnapshotFrom<TLogic>) => void)\n      | Observer<SnapshotFrom<TLogic>>,\n    errorListener?: (error: any) => void,\n    completeListener?: () => void\n  ): Subscription {\n    const observer = toObserver(\n      nextListenerOrObserver,\n      errorListener,\n      completeListener\n    );\n\n    if (this._processingStatus !== ProcessingStatus.Stopped) {\n      this.observers.add(observer);\n    } else {\n      switch ((this._snapshot as any).status) {\n        case 'done':\n          try {\n            observer.complete?.();\n          } catch (err) {\n            reportUnhandledError(err);\n          }\n          break;\n        case 'error': {\n          const err = (this._snapshot as any).error;\n          if (!observer.error) {\n            reportUnhandledError(err);\n          } else {\n            try {\n              observer.error(err);\n            } catch (err) {\n              reportUnhandledError(err);\n            }\n          }\n          break;\n        }\n      }\n    }\n\n    return {\n      unsubscribe: () => {\n        this.observers.delete(observer);\n      }\n    };\n  }\n\n  public on<TType extends EmittedFrom<TLogic>['type'] | '*'>(\n    type: TType,\n    handler: (\n      emitted: EmittedFrom<TLogic> &\n        (TType extends '*' ? unknown : { type: TType })\n    ) => void\n  ): Subscription {\n    let listeners = this.eventListeners.get(type);\n    if (!listeners) {\n      listeners = new Set();\n      this.eventListeners.set(type, listeners);\n    }\n    listeners.add(handler);\n\n    return {\n      unsubscribe: () => {\n        listeners.delete(handler);\n      }\n    };\n  }\n\n  public select<TSelected>(\n    selector: (snapshot: SnapshotFrom<TLogic>) => TSelected,\n    equalityFn: (a: TSelected, b: TSelected) => boolean = Object.is\n  ): Readable<TSelected> {\n    return {\n      subscribe: (\n        observerOrFn:\n          | Observer<TSelected>\n          | ((value: TSelected) => void)\n          | undefined,\n        errorListener?: (error: any) => void,\n        completeListener?: () => void\n      ) => {\n        const observer = toObserver(\n          observerOrFn,\n          errorListener,\n          completeListener\n        );\n        let selected = selector(this.getSnapshot());\n        return this.subscribe({\n          next: (snapshot) => {\n            const next = selector(snapshot);\n            if (!equalityFn(selected, next)) {\n              selected = next;\n              observer.next?.(next);\n            }\n          },\n          error: observer.error,\n          complete: observer.complete\n        });\n      },\n      get: () => selector(this.get())\n    };\n  }\n\n  /** Starts the Actor from the initial state */\n  public start(): this {\n    if (this._processingStatus === ProcessingStatus.Running) {\n      // Do not restart the service if it is already started\n      return this;\n    }\n\n    if (this._syncSnapshot) {\n      this.subscribe({\n        next: (snapshot: Snapshot<unknown>) => {\n          if (snapshot.status === 'active') {\n            this.system._relay(this, this._parent!, {\n              type: `xstate.snapshot.${this.id}`,\n              snapshot\n            });\n          }\n        },\n        error: () => {}\n      });\n    }\n\n    this.system._register(this.sessionId, this);\n    if (this.systemId) {\n      this.system._set(this.systemId, this);\n    }\n    this._processingStatus = ProcessingStatus.Running;\n\n    // TODO: this isn't correct when rehydrating\n    const initEvent = createInitEvent(this.options.input);\n    // remember source of init as parent for unified transition event\n    this._lastSourceRef = this._parent;\n\n    const status = (this._snapshot as any).status;\n\n    switch (status) {\n      case 'done':\n        // a state machine can be \"done\" upon initialization (it could reach a final state using initial microsteps)\n        // we still need to complete observers, flush deferreds etc\n        this.update(\n          this._snapshot,\n          initEvent as unknown as EventFromLogic<TLogic>\n        );\n        // TODO: rethink cleanup of observers, mailbox, etc\n        return this;\n      case 'error':\n        this._error((this._snapshot as any).error);\n        return this;\n    }\n\n    if (!this._parent) {\n      this.system.start();\n    }\n\n    if (this.logic.start) {\n      try {\n        this.logic.start(this._snapshot, this._actorScope);\n      } catch (err) {\n        this._setErrorSnapshot(err);\n        this._error(err);\n        return this;\n      }\n    }\n\n    // TODO: this notifies all subscribers but usually this is redundant\n    // there is no real change happening here\n    // we need to rethink if this needs to be refactored\n    this.update(this._snapshot, initEvent as unknown as EventFromLogic<TLogic>);\n\n    if (this._pendingEffects) {\n      const strategy =\n        this.options.timers ?? this.system._timerStrategy ?? 'resume';\n      for (const effect of this._pendingEffects) {\n        // Re-execute the pending effect with its remaining delay. Only\n        // self-targeted raises exist today; other effect types are ignored.\n        if (effect.type === '@xstate.raise') {\n          this.system.scheduler.schedule(\n            this,\n            this,\n            effect.event,\n            resolveRestoredTimerDelay(strategy, effect),\n            effect.id\n          );\n        }\n      }\n      this._pendingEffects = undefined;\n    }\n\n    this.mailbox.start();\n\n    return this;\n  }\n\n  private _process(event: EventFromLogic<TLogic>) {\n    let nextState: any;\n    let caughtError;\n    try {\n      nextState = this.logic.transition(\n        this._snapshot,\n        event,\n        this._actorScope\n      );\n    } catch (err) {\n      // we wrap it in a box so we can rethrow it later even if falsy value gets caught here\n      caughtError = { err };\n    }\n\n    if (caughtError) {\n      const { err } = caughtError;\n\n      this._setErrorSnapshot(err);\n      this._error(err);\n      return;\n    }\n\n    const [snapshot, effects] = Array.isArray(nextState)\n      ? nextState\n      : [nextState, undefined];\n\n    this.update(snapshot, event);\n    executeLogicEffects(effects, this._actorScope);\n    if (event.type === XSTATE_STOP) {\n      this._stopProcedure();\n      this._complete();\n    }\n  }\n\n  /** @internal */\n  public _stop(): this {\n    if (this._processingStatus === ProcessingStatus.Stopped) {\n      return this;\n    }\n    this.mailbox.clear();\n    if (this._processingStatus === ProcessingStatus.NotStarted) {\n      this._processingStatus = ProcessingStatus.Stopped;\n      return this;\n    }\n    this.mailbox.enqueue({ type: XSTATE_STOP } as any);\n    this.system._unregister(this);\n\n    return this;\n  }\n\n  /** Stops the Actor and unsubscribe all listeners. */\n  public stop(): this {\n    if (this._parent) {\n      throw new Error('A non-root actor cannot be stopped directly.');\n    }\n    return this._stop();\n  }\n  private _complete(): void {\n    for (const observer of this.observers) {\n      try {\n        observer.complete?.();\n      } catch (err) {\n        reportUnhandledError(err);\n      }\n    }\n    this.observers.clear();\n    this.eventListeners.clear();\n  }\n\n  private _error(err: unknown): void {\n    this._stopProcedure();\n    if (!this.observers.size) {\n      if (!this._parent) {\n        reportUnhandledError(err);\n      }\n      this.eventListeners.clear();\n    } else {\n      let reportError = false;\n\n      for (const observer of this.observers) {\n        const errorListener = observer.error;\n        reportError ||= !errorListener;\n        try {\n          errorListener?.(err);\n        } catch (err2) {\n          reportUnhandledError(err2);\n        }\n      }\n      this.observers.clear();\n      this.eventListeners.clear();\n      if (reportError) {\n        reportUnhandledError(err);\n      }\n    }\n\n    if (this._parent) {\n      this.system._relay(\n        this,\n        this._parent,\n        createErrorActorEvent(this.id, err)\n      );\n    }\n  }\n  // TODO: atm children don't belong entirely to the actor so\n  // in a way - it's not even super aware of them\n  // so we can't stop them from here but we really should!\n  // right now, they are being stopped within the machine's transition\n  // but that could throw and leave us with \"orphaned\" active actors\n  private _stopProcedure(): void {\n    if (this._processingStatus !== ProcessingStatus.Running) {\n      // Actor already stopped; do nothing\n      return;\n    }\n\n    // Cancel all delayed events\n    this.system.scheduler.cancelAll(this);\n\n    // TODO: mailbox.reset\n    this.mailbox.clear();\n    // TODO: after `stop` we must prepare ourselves for receiving events again\n    // events sent *after* stop signal must be queued\n    // it seems like this should be the common behavior for all of our consumers\n    // so perhaps this should be unified somehow for all of them\n    this.mailbox = new Mailbox(this._boundProcess);\n\n    this._processingStatus = ProcessingStatus.Stopped;\n    this.system._unregister(this);\n  }\n\n  /** @internal */\n  public _send(event: EventFromLogic<TLogic>) {\n    if (this._processingStatus === ProcessingStatus.Stopped) {\n      // do nothing\n      if (isDevelopment) {\n        // TODO: circular serialization issues\n        // const eventString = ''; //JSON.stringify(event);\n\n        console.warn(\n          `Event \"${event.type}\" was sent to stopped actor \"${this.id} (${this.sessionId})\". This actor has already reached its final state, and will not transition.`\n        );\n      }\n      return;\n    }\n\n    this.mailbox.enqueue(event);\n  }\n\n  /**\n   * Sends an event to the running Actor to trigger a transition.\n   *\n   * @param event The event to send\n   */\n  public send(event: SendableEventFromLogic<TLogic>) {\n    if (isDevelopment && typeof event === 'string') {\n      throw new Error(\n        `Only event objects may be sent to actors; use .send({ type: \"${event}\" }) instead`\n      );\n    }\n    this.system._relay(undefined, this, event);\n  }\n\n  public toJSON() {\n    return {\n      xstate$$type: $$ACTOR_TYPE,\n      id: this.id\n    };\n  }\n\n  /**\n   * Obtain the internal state of the actor, which can be persisted.\n   *\n   * @remarks\n   * The internal state can be persisted from any actor, not only machines.\n   *\n   * Note that the persisted state is not the same as the snapshot from\n   * {@link Actor.getSnapshot}. Persisted state represents the internal state of\n   * the actor, while snapshots represent the actor's last emitted value.\n   *\n   * Can be restored with {@link ActorOptions.state}\n   * @see https://stately.ai/docs/persistence\n   */\n  public getPersistedSnapshot(): Snapshot<unknown>;\n  public getPersistedSnapshot(options?: unknown): Snapshot<unknown> {\n    const persisted = this.logic.getPersistedSnapshot(this._snapshot, options);\n\n    // Capture this actor's pending self-targeted effects (delayed\n    // events/transitions) as serialized action descriptors plus their\n    // runtime progress, so they can be restored on `start()`.\n    const scheduledEvents = this.system._snapshot._scheduledEvents;\n    let pendingEffects: PendingEffect[] | undefined;\n    const now = Date.now();\n    for (const key in scheduledEvents) {\n      const scheduled = scheduledEvents[key as keyof typeof scheduledEvents];\n      if (scheduled.source === this && scheduled.target === this) {\n        (pendingEffects ??= []).push({\n          type: '@xstate.raise',\n          event: scheduled.event,\n          id: scheduled.id,\n          delay: scheduled.delay,\n          startedAt: scheduled.startedAt,\n          elapsed: Math.max(0, now - scheduled.startedAt)\n        });\n      }\n    }\n\n    // If this actor was restored but not yet started, its pending effects\n    // are not in the scheduler yet — carry them through as-is.\n    pendingEffects ??= this._pendingEffects;\n\n    return pendingEffects\n      ? ({\n          ...(persisted as any),\n          _pendingEffects: pendingEffects\n        } as Snapshot<unknown>)\n      : persisted;\n  }\n\n  public [symbolObservable](): InteropSubscribable<SnapshotFrom<TLogic>> {\n    return this;\n  }\n\n  /**\n   * Read an actor’s snapshot synchronously.\n   *\n   * @remarks\n   * The snapshot represent an actor's last emitted value.\n   *\n   * When an actor receives an event, its internal state may change. An actor\n   * may emit a snapshot when a state transition occurs.\n   *\n   * Note that some actors, such as callback actors generated with\n   * `createCallbackLogic`, will not emit snapshots.\n   * @see {@link Actor.subscribe} to subscribe to an actor’s snapshot values.\n   * @see {@link Actor.getPersistedSnapshot} to persist the internal state of an actor (which is more than just a snapshot).\n   */\n  public getSnapshot(): SnapshotFrom<TLogic> {\n    return this.get();\n  }\n\n  /** Read the actor's current snapshot as an atom value. */\n  public get(): SnapshotFrom<TLogic> {\n    if (isDevelopment && !this._snapshot) {\n      throw new Error(\n        `Snapshot can't be read while the actor initializes itself`\n      );\n    }\n    onActorRead?.(this);\n    return this._snapshot;\n  }\n}\n\nfunction resolveRestoredTimerDelay(\n  strategy: TimersRestoreStrategy,\n  effect: PendingEffect\n): number {\n  if (typeof strategy === 'function') {\n    return strategy(effect);\n  }\n  switch (strategy) {\n    case 'restart':\n      return effect.delay;\n    case 'absolute':\n      return Math.max(0, effect.startedAt + effect.delay - Date.now());\n    case 'resume':\n    default:\n      return Math.max(0, effect.delay - effect.elapsed);\n  }\n}\n\nexport type RequiredActorOptionsKeys<TLogic extends AnyActorLogic> =\n  undefined extends InputFrom<TLogic> ? never : 'input';\n\n/**\n * Creates a new actor instance for the given actor logic with the provided\n * options, if any.\n *\n * @remarks\n * When you create an actor from actor logic via `createActor(logic)`, you\n * implicitly create an actor system where the created actor is the root actor.\n * Any actors spawned from this root actor and its descendants are part of that\n * actor system.\n * @example\n *\n * ```ts\n * import { createActor } from 'xstate';\n * import { someActorLogic } from './someActorLogic.ts';\n *\n * // Creating the actor, which implicitly creates an actor system with itself as the root actor\n * const actor = createActor(someActorLogic);\n *\n * actor.subscribe((snapshot) => {\n *   console.log(snapshot);\n * });\n *\n * // Actors must be started by calling `actor.start()`, which will also start the actor system.\n * actor.start();\n *\n * // Actors can receive events\n * actor.send({ type: 'someEvent' });\n *\n * // You can stop root actors by calling `actor.stop()`, which will also stop the actor system and all actors in that system.\n * actor.stop();\n * ```\n *\n * @param logic - The actor logic to create an actor from. For a state machine\n *   actor logic creator, see {@link createMachine}. Other actor logic creators\n *   include {@link createCallbackLogic}, {@link createEventObservableLogic},\n *   {@link createObservableLogic}, {@link createLogic}, and\n *   {@link createAsyncLogic}.\n * @param options - Actor options\n */\nexport function createActor<TLogic extends AnyActorLogic>(\n  logic: TLogic,\n  options?: ActorOptions<TLogic> & {\n    [K in RequiredActorOptionsKeys<TLogic>]: unknown;\n  }\n): Actor<TLogic> {\n  return new Actor(logic, options);\n}\n","import { AnyActorSystem } from '../system.ts';\nimport {\n  ActorLogic,\n  ActorRefFromLogic,\n  AnyActorRef,\n  AnyEventObject,\n  EventObject,\n  NonReducibleUnknown,\n  Snapshot\n} from '../types';\nimport { StandardSchemaV1 } from '../schema.types.ts';\nimport { createLogic as createBaseLogic } from './logic.ts';\n\ninterface CallbackInstanceState<TEvent extends EventObject> {\n  receivers: Set<(e: TEvent) => void> | undefined;\n  dispose: (() => void) | void;\n}\n\nconst instanceStates = /* #__PURE__ */ new WeakMap<\n  AnyActorRef,\n  CallbackInstanceState<any>\n>();\n\nexport type CallbackSnapshot<TInput> = Snapshot<undefined> & {\n  input: TInput;\n  effects?: Record<\n    string,\n    | { status: 'active' }\n    | { status: 'done'; output?: unknown }\n    | { status: 'error'; error: unknown }\n  >;\n};\n\nexport type CallbackActorLogic<\n  TEvent extends EventObject,\n  TInput = NonReducibleUnknown,\n  TEmitted extends EventObject = EventObject\n> = ActorLogic<\n  CallbackSnapshot<TInput>,\n  TEvent,\n  TInput,\n  AnyActorSystem,\n  TEmitted\n>;\n\n/**\n * Represents an actor created by `createCallbackLogic`.\n *\n * The type of `self` within the actor's logic.\n *\n * @example\n *\n * ```ts\n * import { createCallbackLogic, createActor } from 'xstate';\n *\n * // The events the actor receives.\n * type Event = { type: 'someEvent' };\n * // The actor's input.\n * type Input = { name: string };\n *\n * // Actor logic that logs whenever it receives an event of type `someEvent`.\n * const logic = createCallbackLogic<Event, Input>(\n *   ({ self, input, receive }) => {\n *     self;\n *     // ^? CallbackActorRef<Event, Input>\n *\n *     receive((event) => {\n *       if (event.type === 'someEvent') {\n *         console.log(`${input.name}: received \"someEvent\" event`);\n *         // logs 'myActor: received \"someEvent\" event'\n *       }\n *     });\n *   }\n * );\n *\n * const actor = createActor(logic, { input: { name: 'myActor' } });\n * //    ^? CallbackActorRef<Event, Input>\n * ```\n *\n * @see {@link createCallbackLogic}\n */\nexport type CallbackActorRef<\n  TEvent extends EventObject,\n  TInput = NonReducibleUnknown\n> = ActorRefFromLogic<CallbackActorLogic<TEvent, TInput>>;\n\ntype Receiver<TEvent extends EventObject> = (\n  listener: {\n    bivarianceHack(event: TEvent): void;\n  }['bivarianceHack']\n) => void;\n\nexport type CallbackLogicFunction<\n  TEvent extends EventObject = AnyEventObject,\n  TSentEvent extends EventObject = AnyEventObject,\n  TInput = NonReducibleUnknown,\n  TEmitted extends EventObject = EventObject\n> = ({\n  input,\n  system,\n  self,\n  sendBack,\n  receive,\n  emit\n}: {\n  /**\n   * Data that was provided to the callback actor\n   *\n   * @see {@link https://stately.ai/docs/input | Input docs}\n   */\n  input: TInput;\n  /** The actor system to which the callback actor belongs */\n  system: AnyActorSystem;\n  /** The parent actor of the callback actor */\n  self: CallbackActorRef<TEvent>;\n  /** A function that can send events back to the parent actor */\n  sendBack: (event: TSentEvent) => void;\n  /**\n   * A function that can be called with a listener function argument; the\n   * listener is then called whenever events are received by the callback actor\n   */\n  receive: Receiver<TEvent>;\n  emit: (emitted: TEmitted) => void;\n}) => (() => void) | void;\n\nexport interface CallbackLogicConfig<\n  TEvent extends EventObject = AnyEventObject,\n  TSentEvent extends EventObject = AnyEventObject,\n  TInput = NonReducibleUnknown,\n  TEmitted extends EventObject = EventObject,\n  TInputSchema extends StandardSchemaV1 = StandardSchemaV1\n> {\n  schemas?: {\n    input?: TInputSchema;\n  };\n  run: CallbackLogicFunction<TEvent, TSentEvent, TInput, TEmitted>;\n}\n\n/**\n * An actor logic creator which returns callback logic as defined by a callback\n * function.\n *\n * @remarks\n * Useful for subscription-based or other free-form logic that can send events\n * back to the parent actor.\n *\n * Actors created from callback logic (“callback actors”) can:\n *\n * - Receive events via the `receive` function\n * - Send events to the parent actor via the `sendBack` function\n *\n * Callback actors are a bit different from other actors in that they:\n *\n * - Do not work with `onDone`\n * - Do not produce a snapshot using `.getSnapshot()`\n * - Do not emit values when used with `.subscribe()`\n * - Can not be stopped with `.stop()`\n *\n * @example\n *\n * ```typescript\n * const callbackLogic = createCallbackLogic(({ sendBack, receive }) => {\n *   let lockStatus = 'unlocked';\n *\n *   const handler = (event) => {\n *     if (lockStatus === 'locked') {\n *       return;\n *     }\n *     sendBack(event);\n *   };\n *\n *   receive((event) => {\n *     if (event.type === 'lock') {\n *       lockStatus = 'locked';\n *     } else if (event.type === 'unlock') {\n *       lockStatus = 'unlocked';\n *     }\n *   });\n *\n *   document.body.addEventListener('click', handler);\n *\n *   return () => {\n *     document.body.removeEventListener('click', handler);\n *   };\n * });\n * ```\n *\n * @param callback - The callback function used to describe the callback logic\n *   The callback function is passed an object with the following properties:\n *\n *   - `receive` - A function that can send events back to the parent actor; the\n *       listener is then called whenever events are received by the callback\n *       actor\n *   - `sendBack` - A function that can send events back to the parent actor\n *   - `input` - Data that was provided to the callback actor\n *   - `self` - The parent actor of the callback actor\n *   - `system` - The actor system to which the callback actor belongs The callback\n *       function can (optionally) return a cleanup function, which is called\n *       when the actor is stopped.\n *\n * @returns Callback logic\n * @see {@link CallbackLogicFunction} for more information about the callback function and its object argument\n * @see {@link https://stately.ai/docs/input | Input docs} for more information about how input is passed\n */\nexport function createCallbackLogic<\n  TEvent extends EventObject,\n  const TInputSchema extends StandardSchemaV1,\n  TEmitted extends EventObject = EventObject\n>(\n  config: CallbackLogicConfig<\n    TEvent,\n    AnyEventObject,\n    StandardSchemaV1.InferOutput<TInputSchema>,\n    TEmitted,\n    TInputSchema\n  > & {\n    schemas: {\n      input: TInputSchema;\n    };\n  }\n): CallbackActorLogic<\n  TEvent,\n  StandardSchemaV1.InferOutput<TInputSchema>,\n  TEmitted\n>;\nexport function createCallbackLogic<\n  TEvent extends EventObject,\n  TInput = NonReducibleUnknown,\n  TEmitted extends EventObject = EventObject\n>(\n  config: CallbackLogicConfig<TEvent, AnyEventObject, TInput, TEmitted> & {\n    schemas?: undefined;\n  }\n): CallbackActorLogic<TEvent, TInput, TEmitted>;\nexport function createCallbackLogic<\n  TEvent extends EventObject,\n  TInput = NonReducibleUnknown,\n  TEmitted extends EventObject = EventObject\n>(\n  callback: CallbackLogicFunction<TEvent, AnyEventObject, TInput, TEmitted>\n): CallbackActorLogic<TEvent, TInput, TEmitted>;\nexport function createCallbackLogic<\n  TEvent extends EventObject,\n  TInput = NonReducibleUnknown,\n  TEmitted extends EventObject = EventObject\n>(\n  callbackOrConfig:\n    | CallbackLogicFunction<TEvent, AnyEventObject, TInput, TEmitted>\n    | CallbackLogicConfig<TEvent, AnyEventObject, TInput, TEmitted>\n): CallbackActorLogic<TEvent, TInput, TEmitted> {\n  const callback =\n    typeof callbackOrConfig === 'function'\n      ? callbackOrConfig\n      : callbackOrConfig.run;\n  const schemas =\n    typeof callbackOrConfig === 'function'\n      ? undefined\n      : callbackOrConfig.schemas;\n\n  return createBaseLogic<undefined, undefined, TEvent, TInput, TEmitted>({\n    schemas,\n    context: undefined,\n    run: (args, enq) => {\n      const { event, input, self, system } = args;\n      const emit = (args as any).emit as (emitted: TEmitted) => void;\n      const callbackState = instanceStates.get(self as any);\n      callbackState?.receivers?.forEach((receiver) => receiver(event));\n\n      enq.effect('callback', () => {\n        const callbackState: CallbackInstanceState<TEvent> = {\n          receivers: undefined,\n          dispose: undefined\n        };\n\n        instanceStates.set(self as any, callbackState);\n\n        callbackState.dispose = callback({\n          input,\n          system,\n          self: self as any,\n          sendBack: (event) => {\n            if (self.getSnapshot().status === 'stopped') {\n              return;\n            }\n            const parent = (self as any)._parent;\n            if (parent) {\n              system._relay(self as any, parent, event);\n            }\n          },\n          receive: (listener) => {\n            callbackState.receivers ??= new Set();\n            callbackState.receivers.add(listener);\n          },\n          emit: emit as (emitted: TEmitted) => void\n        });\n\n        return () => {\n          instanceStates.delete(self as any);\n          callbackState.receivers?.clear();\n          callbackState.dispose?.();\n        };\n      });\n    }\n  }) as unknown as CallbackActorLogic<TEvent, TInput, TEmitted>;\n}\n","import { XSTATE_STOP } from '../constants';\nimport { StandardSchemaV1 } from '../schema.types.ts';\nimport { AnyActorSystem } from '../system.ts';\nimport {\n  ActorLogic,\n  ActorFromLogic,\n  ActorRefFromLogic,\n  AnyActor,\n  EventObject,\n  NonReducibleUnknown,\n  Snapshot,\n  Subscribable,\n  Subscription\n} from '../types';\nimport { createLogic as createBaseLogic } from './logic.ts';\n\nconst XSTATE_OBSERVABLE_NEXT = 'xstate.observable.next';\nconst XSTATE_OBSERVABLE_ERROR = 'xstate.observable.error';\nconst XSTATE_OBSERVABLE_COMPLETE = 'xstate.observable.complete';\n\nexport type ObservableSnapshot<\n  TContext,\n  TInput extends NonReducibleUnknown\n> = Snapshot<undefined> & {\n  context: TContext | undefined;\n  input: TInput | undefined;\n  effects?: Record<\n    string,\n    | { status: 'active' }\n    | { status: 'done'; output?: unknown }\n    | { status: 'error'; error: unknown }\n  >;\n  _subscription: Subscription | undefined;\n};\n\nexport type ObservableActorLogic<\n  TContext,\n  TInput extends NonReducibleUnknown,\n  TEmitted extends EventObject = EventObject\n> = ActorLogic<\n  ObservableSnapshot<TContext, TInput>,\n  { type: string; [k: string]: unknown },\n  TInput,\n  AnyActorSystem,\n  TEmitted\n>;\n\n/**\n * Represents an actor created by `createObservableLogic` or\n * `createEventObservableLogic`.\n *\n * The type of `self` within the actor's logic.\n *\n * @example\n *\n * ```ts\n * import { createObservableLogic, createActor } from 'xstate';\n * import { interval } from 'rxjs';\n *\n * // The type of the value observed by the actor's logic.\n * type Context = number;\n * // The actor's input.\n * type Input = { period?: number };\n *\n * // Actor logic that observes a number incremented every `input.period`\n * // milliseconds (default: 1_000).\n * const logic = createObservableLogic<Context, Input>(\n *   ({ input, self }) => {\n *     self;\n *     // ^? ObservableActor<Event, Input>\n *\n *     return interval(input.period ?? 1_000);\n *   }\n * );\n *\n * const actor = createActor(logic, { input: { period: 2_000 } });\n * //    ^? ObservableActor<Event, Input>\n * ```\n *\n * @see {@link createObservableLogic}\n * @see {@link createEventObservableLogic}\n */\nexport type ObservableActorRef<TContext> = ActorRefFromLogic<\n  ObservableActorLogic<TContext, any>\n>;\n\ntype ObservableActor<\n  TContext,\n  TInput extends NonReducibleUnknown = any,\n  TEmitted extends EventObject = EventObject\n> = ActorFromLogic<ObservableActorLogic<TContext, TInput, TEmitted>>;\n\nexport type ObservableLogicFunction<\n  TContext,\n  TInput extends NonReducibleUnknown,\n  TEmitted extends EventObject = EventObject\n> = ({\n  input,\n  system,\n  self,\n  emit\n}: {\n  input: TInput;\n  system: AnyActorSystem;\n  self: ObservableActor<TContext, TInput, TEmitted>;\n  emit: (emitted: TEmitted) => void;\n}) => Subscribable<TContext>;\n\nexport interface ObservableLogicConfig<\n  TContext,\n  TInput extends NonReducibleUnknown,\n  TEmitted extends EventObject = EventObject,\n  TInputSchema extends StandardSchemaV1 = StandardSchemaV1\n> {\n  schemas?: {\n    input?: TInputSchema;\n  };\n  run: ObservableLogicFunction<TContext, TInput, TEmitted>;\n}\n\nexport type EventObservableLogicFunction<\n  TEvent extends EventObject,\n  TInput extends NonReducibleUnknown,\n  TEmitted extends EventObject = EventObject\n> = ({\n  input,\n  system,\n  self,\n  emit\n}: {\n  input: TInput;\n  system: AnyActorSystem;\n  self: ObservableActor<TEvent, TInput, TEmitted>;\n  emit: (emitted: TEmitted) => void;\n}) => Subscribable<TEvent>;\n\nexport interface EventObservableLogicConfig<\n  TEvent extends EventObject,\n  TInput extends NonReducibleUnknown,\n  TEmitted extends EventObject = EventObject,\n  TInputSchema extends StandardSchemaV1 = StandardSchemaV1\n> {\n  schemas?: {\n    input?: TInputSchema;\n  };\n  run: EventObservableLogicFunction<TEvent, TInput, TEmitted>;\n}\n\n/**\n * Observable actor logic is described by an observable stream of values. Actors\n * created from observable logic (“observable actors”) can:\n *\n * - Emit snapshots of the observable’s emitted value\n *\n * The observable’s emitted value is used as its observable actor’s `context`.\n *\n * Sending events to observable actors will have no effect.\n *\n * @example\n *\n * ```ts\n * import { createObservableLogic, createActor } from 'xstate';\n * import { interval } from 'rxjs';\n *\n * const logic = createObservableLogic((obj) => interval(1000));\n *\n * const actor = createActor(logic);\n *\n * actor.subscribe((snapshot) => {\n *   console.log(snapshot.context);\n * });\n *\n * actor.start();\n * // At every second:\n * // Logs 0\n * // Logs 1\n * // Logs 2\n * // ...\n * ```\n *\n * @param observableCreator A function that creates an observable. It receives\n *   one argument, an object with the following properties:\n *\n *   - `input` - Data that was provided to the observable actor\n *   - `self` - The parent actor\n *   - `system` - The actor system to which the observable actor belongs\n *\n *   It should return a {@link Subscribable}, which is compatible with an RxJS\n *   Observable, although RxJS is not required to create them.\n * @see {@link https://rxjs.dev} for documentation on RxJS Observable and observable creators.\n * @see {@link Subscribable} interface in XState, which is based on and compatible with RxJS Observable.\n */\nexport function createObservableLogic<\n  TContext,\n  const TInputSchema extends StandardSchemaV1,\n  TEmitted extends EventObject = EventObject\n>(\n  config: ObservableLogicConfig<\n    TContext,\n    StandardSchemaV1.InferOutput<TInputSchema>,\n    TEmitted,\n    TInputSchema\n  > & {\n    schemas: {\n      input: TInputSchema;\n    };\n  }\n): ObservableActorLogic<\n  TContext,\n  StandardSchemaV1.InferOutput<TInputSchema>,\n  TEmitted\n>;\nexport function createObservableLogic<\n  TContext,\n  TInput extends NonReducibleUnknown,\n  TEmitted extends EventObject = EventObject\n>(\n  config: ObservableLogicConfig<TContext, TInput, TEmitted> & {\n    schemas?: undefined;\n  }\n): ObservableActorLogic<TContext, TInput, TEmitted>;\nexport function createObservableLogic<\n  TContext,\n  TInput extends NonReducibleUnknown,\n  TEmitted extends EventObject = EventObject\n>(\n  observableCreator: ObservableLogicFunction<TContext, TInput, TEmitted>\n): ObservableActorLogic<TContext, TInput, TEmitted>;\nexport function createObservableLogic<\n  TContext,\n  TInput extends NonReducibleUnknown,\n  TEmitted extends EventObject = EventObject\n>(\n  observableCreatorOrConfig:\n    | ObservableLogicFunction<TContext, TInput, TEmitted>\n    | ObservableLogicConfig<TContext, TInput, TEmitted>\n): ObservableActorLogic<TContext, TInput, TEmitted> {\n  const observableCreator =\n    typeof observableCreatorOrConfig === 'function'\n      ? observableCreatorOrConfig\n      : observableCreatorOrConfig.run;\n  const schemas =\n    typeof observableCreatorOrConfig === 'function'\n      ? undefined\n      : observableCreatorOrConfig.schemas;\n\n  return createBaseLogic<\n    TContext | undefined,\n    undefined,\n    { type: string; [k: string]: unknown },\n    TInput,\n    TEmitted\n  >({\n    schemas,\n    context: undefined,\n    run: (args, enq) => {\n      const { event, input, self, system } = args;\n      const emit = (args as any).emit as (emitted: TEmitted) => void;\n      switch (event.type) {\n        case XSTATE_OBSERVABLE_NEXT: {\n          return {\n            context: event.data as TContext\n          };\n        }\n        case XSTATE_OBSERVABLE_ERROR:\n          return {\n            status: 'error',\n            error: (event as any).data,\n            input: undefined as TInput | undefined,\n            effects: {\n              observable: { status: 'error', error: (event as any).data }\n            }\n          };\n        case XSTATE_OBSERVABLE_COMPLETE:\n          return {\n            status: 'done',\n            input: undefined as TInput | undefined,\n            effects: {\n              observable: { status: 'done' }\n            }\n          };\n      }\n\n      enq.effect('observable', () => {\n        const actorSelf = self as unknown as AnyActor;\n        const subscription = observableCreator({\n          input,\n          system,\n          self: self as any,\n          emit: emit as (emitted: TEmitted) => void\n        }).subscribe({\n          next: (value) => {\n            system._relay(actorSelf, actorSelf, {\n              type: XSTATE_OBSERVABLE_NEXT,\n              data: value\n            });\n          },\n          error: (err) => {\n            system._relay(actorSelf, actorSelf, {\n              type: XSTATE_OBSERVABLE_ERROR,\n              data: err\n            });\n          },\n          complete: () => {\n            system._relay(actorSelf, actorSelf, {\n              type: XSTATE_OBSERVABLE_COMPLETE\n            });\n          }\n        });\n\n        return () => subscription.unsubscribe();\n      });\n    }\n  }) as unknown as ObservableActorLogic<TContext, TInput, TEmitted>;\n}\n\n/**\n * Creates event observable logic that listens to an observable that delivers\n * event objects.\n *\n * Event observable actor logic is described by an observable stream of\n * {@link https://stately.ai/docs/transitions#event-objects | event objects}.\n * Actors created from event observable logic (“event observable actors”) can:\n *\n * - Implicitly send events to its parent actor\n * - Emit snapshots of its emitted event objects\n *\n * Sending events to event observable actors will have no effect.\n *\n * @example\n *\n * ```ts\n * import {\n *   createEventObservableLogic,\n *   Subscribable,\n *   EventObject,\n *   createMachine,\n *   createActor\n * } from 'xstate';\n * import { fromEvent } from 'rxjs';\n *\n * const mouseClickLogic = createEventObservableLogic(\n *   () => fromEvent(document.body, 'click') as Subscribable<EventObject>\n * );\n *\n * const canvasMachine = createMachine({\n *   invoke: {\n *     // Will send mouse `click` events to the canvas actor\n *     src: mouseClickLogic\n *   }\n * });\n *\n * const canvasActor = createActor(canvasMachine);\n * canvasActor.start();\n * ```\n *\n * @param lazyObservable A function that creates an observable that delivers\n *   event objects. It receives one argument, an object with the following\n *   properties:\n *\n *   - `input` - Data that was provided to the event observable actor\n *   - `self` - The parent actor\n *   - `system` - The actor system to which the event observable actor belongs.\n *\n *   It should return a {@link Subscribable}, which is compatible with an RxJS\n *   Observable, although RxJS is not required to create them.\n */\nexport function createEventObservableLogic<\n  TEvent extends EventObject,\n  const TInputSchema extends StandardSchemaV1,\n  TEmitted extends EventObject = EventObject\n>(\n  config: EventObservableLogicConfig<\n    TEvent,\n    StandardSchemaV1.InferOutput<TInputSchema>,\n    TEmitted,\n    TInputSchema\n  > & {\n    schemas: {\n      input: TInputSchema;\n    };\n  }\n): ObservableActorLogic<\n  TEvent,\n  StandardSchemaV1.InferOutput<TInputSchema>,\n  TEmitted\n>;\nexport function createEventObservableLogic<\n  TEvent extends EventObject,\n  TInput extends NonReducibleUnknown,\n  TEmitted extends EventObject = EventObject\n>(\n  config: EventObservableLogicConfig<TEvent, TInput, TEmitted> & {\n    schemas?: undefined;\n  }\n): ObservableActorLogic<TEvent, TInput, TEmitted>;\nexport function createEventObservableLogic<\n  TEvent extends EventObject,\n  TInput extends NonReducibleUnknown,\n  TEmitted extends EventObject = EventObject\n>(\n  lazyObservable: EventObservableLogicFunction<TEvent, TInput, TEmitted>\n): ObservableActorLogic<TEvent, TInput, TEmitted>;\nexport function createEventObservableLogic<\n  TEvent extends EventObject,\n  TInput extends NonReducibleUnknown,\n  TEmitted extends EventObject = EventObject\n>(\n  lazyObservableOrConfig:\n    | EventObservableLogicFunction<TEvent, TInput, TEmitted>\n    | EventObservableLogicConfig<TEvent, TInput, TEmitted>\n): ObservableActorLogic<TEvent, TInput, TEmitted> {\n  const lazyObservable =\n    typeof lazyObservableOrConfig === 'function'\n      ? lazyObservableOrConfig\n      : lazyObservableOrConfig.run;\n\n  // TODO: event types\n  const logic: ObservableActorLogic<TEvent, TInput, TEmitted> = {\n    config: lazyObservable,\n    transition: (state, event) => {\n      if (state.status !== 'active') {\n        return state;\n      }\n\n      switch (event.type) {\n        case XSTATE_OBSERVABLE_ERROR:\n          return {\n            ...state,\n            status: 'error',\n            error: (event as any).data,\n            input: undefined,\n            _subscription: undefined\n          };\n        case XSTATE_OBSERVABLE_COMPLETE:\n          return {\n            ...state,\n            status: 'done',\n            input: undefined,\n            _subscription: undefined\n          };\n        case XSTATE_STOP:\n          state._subscription!.unsubscribe();\n          return {\n            ...state,\n            status: 'stopped',\n            input: undefined,\n            _subscription: undefined\n          };\n        default:\n          return state;\n      }\n    },\n    getInitialSnapshot: (_, input) => {\n      return {\n        status: 'active',\n        output: undefined,\n        error: undefined,\n        context: undefined,\n        input,\n        _subscription: undefined\n      };\n    },\n    start: (state, { self, system, emit }) => {\n      if (state.status === 'done') {\n        // Do not restart a completed observable\n        return;\n      }\n\n      state._subscription = lazyObservable({\n        input: state.input!,\n        system,\n        self,\n        emit\n      }).subscribe({\n        next: (value) => {\n          if (self._parent) {\n            system._relay(self, self._parent, value);\n          }\n        },\n        error: (err) => {\n          system._relay(self, self, {\n            type: XSTATE_OBSERVABLE_ERROR,\n            data: err\n          });\n        },\n        complete: () => {\n          system._relay(self, self, { type: XSTATE_OBSERVABLE_COMPLETE });\n        }\n      });\n    },\n    getPersistedSnapshot: ({ _subscription, ...snapshot }) => snapshot,\n    restoreSnapshot: (snapshot: any) => ({\n      ...snapshot,\n      _subscription: undefined\n    })\n  };\n\n  return logic;\n}\n","import { parseDelayToMilliseconds } from '../delay.ts';\nimport { XSTATE_INIT } from '../constants.ts';\nimport { StandardSchemaV1 } from '../schema.types.ts';\nimport { AnyActorSystem } from '../system.ts';\nimport {\n  ActorLogic,\n  ActorFromLogic,\n  ActorRefFromLogic,\n  AnyActor,\n  EventObject,\n  NonReducibleUnknown,\n  Snapshot\n} from '../types.ts';\nimport {\n  XSTATE_LOGIC_EFFECT_REJECT,\n  XSTATE_LOGIC_EFFECT_RESOLVE,\n  XSTATE_LOGIC_EFFECT_START,\n  createLogic as createBaseLogic\n} from './logic.ts';\n\nexport type AsyncSnapshot<TOutput, TInput> = Snapshot<TOutput> & {\n  input: TInput | undefined;\n  effects?: Record<\n    string,\n    | { status: 'active' }\n    | { status: 'done'; output?: unknown }\n    | { status: 'error'; error: unknown }\n  >;\n};\n\nconst XSTATE_ASYNC_RESOLVE = 'xstate.async.resolve';\nconst XSTATE_ASYNC_REJECT = 'xstate.async.reject';\n\nexport type AsyncActorLogic<\n  TOutput,\n  TInput = unknown,\n  TEmitted extends EventObject = EventObject\n> = ActorLogic<\n  AsyncSnapshot<TOutput, TInput>,\n  { type: string; [k: string]: unknown },\n  TInput,\n  AnyActorSystem,\n  TEmitted\n>;\n\nexport type AsyncActorRef<TOutput> = ActorRefFromLogic<\n  AsyncActorLogic<TOutput, unknown>\n>;\n\ntype AsyncActor<\n  TOutput,\n  TInput = unknown,\n  TEmitted extends EventObject = EventObject\n> = ActorFromLogic<AsyncActorLogic<TOutput, TInput, TEmitted>>;\n\nexport interface LogicArgs<TOutput, TInput> {\n  /** Data that was provided to the async actor. */\n  input: TInput;\n  /** The actor system to which the async actor belongs. */\n  system: AnyActorSystem;\n  /** The async actor. */\n  self: AsyncActor<TOutput, TInput>;\n  /** Aborted when the async actor is stopped or times out. */\n  signal: AbortSignal;\n}\n\nexport interface LogicEnqueue<TEmitted extends EventObject> {\n  /** Emits an event that can be observed with `actor.on(...)`. */\n  emit: (emitted: TEmitted) => void;\n  /**\n   * Executes async work as a durable effect keyed by `key`.\n   *\n   * @experimental The durability semantics (step journaling, replay, and\n   *   resumption across persistence) are not finalized and may change.\n   */\n  step: <TStepOutput>(\n    key: string,\n    exec: () => TStepOutput | PromiseLike<TStepOutput>\n  ) => Promise<TStepOutput>;\n}\n\nexport type LogicFunction<\n  TOutput,\n  TInput = NonReducibleUnknown,\n  TEmitted extends EventObject = EventObject\n> = (\n  args: LogicArgs<TOutput, TInput>,\n  enq: LogicEnqueue<TEmitted>\n) => PromiseLike<TOutput>;\n\nexport interface LogicConfig<\n  TOutput,\n  TInput = NonReducibleUnknown,\n  TEmitted extends EventObject = EventObject,\n  TInputSchema extends StandardSchemaV1 = StandardSchemaV1,\n  TOutputSchema extends StandardSchemaV1 = StandardSchemaV1\n> {\n  /**\n   * Stable identifier for this async logic. This identifies the logic, not a\n   * particular actor instance.\n   */\n  id?: string;\n  /** Schemas for inferring async logic types. */\n  schemas?: {\n    input?: TInputSchema;\n    output?: TOutputSchema;\n  };\n  /** Maximum time this async logic may run before it is aborted and errors. */\n  timeout?: number | string;\n  /** The async work to execute when the actor starts. */\n  run: LogicFunction<TOutput, TInput, TEmitted>;\n}\n\nexport class TimeoutError extends Error {\n  constructor(timeout: number | string) {\n    super(`Async logic timed out after ${timeout}.`);\n    this.name = 'TimeoutError';\n  }\n}\n\n/**\n * Represents an actor created by `createAsyncLogic`.\n *\n * The type of `self` within the actor's logic.\n *\n * @example\n *\n * ```ts\n * import { createAsyncLogic, createActor } from 'xstate';\n *\n * // The actor's resolved output\n * type Output = string;\n * // The actor's input.\n * type Input = { message: string };\n *\n * // Actor logic that fetches the url of an image of a cat saying `input.message`.\n * const logic = createAsyncLogic<Output, Input>({\n *   run: async ({ input, self }, enq) => {\n *     self;\n *     // ^? AsyncActor<Output, Input>\n *     enq.emit({ type: 'request.start' });\n *\n *     const data = await fetch(\n *       `https://cataas.com/cat/says/${input.message}`\n *     );\n *     const url = await data.json();\n *     return url;\n *   }\n * });\n *\n * const actor = createActor(logic, { input: { message: 'hello world' } });\n * //    ^? AsyncActor<Output, Input>\n * ```\n *\n * @see {@link createAsyncLogic}\n */\n\n/**\n * An actor logic creator which returns async logic as defined by an async\n * process that resolves or rejects after some time.\n *\n * Actors created from async actor logic can:\n *\n * - Output the resolved value of the async process\n * - Error with the rejected value of the async process\n * - Abort when stopped or timed out\n *\n * Sending events to async actors will have no effect.\n *\n * @example\n *\n * ```ts\n * const asyncLogic = createAsyncLogic({\n *   id: 'fetch-user',\n *   timeout: '30s',\n *   run: async ({ signal }, enq) => {\n *     enq.emit({ type: 'request.start' });\n *     const result = await fetch('https://example.com/...', {\n *       signal\n *     }).then((data) => data.json());\n *\n *     return result;\n *   }\n * });\n *\n * const asyncActor = createActor(asyncLogic);\n * asyncActor.subscribe((snapshot) => {\n *   console.log(snapshot);\n * });\n * asyncActor.start();\n * // => {\n * //   output: undefined,\n * //   status: 'active'\n * //   ...\n * // }\n *\n * // After promise resolves\n * // => {\n * //   output: { ... },\n * //   status: 'done',\n * //   ...\n * // }\n * ```\n *\n * @param asyncLogic A config object with a `run` function which returns a\n *   Promise, and accepts an object with the following properties:\n *\n *   - `input` - Data that was provided to the async actor\n *   - `self` - The async actor ref\n *   - `system` - The actor system to which the async actor belongs\n *   - `signal` - An abort signal for cancellation\n *\n *   `run` also receives an `enq` object with the following properties:\n *\n *   - `emit` - Emits an event that can be observed with `actor.on(...)`\n *\n * @see {@link https://stately.ai/docs/input | Input docs} for more information about how input is passed\n */\nexport function createAsyncLogic<\n  const TInputSchema extends StandardSchemaV1,\n  const TOutputSchema extends StandardSchemaV1,\n  TEmitted extends EventObject = EventObject\n>(\n  asyncLogic: LogicConfig<\n    StandardSchemaV1.InferOutput<TOutputSchema>,\n    StandardSchemaV1.InferOutput<TInputSchema>,\n    TEmitted,\n    TInputSchema,\n    TOutputSchema\n  > & {\n    schemas: {\n      input: TInputSchema;\n      output: TOutputSchema;\n    };\n  }\n): AsyncActorLogic<\n  StandardSchemaV1.InferOutput<TOutputSchema>,\n  StandardSchemaV1.InferOutput<TInputSchema>,\n  TEmitted\n> & { id?: string };\nexport function createAsyncLogic<\n  TOutput,\n  const TInputSchema extends StandardSchemaV1,\n  TEmitted extends EventObject = EventObject\n>(\n  asyncLogic: LogicConfig<\n    TOutput,\n    StandardSchemaV1.InferOutput<TInputSchema>,\n    TEmitted,\n    TInputSchema\n  > & {\n    schemas: {\n      input: TInputSchema;\n      output?: never;\n    };\n  }\n): AsyncActorLogic<\n  TOutput,\n  StandardSchemaV1.InferOutput<TInputSchema>,\n  TEmitted\n> & { id?: string };\nexport function createAsyncLogic<\n  const TOutputSchema extends StandardSchemaV1,\n  TInput = NonReducibleUnknown,\n  TEmitted extends EventObject = EventObject\n>(\n  asyncLogic: LogicConfig<\n    StandardSchemaV1.InferOutput<TOutputSchema>,\n    TInput,\n    TEmitted,\n    StandardSchemaV1,\n    TOutputSchema\n  > & {\n    schemas: {\n      input?: never;\n      output: TOutputSchema;\n    };\n  }\n): AsyncActorLogic<\n  StandardSchemaV1.InferOutput<TOutputSchema>,\n  TInput,\n  TEmitted\n> & { id?: string };\nexport function createAsyncLogic<\n  TOutput,\n  TInput = NonReducibleUnknown,\n  TEmitted extends EventObject = EventObject\n>(\n  asyncLogic: Omit<LogicConfig<TOutput, TInput, TEmitted>, 'schemas'> & {\n    schemas?: undefined;\n  }\n): AsyncActorLogic<TOutput, TInput, TEmitted> & { id?: string };\nexport function createAsyncLogic<\n  TOutput,\n  TInput = NonReducibleUnknown,\n  TEmitted extends EventObject = EventObject\n>(\n  asyncLogic: LogicConfig<TOutput, TInput, TEmitted>\n): AsyncActorLogic<TOutput, TInput, TEmitted> & { id?: string } {\n  const config = asyncLogic;\n\n  function waitForEffect<TStepOutput>(\n    self: AsyncActorRef<TOutput>,\n    key: string\n  ): Promise<TStepOutput> {\n    return new Promise((resolve, reject) => {\n      const subscription = self.subscribe((snapshot) => {\n        const effect = snapshot.effects?.[key];\n\n        if (effect?.status === 'done') {\n          subscription.unsubscribe();\n          resolve(effect.output as TStepOutput);\n        } else if (effect?.status === 'error') {\n          subscription.unsubscribe();\n          reject(effect.error as Error);\n        }\n      });\n    });\n  }\n\n  return createBaseLogic<\n    undefined,\n    TOutput,\n    { type: string; [k: string]: unknown },\n    TInput,\n    TEmitted\n  >({\n    id: config.id,\n    schemas: config.schemas,\n    context: undefined,\n    run: ({ event, input, self, system }, enq) => {\n      switch (event.type) {\n        case XSTATE_ASYNC_RESOLVE: {\n          const resolvedValue = (event as any).data ?? (event as any).output;\n          return {\n            status: 'done',\n            output: resolvedValue,\n            input: undefined as TInput | undefined,\n            effects: {\n              async: { status: 'done', output: resolvedValue }\n            }\n          };\n        }\n        case XSTATE_ASYNC_REJECT: {\n          const error = (event as any).data ?? (event as any).error;\n          return {\n            status: 'error',\n            error,\n            input: undefined as TInput | undefined,\n            effects: {\n              async: { status: 'error', error }\n            }\n          };\n        }\n      }\n\n      if (event.type !== XSTATE_INIT) {\n        return;\n      }\n\n      enq.effect(() => {\n        const actorSelf = self as unknown as AnyActor;\n        const controller = new AbortController();\n        const timeout = config.timeout;\n        const timeoutMs = parseDelayToMilliseconds(timeout);\n        const timeoutId =\n          timeoutMs === undefined\n            ? undefined\n            : system._clock.setTimeout(() => {\n                if (self.getSnapshot().status !== 'active') {\n                  return;\n                }\n                controller.abort();\n                system._relay(actorSelf, actorSelf, {\n                  type: XSTATE_ASYNC_REJECT,\n                  data: new TimeoutError(timeout!)\n                });\n              }, timeoutMs);\n\n        const clearTimeout = () => {\n          if (timeoutId !== undefined) {\n            system._clock.clearTimeout(timeoutId);\n          }\n        };\n\n        const resolvedPromise = Promise.resolve(\n          config.run(\n            {\n              input,\n              system,\n              self: self as any,\n              signal: controller.signal\n            },\n            {\n              emit: enq.emit,\n              step: async (key, exec) => {\n                const effect = self.getSnapshot().effects?.[key];\n\n                if (effect?.status === 'done') {\n                  return effect.output as any;\n                }\n\n                if (effect?.status === 'error') {\n                  throw effect.error;\n                }\n\n                if (effect?.status === 'active') {\n                  return waitForEffect(self as any, key) as any;\n                }\n\n                system._relay(actorSelf, actorSelf, {\n                  type: XSTATE_LOGIC_EFFECT_START,\n                  key\n                });\n\n                try {\n                  const output = await exec();\n                  system._relay(actorSelf, actorSelf, {\n                    type: XSTATE_LOGIC_EFFECT_RESOLVE,\n                    key,\n                    output\n                  });\n                  return output;\n                } catch (error) {\n                  system._relay(actorSelf, actorSelf, {\n                    type: XSTATE_LOGIC_EFFECT_REJECT,\n                    key,\n                    error\n                  });\n                  throw error;\n                }\n              }\n            }\n          )\n        );\n\n        resolvedPromise.then(\n          (response) => {\n            clearTimeout();\n            if (self.getSnapshot().status !== 'active') {\n              return;\n            }\n            system._relay(actorSelf, actorSelf, {\n              type: XSTATE_ASYNC_RESOLVE,\n              data: response\n            });\n          },\n          (errorData) => {\n            clearTimeout();\n            if (self.getSnapshot().status !== 'active') {\n              return;\n            }\n            system._relay(actorSelf, actorSelf, {\n              type: XSTATE_ASYNC_REJECT,\n              data: errorData\n            });\n          }\n        );\n\n        return () => {\n          controller.abort();\n          clearTimeout();\n        };\n      });\n\n      return {\n        effects: {\n          async: { status: 'active' }\n        }\n      };\n    }\n  }) as unknown as AsyncActorLogic<TOutput, TInput, TEmitted> & { id?: string };\n}\n","import { createActor } from '../createActor.ts';\nimport type { ActorFromLogic } from '../types.ts';\nimport { createLogic } from './logic.ts';\nexport {\n  createCallbackLogic,\n  type CallbackActorLogic,\n  type CallbackActorRef,\n  type CallbackLogicConfig,\n  type CallbackSnapshot,\n  type CallbackLogicFunction\n} from './callback.ts';\nexport {\n  createObservableLogic,\n  createEventObservableLogic,\n  type EventObservableLogicConfig,\n  type EventObservableLogicFunction,\n  type ObservableActorLogic,\n  type ObservableActorRef,\n  type ObservableLogicConfig,\n  type ObservableLogicFunction,\n  type ObservableSnapshot\n} from './observable.ts';\nexport {\n  createLogic,\n  type LogicActorLogic,\n  type LogicActorRef,\n  type LogicArgs,\n  type LogicConfig,\n  type LogicEffect,\n  type LogicEffectState,\n  type LogicEnqueue,\n  type LogicFunction,\n  type LogicPatch,\n  type LogicSnapshot\n} from './logic.ts';\nexport {\n  createAsyncLogic,\n  type AsyncActorLogic,\n  type AsyncActorRef,\n  type AsyncSnapshot,\n  type LogicArgs as AsyncLogicArgs,\n  type LogicConfig as AsyncLogicConfig,\n  type LogicEnqueue as AsyncLogicEnqueue,\n  type LogicFunction as AsyncLogicFunction,\n  TimeoutError\n} from './promise.ts';\nexport {\n  createListenerLogic,\n  listenerLogic,\n  type ListenerActorLogic,\n  type ListenerActorRef,\n  type ListenerSnapshot,\n  type ListenerInput\n} from './listener.ts';\nexport {\n  createSubscriptionLogic,\n  subscriptionLogic,\n  type SubscriptionActorLogic,\n  type SubscriptionActorRef,\n  type SubscriptionSnapshot,\n  type SubscriptionInput,\n  type SubscriptionMappers\n} from './subscription.ts';\n\nconst emptyLogic = /* #__PURE__ */ createLogic<undefined, undefined>({\n  context: undefined,\n  run: () => undefined\n});\n\nexport function createEmptyActor(): ActorFromLogic<typeof emptyLogic> {\n  return createActor(emptyLogic);\n}\n"],"names":["Mailbox","constructor","_process","this","_active","_current","_last","start","flush","clear","next","enqueue","event","enqueued","value","consumed","XSTATE_INIT","XSTATE_STOP","createInitEvent","input","type","reportUnhandledError","err","setTimeout","symbolObservable","Symbol","observable","subscriptions","WeakMap","createAttachedLogic","attach","state","self","system","target","actor","getSnapshot","status","subscription","parentSubscription","torndown","teardown","unsubscribe","parent","_parent","subscribe","complete","error","set","transition","get","delete","undefined","getInitialSnapshot","_","output","getPersistedSnapshot","snapshot","restoreSnapshot","relayMappedToParent","getEvent","_relay","createListenerLogic","eventType","mapper","isPartialWildcard","endsWith","on","emittedEvent","descriptor","partialEventTokens","split","eventTokens","tokenIndex","length","partialEventToken","eventToken","matchesEventDescriptor","listenerLogic","$$atom","for","createSubscriptionLogic","mappers","done","onSnapshot","subscriptionLogic","parseDelayToMilliseconds","delay","duration","normalizedDuration","trim","millisecondsMatch","match","parseInt","secondsMatch","wholePart","hasDecimal","fracPart","padEnd","slice","iso8601DurationMatch","groups","weeks","days","hours","minutes","seconds","toNumber","Number","replace","parseDurationToMilliseconds","toObserver","nextHandler","errorHandler","completionHandler","isObserver","bind","createScheduledEventId","id","sessionId","effectStates","XSTATE_LOGIC_EFFECT_RESOLVE","XSTATE_LOGIC_EFFECT_REJECT","XSTATE_LOGIC_EFFECT_START","getEffectState","Map","executeLogicEffects","effects","actorScope","effect","emit","key","cleanup","exec","has","values","createLogic","config","trackedEffects","enq","emitted","push","sendBack","sentEvent","raise","raisedEvent","keyOrExec","maybeExec","enqueueEffect","patch","run","context","nextSnapshot","Object","keys","assign","resolveContext","executingCustomAction","ProcessingStatus","defaultOptions","clock","fn","ms","clearTimeout","logger","console","log","Actor","logic","options","_snapshot","_boundProcess","mailbox","observers","Set","eventListeners","_processingStatus","NotStarted","_syncSnapshot","ref","_actorScope","_lastSourceRef","_collectedMicrosteps","_collectedActions","_collectedSent","systemId","trigger","src","_deferred","_pendingEffects","resolvedOptions","syncSnapshot","inspect","rootActor","idCounter","children","keyedActors","reverseKeyedActors","inspectionObservers","timerMap","recordSent","source","size","targetRef","targetId","scheduler","schedule","Math","random","toString","scheduledEvent","startedAt","Date","now","scheduledEventId","_scheduledEvents","timeout","deliver","cancel","cancelAll","targetMachine","isInternalEventType","Error","_send","_bookId","_register","_unregister","getAll","fromEntries","entries","_set","existing","observerOrFn","observer","add","_sendInspectionEvent","resolvedInspectionEvent","rootId","forEach","scheduledEvents","scheduledId","_clock","_logger","_timerStrategy","timers","createSystem","defer","stopChild","child","_stop","listeners","wildcardListener","handler","actionExecutor","action","params","saveExecutingCustomAction","Running","send","Proxy","payload","persistedState","rest","actorRef","parentRef","_setErrorSnapshot","_next","update","i","deferredFn","_stopProcedure","_complete","doneEvent","invokeId","actorId","_error","sourceRef","microsteps","actions","sent","nextListenerOrObserver","errorListener","completeListener","Stopped","select","selector","equalityFn","is","selected","initEvent","strategy","resolveRestoredTimerDelay","nextState","caughtError","Array","isArray","stop","reportError","err2","toJSON","xstate$$type","persisted","pendingEffects","scheduled","elapsed","max","instanceStates","XSTATE_OBSERVABLE_NEXT","XSTATE_OBSERVABLE_ERROR","XSTATE_OBSERVABLE_COMPLETE","XSTATE_ASYNC_RESOLVE","XSTATE_ASYNC_REJECT","TimeoutError","super","name","emptyLogic","asyncLogic","createBaseLogic","schemas","resolvedValue","data","async","actorSelf","controller","AbortController","timeoutMs","timeoutId","abort","Promise","resolve","signal","step","reject","waitForEffect","then","response","errorData","callbackOrConfig","callback","args","callbackState","receivers","receiver","dispose","receive","listener","lazyObservableOrConfig","lazyObservable","_subscription","observableCreatorOrConfig","observableCreator"],"mappings":"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"}
+{"version":3,"file":"xstate-actors.umd.min.js","sources":["../src/Mailbox.ts","../src/constants.ts","../src/eventUtils.ts","../src/reportUnhandledError.ts","../src/symbolObservable.ts","../src/actors/attached.ts","../src/actors/listener.ts","../src/utils.ts","../src/actors/subscription.ts","../src/delay.ts","../src/system.ts","../src/actors/logic.ts","../src/createActor.ts","../src/actors/callback.ts","../src/actors/observable.ts","../src/actors/promise.ts","../src/actors/index.ts"],"sourcesContent":["interface MailboxItem<T> {\n  value: T;\n  next: MailboxItem<T> | null;\n}\n\nexport class Mailbox<T> {\n  private _active: boolean = false;\n  private _current: MailboxItem<T> | null = null;\n  private _last: MailboxItem<T> | null = null;\n\n  constructor(private _process: (ev: T) => void) {}\n\n  public start() {\n    this._active = true;\n    this.flush();\n  }\n\n  public clear(): void {\n    // we can't set _current to null because we might be currently processing\n    // and enqueue following clear shouldn't start processing the enqueued item immediately\n    if (this._current) {\n      this._current.next = null;\n      this._last = this._current;\n    }\n  }\n\n  public enqueue(event: T): void {\n    const enqueued = {\n      value: event,\n      next: null\n    };\n\n    if (this._current) {\n      this._last!.next = enqueued;\n      this._last = enqueued;\n      return;\n    }\n\n    this._current = enqueued;\n    this._last = enqueued;\n\n    if (this._active) {\n      this.flush();\n    }\n  }\n\n  private flush() {\n    while (this._current) {\n      // atm the given _process is responsible for implementing proper try/catch handling\n      // we assume here that this won't throw in a way that can affect this mailbox\n      const consumed = this._current;\n      this._process(consumed.value);\n      this._current = consumed.next;\n    }\n    this._last = null;\n  }\n}\n","export const STATE_DELIMITER = '.';\nexport const TARGETLESS_KEY = '';\nexport const NULL_EVENT = '';\nexport const STATE_IDENTIFIER = '#';\nexport const WILDCARD = '*';\nexport const XSTATE_INIT = '@xstate.init';\nexport const XSTATE_STOP = '@xstate.stop';\n","import { XSTATE_INIT } from './constants.ts';\nimport { DoneActorEvent, DoneStateEvent, ErrorActorEvent } from './types.ts';\n\n/**\n * Returns an event that represents an implicit event that is sent after the\n * specified `delay`.\n *\n * @param delayRef The delay in milliseconds\n * @param id The state node ID where this event is handled\n */\nexport function createAfterEvent(delayRef: number | string, id: string) {\n  return { type: `xstate.after.${delayRef}.${id}` } as const;\n}\n\n/**\n * Returns an event that represents an implicit state-level timeout. Fired when\n * a state's `timeout` duration elapses without the state being exited.\n *\n * @param id The state node ID where this timeout is configured\n */\nexport function createTimeoutEvent(id: string) {\n  return { type: `xstate.timeout.${id}` } as const;\n}\n\n/**\n * Returns an event that represents an implicit invoke-level timeout. Fired when\n * an invoked actor has not completed within its `timeout` duration.\n *\n * @param invokeId The invoked actor's ID\n */\nexport function createInvokeTimeoutEvent(invokeId: string) {\n  return { type: `xstate.timeout.actor.${invokeId}` } as const;\n}\n\n/**\n * Returns an event that represents that a final state node has been reached in\n * the parent state node.\n *\n * @param id The final state node's parent state node `id`\n * @param output The data to pass into the event\n */\nexport function createDoneStateEvent(\n  id: string,\n  output?: unknown\n): DoneStateEvent {\n  return {\n    type: `xstate.done.state.${id}`,\n    output\n  };\n}\n\n/**\n * Returns an event that represents that an invoked service has terminated.\n *\n * An invoked service is terminated when it has reached a top-level final state\n * node, but not when it is canceled.\n *\n * @param invokeId The invoked service ID\n * @param output The data to pass into the event\n */\nexport function createDoneActorEvent(\n  invokeId: string,\n  output?: unknown\n): DoneActorEvent {\n  return {\n    type: `xstate.done.actor.${invokeId}`,\n    output,\n    actorId: invokeId\n  };\n}\n\nexport function createErrorActorEvent(\n  id: string,\n  error?: unknown\n): ErrorActorEvent {\n  return { type: `xstate.error.actor.${id}`, error, actorId: id };\n}\n\nexport function createInitEvent(input: unknown) {\n  return { type: XSTATE_INIT, input } as const;\n}\n","/**\n * This function makes sure that unhandled errors are thrown in a separate\n * macrotask. It allows those errors to be detected by global error handlers and\n * reported to bug tracking services without interrupting our own stack of\n * execution.\n *\n * @param err Error to be thrown\n */\nexport function reportUnhandledError(err: unknown) {\n  setTimeout(() => {\n    throw err;\n  });\n}\n","export const symbolObservable: typeof Symbol.observable = (() =>\n  (typeof Symbol === 'function' && Symbol.observable) ||\n  '@@observable')() as any;\n","import { XSTATE_STOP } from '../constants.ts';\nimport type { AnyActorSystem } from '../system.ts';\nimport type {\n  AnyActor,\n  EventObject,\n  Snapshot,\n  Subscription\n} from '../types.ts';\n\nconst subscriptions = /* #__PURE__ */ new WeakMap<AnyActor, Subscription>();\n\n/**\n * Internal factory for actor logic that attaches to another actor on start\n * (`enq.listen()` / `enq.subscribeTo()`) and detaches when stopped.\n */\nexport function createAttachedLogic(\n  attach: (\n    input: any,\n    scope: { self: AnyActor; system: AnyActorSystem }\n  ) => Subscription | undefined\n): any {\n  const initialTransition = (input: unknown, _: unknown) =>\n    [\n      {\n        status: 'active',\n        output: undefined,\n        error: undefined,\n        input\n      },\n      []\n    ] as const;\n\n  return {\n    start: (state: any, { self, system }: any) => {\n      // Don't attach if the target doesn't exist or is stopped.\n      const target = state.input.actor;\n      if (!target || target.getSnapshot().status === 'stopped') {\n        return;\n      }\n      const subscription = attach(state.input, { self, system });\n      if (!subscription) {\n        return;\n      }\n\n      // Attached actors are not registered as children (their `input` holds\n      // non-serializable function mappers), so a parent stop does not cascade\n      // to them. Subscribe to the parent and tear down when it stops/errors,\n      // so the subscription never relays to a stopped parent or leaks the\n      // source subscription.\n      let parentSubscription: Subscription | undefined;\n      let torndown = false;\n      const teardown = () => {\n        if (torndown) {\n          return;\n        }\n        torndown = true;\n        subscription.unsubscribe();\n        parentSubscription?.unsubscribe();\n      };\n\n      const parent: AnyActor | undefined = self._parent;\n      if (parent) {\n        parentSubscription = parent.subscribe({\n          complete: teardown,\n          error: teardown\n        });\n      }\n\n      subscriptions.set(self, { unsubscribe: teardown });\n    },\n    transition: (state: any, event: EventObject, { self }: any) => {\n      if (event.type === XSTATE_STOP) {\n        subscriptions.get(self)?.unsubscribe();\n        subscriptions.delete(self);\n        return [\n          {\n            ...state,\n            status: 'stopped',\n            error: undefined\n          },\n          []\n        ];\n      }\n      return [state, []];\n    },\n    initialTransition,\n    getInitialSnapshot: (actorScope: unknown, input: unknown) =>\n      initialTransition(input, actorScope)[0],\n    getPersistedSnapshot: (snapshot: Snapshot<unknown>) => snapshot,\n    restoreSnapshot: (snapshot: Snapshot<unknown>) => snapshot\n  };\n}\n\n/**\n * Relays a mapped event to the attached actor's parent, unless the attached\n * actor has been stopped (the mapper is not called in that case).\n */\nexport function relayMappedToParent(\n  self: AnyActor,\n  system: AnyActorSystem,\n  getEvent: () => EventObject\n): void {\n  if (self.getSnapshot().status === 'stopped' || !self._parent) {\n    return;\n  }\n  system._relay(self, self._parent, getEvent());\n}\n","import { AnyActorSystem } from '../system.ts';\nimport { matchesEventDescriptor } from '../utils.ts';\nimport {\n  ActorLogic,\n  ActorRefFromLogic,\n  AnyActor,\n  EventObject,\n  Snapshot\n} from '../types';\nimport { createAttachedLogic, relayMappedToParent } from './attached.ts';\n\nexport type ListenerSnapshot = Snapshot<undefined> & {\n  input: ListenerInput<any, any>;\n};\n\nexport interface ListenerInput<\n  TEmitted extends EventObject,\n  TMappedEvent extends EventObject\n> {\n  actor: AnyActor;\n  eventType: string;\n  mapper: (event: TEmitted) => TMappedEvent;\n}\n\nexport type ListenerActorLogic<\n  TEmitted extends EventObject = EventObject,\n  TMappedEvent extends EventObject = EventObject\n> = ActorLogic<\n  ListenerSnapshot,\n  EventObject,\n  ListenerInput<TEmitted, TMappedEvent>,\n  AnyActorSystem,\n  EventObject\n>;\n\nexport type ListenerActorRef<\n  TEmitted extends EventObject = EventObject,\n  TMappedEvent extends EventObject = EventObject\n> = ActorRefFromLogic<ListenerActorLogic<TEmitted, TMappedEvent>>;\n\n/**\n * Creates actor logic for listening to emitted events from another actor. Used\n * internally by `enq.listen()`.\n */\nexport function createListenerLogic<\n  TEmitted extends EventObject = EventObject,\n  TMappedEvent extends EventObject = EventObject\n>(): ListenerActorLogic<TEmitted, TMappedEvent> {\n  return createAttachedLogic(\n    (\n      { actor, eventType, mapper }: ListenerInput<TEmitted, TMappedEvent>,\n      { self, system }\n    ) => {\n      // Determine the subscription type:\n      // - For exact matches or '*', subscribe directly\n      // - For partial wildcards ('data.*'), subscribe to '*' and filter\n      const isPartialWildcard = eventType !== '*' && eventType.endsWith('.*');\n\n      return actor.on(isPartialWildcard ? '*' : eventType, (emittedEvent) => {\n        if (\n          isPartialWildcard &&\n          !matchesEventDescriptor(emittedEvent.type, eventType)\n        ) {\n          return;\n        }\n        relayMappedToParent(self, system, () =>\n          mapper(emittedEvent as TEmitted)\n        );\n      });\n    }\n  );\n}\n\n// Singleton logic instance\nexport const listenerLogic = /* #__PURE__ */ createListenerLogic();\n","import isDevelopment from '#is-development';\nimport { isMachineSnapshot } from './State.ts';\nimport type { StateNode } from './StateNode.ts';\nimport { TARGETLESS_KEY, WILDCARD } from './constants.ts';\nimport { isStateId } from './stateUtils.ts';\nimport type {\n  AnyActor,\n  AnyEventObject,\n  AnyMachineSnapshot,\n  AnyStateMachine,\n  AnyTransitionConfig,\n  AnyTransitionConfigFunction,\n  ErrorActorEvent,\n  EventObject,\n  InvokeConfig,\n  MachineContext,\n  Mapper,\n  NonReducibleUnknown,\n  Observer,\n  SingleOrArray,\n  StateLike,\n  StateValue,\n  TransitionConfigTarget\n} from './types.ts';\n\nexport function matchesState(\n  parentStateId: StateValue,\n  childStateId: StateValue\n): boolean {\n  const parentStateValue = toStateValue(parentStateId);\n  const childStateValue = toStateValue(childStateId);\n\n  if (typeof childStateValue === 'string') {\n    if (typeof parentStateValue === 'string') {\n      return childStateValue === parentStateValue;\n    }\n\n    // Parent more specific than child\n    return false;\n  }\n\n  if (typeof parentStateValue === 'string') {\n    return parentStateValue in childStateValue;\n  }\n\n  return Object.keys(parentStateValue).every((key) => {\n    if (!(key in childStateValue)) {\n      return false;\n    }\n\n    return matchesState(parentStateValue[key]!, childStateValue[key]!);\n  });\n}\n\nexport function checkStateIn(\n  snapshot: AnyMachineSnapshot,\n  stateValue: StateValue\n) {\n  if (typeof stateValue === 'string' && isStateId(stateValue)) {\n    const target = snapshot.machine.getStateNodeById(stateValue);\n    return snapshot._nodes.some((sn) => sn === target);\n  }\n\n  return snapshot.matches(stateValue);\n}\n\nexport function toStatePath(stateId: string | string[]): string[] {\n  if (isArray(stateId)) {\n    return stateId;\n  }\n\n  const result: string[] = [];\n  let segment = '';\n\n  for (let i = 0; i < stateId.length; i++) {\n    const char = stateId.charCodeAt(i);\n    switch (char) {\n      // \\\n      case 92:\n        // consume the next character\n        segment += stateId[i + 1];\n        // and skip over it\n        i++;\n        continue;\n      // .\n      case 46:\n        result.push(segment);\n        segment = '';\n        continue;\n    }\n    segment += stateId[i];\n  }\n\n  result.push(segment);\n\n  return result;\n}\n\nfunction toStateValue(stateValue: StateLike<any> | StateValue): StateValue {\n  if (isMachineSnapshot(stateValue)) {\n    return stateValue.value;\n  }\n\n  if (typeof stateValue !== 'string') {\n    return stateValue as StateValue;\n  }\n\n  const statePath = toStatePath(stateValue);\n\n  return pathToStateValue(statePath);\n}\n\nexport function pathToStateValue(statePath: string[]): StateValue {\n  if (statePath.length === 1) {\n    return statePath[0];\n  }\n\n  const value: StateValue = {};\n  let marker = value;\n\n  for (let i = 0; i < statePath.length - 1; i++) {\n    if (i === statePath.length - 2) {\n      marker[statePath[i]] = statePath[i + 1];\n    } else {\n      const previous = marker;\n      marker = {};\n      previous[statePath[i]] = marker;\n    }\n  }\n\n  return value;\n}\n\nexport function mapValues<P, O extends Record<string, unknown>>(\n  collection: O,\n  iteratee: (item: O[keyof O], key: keyof O, collection: O, i: number) => P\n): { [key in keyof O]: P };\nexport function mapValues(\n  collection: Record<string, unknown>,\n  iteratee: (\n    item: unknown,\n    key: string,\n    collection: Record<string, unknown>,\n    i: number\n  ) => unknown\n) {\n  const result: Record<string, unknown> = {};\n\n  const collectionKeys = Object.keys(collection);\n  for (let i = 0; i < collectionKeys.length; i++) {\n    const key = collectionKeys[i];\n    result[key] = iteratee(collection[key], key, collection, i);\n  }\n\n  return result;\n}\n\nfunction toArrayStrict<T>(value: readonly T[] | T): readonly T[] {\n  if (isArray(value)) {\n    return value;\n  }\n  return [value];\n}\n\nexport function toArray<T>(value: readonly T[] | T | undefined): readonly T[] {\n  if (value === undefined) {\n    return [];\n  }\n  return toArrayStrict(value);\n}\n\nexport function resolveOutput<\n  TContext extends MachineContext,\n  TExpressionEvent extends EventObject\n>(\n  mapper:\n    | Mapper<TContext, TExpressionEvent, unknown, EventObject>\n    | NonReducibleUnknown,\n  context: TContext,\n  event: TExpressionEvent,\n  self: AnyActor\n): unknown {\n  if (typeof mapper === 'function') {\n    return mapper({ context, event, self });\n  }\n\n  if (\n    isDevelopment &&\n    !!mapper &&\n    typeof mapper === 'object' &&\n    Object.values(mapper).some((val) => typeof val === 'function')\n  ) {\n    console.warn(\n      `Dynamically mapping values to individual properties is deprecated. Use a single function that returns the mapped object instead.\\nFound object containing properties whose values are possibly mapping functions: ${Object.entries(\n        mapper\n      )\n        .filter(([, value]) => typeof value === 'function')\n        .map(\n          ([key, value]) =>\n            `\\n - ${key}: ${(value as () => any)\n              .toString()\n              .replace(/\\n\\s*/g, '')}`\n        )\n        .join('')}`\n    );\n  }\n\n  return mapper;\n}\n\nfunction isArray(value: any): value is readonly any[] {\n  return Array.isArray(value);\n}\n\nexport function isErrorActorEvent(\n  event: AnyEventObject\n): event is ErrorActorEvent {\n  return event.type.startsWith('xstate.error.actor');\n}\n\nexport function toTransitionConfigArray(\n  configLike: SingleOrArray<\n    AnyTransitionConfig | TransitionConfigTarget | AnyTransitionConfigFunction\n  >\n): Array<AnyTransitionConfig> {\n  return toArrayStrict(configLike).map((transitionLike) => {\n    if (\n      typeof transitionLike === 'undefined' ||\n      typeof transitionLike === 'string'\n    ) {\n      return { target: transitionLike };\n    }\n\n    if (typeof transitionLike === 'function') {\n      return { to: transitionLike };\n    }\n\n    return transitionLike;\n  });\n}\n\nexport function normalizeTarget<\n  TContext extends MachineContext,\n  TEvent extends EventObject\n>(\n  target: SingleOrArray<string | StateNode<TContext, TEvent>> | undefined\n): ReadonlyArray<string | StateNode<TContext, TEvent>> | undefined {\n  if (target === undefined || target === TARGETLESS_KEY) {\n    return undefined;\n  }\n  return toArray(target);\n}\n\nexport function toObserver<T>(\n  nextHandler?: Observer<T> | ((value: T) => void),\n  errorHandler?: (error: any) => void,\n  completionHandler?: () => void\n): Observer<T> {\n  const isObserver = typeof nextHandler === 'object';\n  const self = isObserver ? nextHandler : undefined;\n\n  return {\n    next: (isObserver ? nextHandler.next : nextHandler)?.bind(self),\n    error: (isObserver ? nextHandler.error : errorHandler)?.bind(self),\n    complete: (isObserver ? nextHandler.complete : completionHandler)?.bind(\n      self\n    )\n  };\n}\n\nexport function createInvokeId(stateNodeId: string, index: number): string {\n  return `${index}.${stateNodeId}`;\n}\n\nexport function resolveReferencedActor(machine: AnyStateMachine, src: string) {\n  const match = src.match(/^xstate\\.invoke\\.(\\d+)\\.(.*)/)!;\n  if (!match) {\n    return machine.implementations.actors[src];\n  }\n  const [, indexStr, nodeId] = match;\n  const node = machine.getStateNodeById(nodeId);\n  const invokeConfig = node.config.invoke!;\n  const configSrc = (\n    Array.isArray(invokeConfig)\n      ? invokeConfig[indexStr as any]\n      : (invokeConfig as InvokeConfig<\n          any,\n          any,\n          any,\n          any,\n          any,\n          any,\n          any, // TEmitted\n          any // TMeta\n        >)\n  ).src;\n  // A referenced actor may itself be registered by name.\n  return typeof configSrc === 'string'\n    ? machine.implementations.actors[configSrc]\n    : configSrc;\n}\n\nexport function getAllOwnEventDescriptors(snapshot: AnyMachineSnapshot) {\n  return [...new Set([...snapshot._nodes.flatMap((sn) => sn.ownEvents)])];\n}\n\n/**\n * Checks if an event type matches an event descriptor, supporting wildcards.\n * Event descriptors can be:\n *\n * - Exact matches: \"event.type\"\n * - Wildcard: \"*\"\n * - Partial matches: \"event.*\"\n *\n * @param eventType - The actual event type string\n * @param descriptor - The event descriptor to match against\n * @returns True if the event type matches the descriptor\n */\nexport function matchesEventDescriptor(\n  eventType: string,\n  descriptor: string\n): boolean {\n  if (descriptor === eventType) {\n    return true;\n  }\n\n  if (descriptor === WILDCARD) {\n    return true;\n  }\n\n  if (!descriptor.endsWith('.*')) {\n    return false;\n  }\n\n  if (isDevelopment && /.*\\*.+/.test(descriptor)) {\n    console.warn(\n      `Wildcards can only be the last token of an event descriptor (e.g., \"event.*\") or the entire event descriptor (\"*\"). Check the \"${descriptor}\" event.`\n    );\n  }\n\n  const partialEventTokens = descriptor.split('.');\n  const eventTokens = eventType.split('.');\n\n  for (\n    let tokenIndex = 0;\n    tokenIndex < partialEventTokens.length;\n    tokenIndex++\n  ) {\n    const partialEventToken = partialEventTokens[tokenIndex];\n    const eventToken = eventTokens[tokenIndex];\n\n    if (partialEventToken === '*') {\n      const isLastToken = tokenIndex === partialEventTokens.length - 1;\n\n      if (isDevelopment && !isLastToken) {\n        console.warn(\n          `Infix wildcards in transition events are not allowed. Check the \"${descriptor}\" transition.`\n        );\n      }\n\n      return isLastToken;\n    }\n\n    if (partialEventToken !== eventToken) {\n      return false;\n    }\n  }\n\n  return true;\n}\n","import { AnyActorSystem } from '../system.ts';\nimport {\n  ActorLogic,\n  ActorRefFromLogic,\n  AnyActorRef,\n  EventObject,\n  Snapshot\n} from '../types';\nimport { createAttachedLogic, relayMappedToParent } from './attached.ts';\n\nexport type SubscriptionSnapshot = Snapshot<undefined> & {\n  input: SubscriptionInput<any, any, any, any>;\n};\n\nexport interface SubscriptionMappers<\n  TSnapshot extends Snapshot<unknown>,\n  TOutput,\n  TMappedEvent extends EventObject\n> {\n  snapshot?: (snapshot: TSnapshot) => TMappedEvent;\n  done?: (output: TOutput) => TMappedEvent;\n  error?: (error: unknown) => TMappedEvent;\n}\n\nexport interface SubscriptionInput<\n  TSnapshot extends Snapshot<unknown>,\n  TOutput,\n  TMappedEvent extends EventObject,\n  TMappers extends SubscriptionMappers<TSnapshot, TOutput, TMappedEvent>\n> {\n  actor: AnyActorRef;\n  mappers: TMappers;\n}\n\nexport type SubscriptionActorLogic<\n  TSnapshot extends Snapshot<unknown> = Snapshot<unknown>,\n  TOutput = unknown,\n  TMappedEvent extends EventObject = EventObject\n> = ActorLogic<\n  SubscriptionSnapshot,\n  EventObject,\n  SubscriptionInput<\n    TSnapshot,\n    TOutput,\n    TMappedEvent,\n    SubscriptionMappers<TSnapshot, TOutput, TMappedEvent>\n  >,\n  AnyActorSystem,\n  EventObject\n>;\n\nexport type SubscriptionActorRef<\n  TSnapshot extends Snapshot<unknown> = Snapshot<unknown>,\n  TOutput = unknown,\n  TMappedEvent extends EventObject = EventObject\n> = ActorRefFromLogic<SubscriptionActorLogic<TSnapshot, TOutput, TMappedEvent>>;\n\n/**\n * Creates actor logic for subscribing to lifecycle events (done/error/snapshot)\n * from another actor. Used internally by `enq.subscribeTo()`.\n */\nexport function createSubscriptionLogic<\n  TSnapshot extends Snapshot<unknown> = Snapshot<unknown>,\n  TOutput = unknown,\n  TMappedEvent extends EventObject = EventObject\n>(): SubscriptionActorLogic<TSnapshot, TOutput, TMappedEvent> {\n  return createAttachedLogic(({ actor, mappers }, { self, system }) => {\n    const { done, error, snapshot: onSnapshot } = mappers;\n\n    return actor.subscribe({\n      next: (snapshot: TSnapshot) => {\n        if (snapshot.status === 'done' && done) {\n          relayMappedToParent(self, system, () =>\n            done(snapshot.output as TOutput)\n          );\n        } else if (snapshot.status === 'error' && error) {\n          relayMappedToParent(self, system, () => error(snapshot.error));\n        } else if (snapshot.status === 'active' && onSnapshot) {\n          relayMappedToParent(self, system, () => onSnapshot(snapshot));\n        }\n      },\n      error: (err: unknown) => {\n        if (error) {\n          relayMappedToParent(self, system, () => error(err));\n        }\n      },\n      complete: () => {\n        // Actor completed without output (stopped); no action needed\n      }\n    });\n  });\n}\n\n// Singleton logic instance\nexport const subscriptionLogic = /* #__PURE__ */ createSubscriptionLogic();\n","export function parseDurationToMilliseconds(\n  duration: string\n): number | undefined {\n  const normalizedDuration = duration.trim();\n\n  const millisecondsMatch = normalizedDuration.match(/^(\\d+)ms$/i);\n  if (millisecondsMatch) {\n    return parseInt(millisecondsMatch[1], 10);\n  }\n\n  const secondsMatch = normalizedDuration.match(/^(\\d*)(\\.?)(\\d*)s$/i);\n  if (secondsMatch) {\n    const wholePart = secondsMatch[1] ? parseInt(secondsMatch[1], 10) : 0;\n    const hasDecimal = !!secondsMatch[2];\n    const fracPart = secondsMatch[3]\n      ? parseInt(secondsMatch[3].padEnd(3, '0').slice(0, 3), 10)\n      : 0;\n\n    return wholePart * 1000 + (hasDecimal ? fracPart : 0);\n  }\n\n  const iso8601DurationMatch = normalizedDuration.match(\n    /^P(?:(?<weeks>\\d+(?:[.,]\\d+)?)W)?(?:(?<days>\\d+(?:[.,]\\d+)?)D)?(?:T(?:(?<hours>\\d+(?:[.,]\\d+)?)H)?(?:(?<minutes>\\d+(?:[.,]\\d+)?)M)?(?:(?<seconds>\\d+(?:[.,]\\d+)?)S)?)?$/i\n  );\n\n  if (!iso8601DurationMatch?.groups) {\n    return undefined;\n  }\n\n  const { weeks, days, hours, minutes, seconds } = iso8601DurationMatch.groups;\n  if (!weeks && !days && !hours && !minutes && !seconds) {\n    return undefined;\n  }\n\n  const toNumber = (value: string | undefined) =>\n    value ? Number(value.replace(',', '.')) : 0;\n\n  return (\n    toNumber(weeks) * 7 * 24 * 60 * 60 * 1000 +\n    toNumber(days) * 24 * 60 * 60 * 1000 +\n    toNumber(hours) * 60 * 60 * 1000 +\n    toNumber(minutes) * 60 * 1000 +\n    toNumber(seconds) * 1000\n  );\n}\n\nexport function parseDelayToMilliseconds(\n  delay: string | number | undefined\n): number | undefined {\n  if (delay === undefined) {\n    return undefined;\n  }\n\n  if (typeof delay === 'number') {\n    return delay;\n  }\n\n  return parseDurationToMilliseconds(delay);\n}\n","import { InspectionEvent } from './inspection.ts';\nimport {\n  AnyEventObject,\n  ActorSystemInfo,\n  AnyActor,\n  Observer,\n  HomomorphicOmit,\n  EventObject,\n  Subscription,\n  TimersRestoreStrategy\n} from './types.ts';\nimport { toObserver } from './utils.ts';\n\ninterface ScheduledEvent {\n  id: string;\n  event: EventObject;\n  startedAt: number; // timestamp\n  delay: number;\n  source: AnyActor;\n  target: AnyActor;\n}\n\nexport interface Clock {\n  setTimeout(fn: (...args: any[]) => void, timeout: number): any;\n  clearTimeout(id: any): void;\n}\n\ninterface Scheduler {\n  schedule(\n    source: AnyActor,\n    target: AnyActor,\n    event: EventObject,\n    delay: number,\n    id: string | undefined\n  ): void;\n  cancel(source: AnyActor, id: string): void;\n  cancelAll(actor: AnyActor): void;\n}\n\ntype ScheduledEventId = string & { __scheduledEventId: never };\n\nfunction createScheduledEventId(actor: AnyActor, id: string): ScheduledEventId {\n  return `${actor.sessionId}.${id}` as ScheduledEventId;\n}\n\nexport interface ActorSystem<T extends ActorSystemInfo> {\n  /** @internal */\n  children: Map<string, AnyActor>;\n  /** @internal */\n  reverseKeyedActors: WeakMap<AnyActor, keyof T['actors']>;\n  /** @internal */\n  keyedActors: Map<keyof T['actors'], AnyActor | undefined>;\n  /** @internal */\n  _bookId: () => string;\n  /** @internal */\n  _register: (sessionId: string, actor: AnyActor) => string;\n  /** @internal */\n  _unregister: (actor: AnyActor) => void;\n  /** @internal */\n  _set: <K extends keyof T['actors']>(key: K, actor: AnyActor) => void;\n  get: <K extends keyof T['actors']>(key: K) => T['actors'][K] | undefined;\n  getAll: () => Partial<T['actors']>;\n\n  inspect: (\n    observer:\n      | Observer<InspectionEvent>\n      | ((inspectionEvent: InspectionEvent) => void)\n  ) => Subscription;\n  /** @internal */\n  _sendInspectionEvent: (\n    event: HomomorphicOmit<InspectionEvent, 'rootId'>\n  ) => void;\n  /** @internal */\n  _relay: (\n    source: AnyActor | undefined,\n    target: AnyActor,\n    event: AnyEventObject\n  ) => void;\n  scheduler: Scheduler;\n  getSnapshot: () => {\n    _scheduledEvents: Record<string, ScheduledEvent>;\n  };\n  /** @internal */\n  _snapshot: {\n    _scheduledEvents: Record<ScheduledEventId, ScheduledEvent>;\n  };\n  start: () => void;\n  _clock: Clock;\n  _logger: (...args: any[]) => void;\n  /**\n   * How rehydrated actors in this system restore persisted timers.\n   *\n   * @internal\n   */\n  _timerStrategy?: TimersRestoreStrategy;\n}\n\nexport type AnyActorSystem = ActorSystem<any>;\n\nexport function createSystem<T extends ActorSystemInfo>(\n  rootActor: AnyActor,\n  options: {\n    clock: Clock;\n    logger: (...args: any[]) => void;\n    snapshot?: unknown;\n    timers?: TimersRestoreStrategy;\n  }\n): ActorSystem<T> {\n  let idCounter = 0;\n  const children = new Map<string, AnyActor>();\n  const keyedActors = new Map<keyof T['actors'], AnyActor | undefined>();\n  const reverseKeyedActors = new WeakMap<AnyActor, keyof T['actors']>();\n  const inspectionObservers = new Set<Observer<InspectionEvent>>();\n  const timerMap: { [id: ScheduledEventId]: number } = {};\n  const { clock, logger } = options;\n\n  // Records a send on the *sender's* transition for the `sent[]` inspection\n  // facet. Captures the send when it is initiated (including delayed sends that\n  // may never deliver), keyed to the source actor's in-flight transition.\n  const recordSent = (\n    source: AnyActor | undefined,\n    target: AnyActor,\n    event: AnyEventObject,\n    delay?: number,\n    id?: string\n  ) => {\n    if (!inspectionObservers.size || !source) {\n      return;\n    }\n    const collected = ((source as any)._collectedSent ??= []);\n    collected.push({\n      targetRef: target,\n      targetId: target.id,\n      event,\n      delay,\n      id\n    });\n  };\n\n  const scheduler: Scheduler = {\n    schedule: (\n      source,\n      target,\n      event,\n      delay,\n      id = Math.random().toString(36).slice(2)\n    ) => {\n      recordSent(source, target, event, delay, id);\n      const scheduledEvent: ScheduledEvent = {\n        source,\n        target,\n        event,\n        delay,\n        id,\n        startedAt: Date.now()\n      };\n      const scheduledEventId = createScheduledEventId(source, id);\n      system._snapshot._scheduledEvents[scheduledEventId] = scheduledEvent;\n\n      const timeout = clock.setTimeout(() => {\n        delete timerMap[scheduledEventId];\n        delete system._snapshot._scheduledEvents[scheduledEventId];\n\n        // The send was already recorded at schedule time on the sender's\n        // transition, so deliver without re-recording.\n        deliver(source, target, event);\n      }, delay);\n\n      timerMap[scheduledEventId] = timeout;\n    },\n    cancel: (source, id: string) => {\n      const scheduledEventId = createScheduledEventId(source, id);\n      const timeout = timerMap[scheduledEventId];\n\n      delete timerMap[scheduledEventId];\n      delete system._snapshot._scheduledEvents[scheduledEventId];\n\n      if (timeout !== undefined) {\n        clock.clearTimeout(timeout);\n      }\n    },\n    cancelAll: (actor) => {\n      for (const scheduledEventId in system._snapshot._scheduledEvents) {\n        const scheduledEvent =\n          system._snapshot._scheduledEvents[\n            scheduledEventId as ScheduledEventId\n          ];\n        if (scheduledEvent.source === actor) {\n          scheduler.cancel(actor, scheduledEvent.id);\n        }\n      }\n    }\n  };\n  // Delivers an event to the target actor. Used by both `_relay` (which also\n  // records the send) and the scheduler's timer (which already recorded it).\n  const deliver = (\n    source: AnyActor | undefined,\n    target: AnyActor,\n    event: AnyEventObject\n  ) => {\n    const targetMachine = (target as any).logic;\n    const isInternalEvent =\n      typeof targetMachine?.isInternalEventType === 'function' &&\n      targetMachine.isInternalEventType(event.type);\n\n    if (isInternalEvent && source !== target) {\n      throw new Error(\n        `Internal event \"${event.type}\" cannot be sent to actor \"${target.id}\" from outside.`\n      );\n    }\n\n    // remember the last source for unified transition inspect event\n    (target as any)._lastSourceRef = source;\n    target._send(event);\n  };\n\n  const sendInspectionEvent = (event: InspectionEvent) => {\n    if (!inspectionObservers.size) {\n      return;\n    }\n    const resolvedInspectionEvent: InspectionEvent = {\n      ...event,\n      rootId: rootActor.sessionId!\n    };\n    inspectionObservers.forEach((observer) =>\n      observer.next?.(resolvedInspectionEvent)\n    );\n  };\n\n  const system: ActorSystem<T> = {\n    children,\n    reverseKeyedActors,\n    keyedActors,\n    _snapshot: {\n      _scheduledEvents:\n        (options?.snapshot && (options.snapshot as any).scheduler) ?? {}\n    },\n    _bookId: () => `x:${idCounter++}`,\n    _register: (sessionId, actor) => {\n      children.set(sessionId, actor);\n      return sessionId;\n    },\n    _unregister: (actor) => {\n      children.delete(actor.sessionId!);\n      const systemId = reverseKeyedActors.get(actor);\n\n      if (systemId !== undefined) {\n        keyedActors.delete(systemId);\n        reverseKeyedActors.delete(actor);\n      }\n    },\n    get: (systemId) => {\n      return keyedActors.get(systemId) as T['actors'][any] | undefined;\n    },\n    getAll: () => {\n      return Object.fromEntries(keyedActors.entries()) as Partial<T['actors']>;\n    },\n    _set: (systemId, actor) => {\n      const existing = keyedActors.get(systemId);\n      if (existing && existing !== actor) {\n        throw new Error(\n          `Actor with system ID '${systemId as string}' already exists.`\n        );\n      }\n\n      keyedActors.set(systemId, actor);\n      reverseKeyedActors.set(actor, systemId);\n    },\n    inspect: (observerOrFn) => {\n      const observer = toObserver(observerOrFn);\n      inspectionObservers.add(observer);\n\n      return {\n        unsubscribe() {\n          inspectionObservers.delete(observer);\n        }\n      };\n    },\n    _sendInspectionEvent: sendInspectionEvent as any,\n    _relay: (source, target, event) => {\n      recordSent(source, target, event);\n      deliver(source, target, event);\n    },\n    scheduler,\n    getSnapshot: () => {\n      return {\n        _scheduledEvents: { ...system._snapshot._scheduledEvents }\n      };\n    },\n    start: () => {\n      const scheduledEvents = system._snapshot._scheduledEvents;\n      system._snapshot._scheduledEvents = {};\n      for (const scheduledId in scheduledEvents) {\n        const { source, target, event, delay, id } =\n          scheduledEvents[scheduledId as ScheduledEventId];\n        scheduler.schedule(source, target, event, delay, id);\n      }\n    },\n    _clock: clock,\n    _logger: logger,\n    _timerStrategy: options.timers\n  };\n\n  return system;\n}\n","import { XSTATE_STOP } from '../constants.ts';\nimport { createInitEvent } from '../eventUtils.ts';\nimport { StandardSchemaV1 } from '../schema.types.ts';\nimport { AnyActorSystem } from '../system.ts';\nimport {\n  ActorLogic,\n  ActorRefFromLogic,\n  ActorScope,\n  AnyActorRef,\n  EventObject,\n  NonReducibleUnknown,\n  Snapshot\n} from '../types.ts';\n\nexport type LogicSnapshot<TContext, TOutput, TInput> = Snapshot<TOutput> & {\n  context: TContext;\n  input: TInput | undefined;\n  effects?: Record<string, LogicEffectState>;\n};\n\nexport type LogicEffectState =\n  | { status: 'active' }\n  | { status: 'done'; output?: unknown }\n  | { status: 'error'; error: unknown };\n\nexport interface LogicArgs<TContext, TEvent extends EventObject, TInput> {\n  context: TContext;\n  event: TEvent;\n  input: TInput;\n  system: AnyActorSystem;\n  self: LogicActorRef<TContext, unknown, TEvent, TInput>;\n}\n\nexport type LogicEffect<\n  TEvent extends EventObject,\n  TEmitted extends EventObject\n> =\n  | { type: 'emit'; event: TEmitted }\n  | { type: 'sendBack'; event: EventObject }\n  | { type: 'raise'; event: TEvent }\n  | { type: 'effect'; key?: string; exec: () => void | (() => void) }\n  | { type: 'cleanupEffects' };\n\nexport interface LogicEnqueue<\n  TEvent extends EventObject,\n  TEmitted extends EventObject\n> {\n  emit: (emitted: TEmitted) => void;\n  sendBack: (event: EventObject) => void;\n  raise: (event: TEvent) => void;\n  effect: {\n    (exec: () => void | (() => void)): void;\n    (key: string, exec: () => void | (() => void)): void;\n  };\n}\n\nexport type LogicPatch<TContext, TOutput, TInput> = Partial<{\n  context: TContext;\n  input: TInput | undefined;\n  status: LogicSnapshot<TContext, TOutput, TInput>['status'];\n  output: TOutput;\n  error: unknown;\n  effects: Record<string, LogicEffectState>;\n}>;\n\nexport type LogicFunction<\n  TContext,\n  TOutput,\n  TEvent extends EventObject,\n  TInput,\n  TEmitted extends EventObject\n> = (\n  args: LogicArgs<TContext, TEvent, TInput>,\n  enq: LogicEnqueue<TEvent, TEmitted>\n) => void | LogicPatch<TContext, TOutput, TInput>;\n\nexport interface LogicConfig<\n  TContext,\n  TOutput,\n  TEvent extends EventObject,\n  TInput,\n  TEmitted extends EventObject,\n  TInputSchema extends StandardSchemaV1 = StandardSchemaV1,\n  TOutputSchema extends StandardSchemaV1 = StandardSchemaV1\n> {\n  id?: string;\n  schemas?: {\n    input?: TInputSchema;\n    output?: TOutputSchema;\n  };\n  context: TContext | ((args: { input: TInput }) => TContext);\n  run: LogicFunction<TContext, TOutput, TEvent, TInput, TEmitted>;\n}\n\ninterface LogicTransition<\n  TContext,\n  TOutput,\n  TEvent extends EventObject,\n  TInput,\n  TEmitted extends EventObject\n> {\n  (\n    snapshot: LogicSnapshot<TContext, TOutput, TInput>,\n    event: TEvent,\n    actorScope: ActorScope<\n      LogicSnapshot<TContext, TOutput, TInput>,\n      TEvent,\n      AnyActorSystem,\n      TEmitted\n    >\n  ): [\n    LogicSnapshot<TContext, TOutput, TInput>,\n    LogicEffect<TEvent, TEmitted>[]\n  ];\n  (\n    snapshot: LogicSnapshot<TContext, TOutput, TInput>,\n    event: TEvent,\n    actorScope: ActorScope<\n      LogicSnapshot<TContext, TOutput, TInput>,\n      TEvent,\n      AnyActorSystem,\n      TEmitted\n    >\n  ): LogicSnapshot<TContext, TOutput, TInput>;\n}\n\nexport type LogicActorLogic<\n  TContext,\n  TOutput,\n  TEvent extends EventObject = EventObject,\n  TInput = NonReducibleUnknown,\n  TEmitted extends EventObject = EventObject\n> = Omit<\n  ActorLogic<\n    LogicSnapshot<TContext, TOutput, TInput>,\n    TEvent,\n    TInput,\n    AnyActorSystem,\n    TEmitted\n  >,\n  'transition'\n> & {\n  id?: string;\n  transition: LogicTransition<TContext, TOutput, TEvent, TInput, TEmitted>;\n};\n\nexport type LogicActorRef<\n  TContext,\n  TOutput,\n  TEvent extends EventObject,\n  TInput\n> = ActorRefFromLogic<LogicActorLogic<TContext, TOutput, TEvent, TInput>>;\n\nconst effectStates = new WeakMap<\n  AnyActorRef,\n  Map<PropertyKey, { cleanup?: () => void }>\n>();\n\nexport const XSTATE_LOGIC_EFFECT_RESOLVE = 'xstate.logic.effect.resolve';\nexport const XSTATE_LOGIC_EFFECT_REJECT = 'xstate.logic.effect.reject';\nexport const XSTATE_LOGIC_EFFECT_START = 'xstate.logic.effect.start';\n\nfunction getEffectState(self: AnyActorRef) {\n  let state = effectStates.get(self);\n  if (!state) {\n    state = new Map();\n    effectStates.set(self, state);\n  }\n  return state;\n}\n\nexport function executeLogicEffects(\n  effects: readonly unknown[] | undefined,\n  actorScope: ActorScope<any, any, any, any>\n) {\n  if (!effects?.length) {\n    return;\n  }\n\n  for (const effect of effects as LogicEffect<EventObject, EventObject>[]) {\n    switch (effect.type) {\n      case 'emit':\n        actorScope.emit(effect.event);\n        break;\n      case 'sendBack': {\n        const parent = (actorScope.self as any)._parent;\n        if (parent) {\n          actorScope.system._relay(actorScope.self, parent, effect.event);\n        }\n        break;\n      }\n      case 'raise':\n        actorScope.system._relay(\n          actorScope.self,\n          actorScope.self,\n          effect.event\n        );\n        break;\n      case 'effect': {\n        if (!effect.key) {\n          const cleanup = effect.exec();\n          if (typeof cleanup === 'function') {\n            getEffectState(actorScope.self).set(Symbol(), { cleanup });\n          }\n          break;\n        }\n\n        const state = getEffectState(actorScope.self);\n        if (state.has(effect.key)) {\n          break;\n        }\n        const cleanup = effect.exec();\n        state.set(effect.key, {\n          cleanup: typeof cleanup === 'function' ? cleanup : undefined\n        });\n        break;\n      }\n      case 'cleanupEffects': {\n        const state = effectStates.get(actorScope.self);\n        if (!state) {\n          break;\n        }\n        for (const { cleanup } of state.values()) {\n          cleanup?.();\n        }\n        effectStates.delete(actorScope.self);\n        break;\n      }\n    }\n  }\n}\n\nfunction resolveContext<TContext, TInput>(\n  context: TContext | ((args: { input: TInput }) => TContext),\n  input: TInput\n) {\n  return typeof context === 'function'\n    ? (context as (args: { input: TInput }) => TContext)({ input })\n    : context;\n}\n\nexport function createLogic<\n  TContext,\n  const TInputSchema extends StandardSchemaV1,\n  const TOutputSchema extends StandardSchemaV1,\n  TEvent extends EventObject = EventObject,\n  TEmitted extends EventObject = EventObject\n>(\n  config: LogicConfig<\n    TContext,\n    StandardSchemaV1.InferOutput<TOutputSchema>,\n    TEvent,\n    StandardSchemaV1.InferOutput<TInputSchema>,\n    TEmitted,\n    TInputSchema,\n    TOutputSchema\n  > & {\n    schemas: {\n      input: TInputSchema;\n      output: TOutputSchema;\n    };\n  }\n): LogicActorLogic<\n  TContext,\n  StandardSchemaV1.InferOutput<TOutputSchema>,\n  TEvent,\n  StandardSchemaV1.InferOutput<TInputSchema>,\n  TEmitted\n>;\nexport function createLogic<\n  TContext,\n  TOutput,\n  const TInputSchema extends StandardSchemaV1,\n  TEvent extends EventObject = EventObject,\n  TEmitted extends EventObject = EventObject\n>(\n  config: LogicConfig<\n    TContext,\n    TOutput,\n    TEvent,\n    StandardSchemaV1.InferOutput<TInputSchema>,\n    TEmitted,\n    TInputSchema\n  > & {\n    schemas: {\n      input: TInputSchema;\n      output?: undefined;\n    };\n  }\n): LogicActorLogic<\n  TContext,\n  TOutput,\n  TEvent,\n  StandardSchemaV1.InferOutput<TInputSchema>,\n  TEmitted\n>;\nexport function createLogic<\n  TContext,\n  const TOutputSchema extends StandardSchemaV1,\n  TEvent extends EventObject = EventObject,\n  TInput = NonReducibleUnknown,\n  TEmitted extends EventObject = EventObject\n>(\n  config: LogicConfig<\n    TContext,\n    StandardSchemaV1.InferOutput<TOutputSchema>,\n    TEvent,\n    TInput,\n    TEmitted,\n    StandardSchemaV1,\n    TOutputSchema\n  > & {\n    schemas: {\n      input?: undefined;\n      output: TOutputSchema;\n    };\n  }\n): LogicActorLogic<\n  TContext,\n  StandardSchemaV1.InferOutput<TOutputSchema>,\n  TEvent,\n  TInput,\n  TEmitted\n>;\nexport function createLogic<\n  TContext,\n  TOutput = unknown,\n  TEvent extends EventObject = EventObject,\n  TInput = NonReducibleUnknown,\n  TEmitted extends EventObject = EventObject\n>(\n  config: LogicConfig<TContext, TOutput, TEvent, TInput, TEmitted>\n): LogicActorLogic<TContext, TOutput, TEvent, TInput, TEmitted>;\nexport function createLogic<\n  TContext,\n  TOutput = unknown,\n  TEvent extends EventObject = EventObject,\n  TInput = NonReducibleUnknown,\n  TEmitted extends EventObject = EventObject\n>(\n  config: LogicConfig<TContext, TOutput, TEvent, TInput, TEmitted>\n): LogicActorLogic<TContext, TOutput, TEvent, TInput, TEmitted> {\n  const transition = ((snapshot, event, actorScope) => {\n    if (snapshot.status !== 'active') {\n      return [snapshot, []];\n    }\n\n    if (event.type === XSTATE_STOP) {\n      return [\n        {\n          ...snapshot,\n          status: 'stopped',\n          input: undefined\n        },\n        [{ type: 'cleanupEffects' }]\n      ];\n    }\n\n    if (event.type === XSTATE_LOGIC_EFFECT_START) {\n      return [\n        {\n          ...snapshot,\n          effects: {\n            ...snapshot.effects,\n            [(event as any).key]: { status: 'active' }\n          }\n        },\n        []\n      ];\n    }\n\n    if (event.type === XSTATE_LOGIC_EFFECT_RESOLVE) {\n      return [\n        {\n          ...snapshot,\n          effects: {\n            ...snapshot.effects,\n            [(event as any).key]: {\n              status: 'done',\n              output: (event as any).output\n            }\n          }\n        },\n        []\n      ];\n    }\n\n    if (event.type === XSTATE_LOGIC_EFFECT_REJECT) {\n      return [\n        {\n          ...snapshot,\n          effects: {\n            ...snapshot.effects,\n            [(event as any).key]: {\n              status: 'error',\n              error: (event as any).error\n            }\n          }\n        },\n        []\n      ];\n    }\n\n    const effects: LogicEffect<TEvent, TEmitted>[] = [];\n    const trackedEffects: Record<string, LogicEffectState> = {};\n    const enqueueEffect = (key: string, exec: () => void | (() => void)) => {\n      if (snapshot.effects?.[key]) {\n        return;\n      }\n      effects.push({ type: 'effect', key, exec });\n      trackedEffects[key] = { status: 'active' };\n    };\n    const enq: LogicEnqueue<TEvent, TEmitted> = {\n      emit: (emitted) => {\n        effects.push({ type: 'emit', event: emitted });\n      },\n      sendBack: (sentEvent) => {\n        effects.push({ type: 'sendBack', event: sentEvent });\n      },\n      raise: (raisedEvent) => {\n        effects.push({ type: 'raise', event: raisedEvent });\n      },\n      effect: ((keyOrExec, maybeExec) => {\n        if (typeof keyOrExec === 'string') {\n          enqueueEffect(keyOrExec, maybeExec);\n          return;\n        }\n        effects.push({ type: 'effect', exec: keyOrExec });\n      }) as LogicEnqueue<TEvent, TEmitted>['effect']\n    };\n\n    const patch = config.run(\n      {\n        context: snapshot.context,\n        event,\n        input: snapshot.input!,\n        system: actorScope.system,\n        self: actorScope.self as any,\n        emit: actorScope.emit\n      } as LogicArgs<TContext, TEvent, TInput>,\n      enq\n    );\n\n    const nextSnapshot = {\n      ...snapshot,\n      ...(patch || {})\n    };\n\n    if ('context' in snapshot || patch?.context !== undefined) {\n      (nextSnapshot as any).context = patch?.context ?? snapshot.context;\n    }\n    if (patch?.effects || Object.keys(trackedEffects).length) {\n      (nextSnapshot as any).effects = {\n        ...snapshot.effects,\n        ...patch?.effects,\n        ...trackedEffects\n      };\n    }\n\n    return [nextSnapshot, effects];\n  }) as LogicTransition<TContext, TOutput, TEvent, TInput, TEmitted>;\n\n  const logic: LogicActorLogic<TContext, TOutput, TEvent, TInput, TEmitted> = {\n    id: config.id,\n    config,\n    transition,\n    start: (snapshot, actorScope) => {\n      const [nextSnapshot, effects] = transition(\n        snapshot,\n        createInitEvent(snapshot.input) as unknown as TEvent,\n        actorScope\n      );\n      Object.assign(snapshot, nextSnapshot);\n      executeLogicEffects(effects, actorScope);\n    },\n    initialTransition: (input, _) => {\n      const context = resolveContext(config.context, input);\n      const snapshot = {\n        status: 'active' as const,\n        output: undefined,\n        error: undefined,\n        input\n      };\n\n      if (context !== undefined) {\n        (snapshot as any).context = context;\n      }\n\n      return [\n        {\n          ...snapshot\n        } as LogicSnapshot<TContext, TOutput, TInput>,\n        []\n      ];\n    },\n    getInitialSnapshot: (actorScope, input) =>\n      logic.initialTransition(input, actorScope)[0],\n    getPersistedSnapshot: (snapshot) => snapshot,\n    restoreSnapshot: (snapshot: any) => snapshot\n  };\n\n  return logic;\n}\n","import isDevelopment from '#is-development';\nimport type { ActionRecord, SentRecord } from './inspection.ts';\nimport { Mailbox } from './Mailbox.ts';\nimport { XSTATE_STOP } from './constants.ts';\nimport {\n  createDoneActorEvent,\n  createErrorActorEvent,\n  createInitEvent\n} from './eventUtils.ts';\nimport { reportUnhandledError } from './reportUnhandledError.ts';\nimport { symbolObservable } from './symbolObservable.ts';\nimport { AnyActorSystem, Clock, createSystem } from './system.ts';\nimport { executeLogicEffects } from './actors/logic.ts';\n\n// those are needed to make JSDoc `@link` work properly\nimport type {\n  createObservableLogic,\n  createEventObservableLogic\n} from './actors/observable.ts';\nimport type { createCallbackLogic } from './actors/callback.ts';\nimport type { createLogic } from './actors/logic.ts';\nimport type { createAsyncLogic } from './actors/promise.ts';\nimport type { createMachine } from './createMachine.ts';\n\nlet executingCustomAction: boolean = false;\n\nimport type {\n  ActorScope,\n  AnyActor,\n  AnyActorLogic,\n  EmittedFrom,\n  EventFromLogic,\n  SendableEventFromLogic,\n  InputFrom,\n  Snapshot,\n  SnapshotFrom,\n  AnyTransitionDefinition,\n  ExecutableActionObject,\n  Readable\n} from './types.ts';\nimport {\n  ActorOptions,\n  ActorInstance,\n  ActorRef,\n  EventObject,\n  InteropSubscribable,\n  Observer,\n  PendingEffect,\n  Subscription,\n  TimersRestoreStrategy\n} from './types.ts';\nimport { toObserver } from './utils.ts';\n\nexport const $$ACTOR_TYPE = 1;\n\n// those values are currently used by @xstate/react directly so it's important to keep the assigned values in sync\nexport enum ProcessingStatus {\n  NotStarted = 0,\n  Running = 1,\n  Stopped = 2\n}\n\nconst defaultOptions = {\n  clock: {\n    setTimeout: (fn, ms) => {\n      return setTimeout(fn, ms);\n    },\n    clearTimeout: (id) => {\n      return clearTimeout(id);\n    }\n  } as Clock,\n  logger: console.log.bind(console)\n};\n\nfunction isExecutableActionObject(\n  effect: unknown\n): effect is ExecutableActionObject {\n  return (\n    typeof effect === 'object' &&\n    effect !== null &&\n    'args' in effect &&\n    'exec' in effect\n  );\n}\n\nfunction executeExecutableEffects(\n  effects: readonly unknown[] | undefined,\n  actorScope: ActorScope<any, any, any, any>\n): unknown[] {\n  if (!effects?.length) {\n    return [];\n  }\n\n  const logicEffects = [];\n  for (const effect of effects) {\n    if (isExecutableActionObject(effect)) {\n      actorScope.actionExecutor(effect);\n    } else {\n      logicEffects.push(effect);\n    }\n  }\n  return logicEffects;\n}\n\n/**\n * An Actor is a running process that can receive events, send events and change\n * its behavior based on the events it receives, which can cause effects outside\n * of the actor. When you run a state machine, it becomes an actor.\n *\n * An `Actor` is the concrete runtime instance with lifecycle methods and\n * system-owned internals. It also satisfies the narrower `ActorRef` contract,\n * so consumer APIs should accept `ActorRef` when they only need to send events\n * or read snapshots.\n */\nexport class Actor<TLogic extends AnyActorLogic>\n  implements\n    ActorInstance<\n      SnapshotFrom<TLogic>,\n      EventFromLogic<TLogic>,\n      EmittedFrom<TLogic>,\n      SendableEventFromLogic<TLogic>\n    >\n{\n  /** The current internal state of the actor. */\n  private _snapshot!: SnapshotFrom<TLogic>;\n  /**\n   * The clock that is responsible for setting and clearing timeouts, such as\n   * delayed events and transitions.\n   */\n  public clock: Clock;\n  public options: Readonly<ActorOptions<TLogic>>;\n\n  /** The unique identifier for this actor relative to its parent. */\n  public id: string;\n\n  private readonly _boundProcess = this._process.bind(this);\n\n  private mailbox: Mailbox<EventFromLogic<TLogic>> = new Mailbox(\n    this._boundProcess\n  );\n\n  private observers: Set<Observer<SnapshotFrom<TLogic>>> = new Set();\n  private eventListeners: Map<\n    string,\n    Set<(emittedEvent: EmittedFrom<TLogic>) => void>\n  > = new Map();\n  private logger: (...args: any[]) => void;\n\n  /** @internal */\n  public _processingStatus: ProcessingStatus = ProcessingStatus.NotStarted;\n  private _forceDeferredActions = false;\n\n  // Actor Ref\n  public _parent?: AnyActor;\n  /** @internal */\n  public _syncSnapshot?: boolean;\n  public ref: ActorRef<\n    SnapshotFrom<TLogic>,\n    EventFromLogic<TLogic>,\n    EmittedFrom<TLogic>,\n    SendableEventFromLogic<TLogic>\n  >;\n  // TODO: add typings for system\n  private _actorScope: ActorScope<\n    SnapshotFrom<TLogic>,\n    EventFromLogic<TLogic>,\n    AnyActorSystem,\n    EmittedFrom<TLogic>,\n    SendableEventFromLogic<TLogic>\n  >;\n\n  /** @internal */\n  public _lastSourceRef?: AnyActor;\n  /** @internal */\n  public _collectedMicrosteps: AnyTransitionDefinition[] = [] as any;\n  /** @internal Actions executed during the in-flight transition. */\n  public _collectedActions: ActionRecord[] = [];\n  /** @internal Events relayed to other actors during the in-flight transition. */\n  public _collectedSent: SentRecord[] = [];\n  private _initialEffects: unknown[] | undefined;\n  public systemId: string | undefined;\n\n  /** The globally unique process ID for this invocation. */\n  public sessionId: string;\n\n  /** The system to which this actor belongs. */\n  public system: AnyActorSystem;\n\n  public trigger: {\n    [K in SendableEventFromLogic<TLogic>['type']]: {} extends Omit<\n      Extract<SendableEventFromLogic<TLogic>, { type: K }>,\n      'type'\n    >\n      ? () => void\n      : (\n          payload: Omit<\n            Extract<SendableEventFromLogic<TLogic>, { type: K }>,\n            'type'\n          >\n        ) => void;\n  };\n\n  public src: string | AnyActorLogic;\n\n  /**\n   * Creates a new actor instance for the given logic with the provided options,\n   * if any.\n   *\n   * @param logic The logic to create an actor from\n   * @param options Actor options\n   */\n  constructor(\n    public logic: TLogic,\n    options?: ActorOptions<TLogic>\n  ) {\n    const resolvedOptions = {\n      ...defaultOptions,\n      ...options\n    };\n\n    const { clock, logger, parent, syncSnapshot, id, systemId, inspect } =\n      resolvedOptions;\n\n    this.system = parent\n      ? parent.system\n      : createSystem(this, {\n          clock,\n          logger,\n          timers: resolvedOptions.timers\n        });\n\n    if (inspect && !parent) {\n      // Always inspect at the system-level\n      this.system.inspect(toObserver(inspect));\n    }\n\n    this.sessionId = this.system._bookId();\n    this.id = id ?? this.sessionId;\n    this.logger = options?.logger ?? this.system._logger;\n    this.clock = options?.clock ?? this.system._clock;\n    this._parent = parent;\n    this._syncSnapshot = syncSnapshot;\n    this.options = resolvedOptions as ActorOptions<TLogic> &\n      typeof defaultOptions;\n    this.src = resolvedOptions.src ?? logic;\n    this.ref = this;\n    this._actorScope = {\n      self: this,\n      id: this.id,\n      sessionId: this.sessionId,\n      logger: this.logger,\n      defer: (fn) => {\n        this._deferred.push(fn);\n      },\n      system: this.system,\n      stopChild: (child) => {\n        if (child._parent !== this) {\n          throw new Error(\n            `Cannot stop child actor ${child.id} of ${this.id} because it is not a child`\n          );\n        }\n        (child as Actor<AnyActorLogic>)._stop();\n      },\n      emit: (emittedEvent) => {\n        const listeners = this.eventListeners.get(emittedEvent.type);\n        const wildcardListener = this.eventListeners.get('*');\n        if (!listeners && !wildcardListener) {\n          return;\n        }\n        if (listeners) {\n          for (const handler of listeners) {\n            try {\n              handler(emittedEvent);\n            } catch (err) {\n              reportUnhandledError(err);\n            }\n          }\n        }\n        if (!wildcardListener) {\n          return;\n        }\n        for (const handler of wildcardListener) {\n          try {\n            handler(emittedEvent);\n          } catch (err) {\n            reportUnhandledError(err);\n          }\n        }\n      },\n      actionExecutor: (action) => {\n        const exec = () => {\n          // Record every executed action for the '@xstate.transition' inspection\n          // event's `actions[]` facet (replaces the v5 '@xstate.action' event).\n          this._collectedActions.push({\n            type: action.type,\n            params: action.params\n          });\n          if (!action.exec) {\n            return;\n          }\n          const saveExecutingCustomAction = executingCustomAction;\n          try {\n            executingCustomAction = true;\n\n            action.exec();\n          } finally {\n            executingCustomAction = saveExecutingCustomAction;\n          }\n        };\n        if (\n          this._processingStatus === ProcessingStatus.Running &&\n          !this._forceDeferredActions\n        ) {\n          exec();\n        } else {\n          this._deferred.push(exec);\n        }\n      }\n    };\n\n    // Ensure that the send method is bound to this Actor instance\n    // if destructured\n    this.send = this.send.bind(this);\n    this.trigger = new Proxy({} as Actor<TLogic>['trigger'], {\n      get: (_, eventType: string) => {\n        return (payload?: any) => {\n          this.send({ ...payload, type: eventType });\n        };\n      }\n    });\n\n    // unified '@xstate.transition' event replaces '@xstate.actor'\n\n    if (systemId) {\n      this.systemId = systemId;\n      this.system._set(systemId, this);\n    }\n\n    // prepare to collect initial microsteps during initialTransition\n    this._collectedMicrosteps = [] as any;\n    let persistedState = options?.snapshot ?? options?.state;\n    if (\n      persistedState &&\n      typeof persistedState === 'object' &&\n      '_pendingEffects' in persistedState\n    ) {\n      // Pending effects are restored by this actor on `start()`; the logic\n      // only sees the rest of the persisted snapshot.\n      const { _pendingEffects, ...rest } = persistedState as any;\n      this._pendingEffects = _pendingEffects;\n      persistedState = rest;\n    }\n    try {\n      if (persistedState) {\n        this._snapshot = this.logic.restoreSnapshot\n          ? this.logic.restoreSnapshot(persistedState, this._actorScope)\n          : persistedState;\n      } else {\n        const [snapshot, effects] = this.logic.initialTransition(\n          this.options?.input,\n          this._actorScope\n        );\n        this._snapshot = snapshot;\n        this._initialEffects = effects;\n      }\n    } catch (err) {\n      // if we get here then it means that we assign a value to this._snapshot that is not of the correct type\n      // we can't get the true `TSnapshot & { status: 'error'; }`, it's impossible\n      // so right now this is a lie of sorts\n      this._snapshot = {\n        status: 'error',\n        output: undefined,\n        error: err\n      } as any;\n      // discard any functions deferred during the failed initial snapshot\n      // computation so they can't run against an inconsistent actor\n      this._deferred.length = 0;\n    }\n\n    if (systemId && (this._snapshot as any).status !== 'active') {\n      this.system._unregister(this);\n    }\n\n    // Announce actor topology: emitted once for every actor (root and every\n    // spawned/invoked child) so the actor graph can be drawn before any\n    // transitions occur. This is the only place actor identity is announced.\n    this.system._sendInspectionEvent({\n      type: '@xstate.actor',\n      actorRef: this as any,\n      parentRef: this._parent,\n      id: this.id,\n      src: this.src,\n      snapshot: this._snapshot\n    });\n  }\n\n  // array of functions to defer\n  private _deferred: Array<() => void> = [];\n\n  // pending effects (timers) from a persisted snapshot, rescheduled on `start()`\n  private _pendingEffects?: PendingEffect[];\n\n  private _setErrorSnapshot(\n    err: unknown,\n    snapshot: SnapshotFrom<TLogic> = this._snapshot\n  ) {\n    this._snapshot = {\n      ...(snapshot as any),\n      status: 'error',\n      error: err\n    };\n  }\n\n  private _next(snapshot: SnapshotFrom<TLogic>) {\n    for (const observer of this.observers) {\n      try {\n        observer.next?.(snapshot);\n      } catch (err) {\n        reportUnhandledError(err);\n      }\n    }\n  }\n\n  private update(snapshot: SnapshotFrom<TLogic>, event: EventObject): void {\n    // Update state\n    this._snapshot = snapshot;\n\n    // Execute deferred effects\n    for (let i = 0; i < this._deferred.length; i++) {\n      const deferredFn = this._deferred[i];\n      try {\n        deferredFn();\n      } catch (err) {\n        // this error can only be caught when executing *initial* actions\n        // it's the only time when we call actions provided by the user through those deferreds\n        // when the actor is already running we always execute them synchronously while transitioning\n        // no \"builtin deferred\" should actually throw an error since they are either safe\n        // or the control flow is passed through the mailbox and errors should be caught by the `_process` used by the mailbox\n        this._deferred.length = 0;\n        this._setErrorSnapshot(err, snapshot);\n        break;\n      }\n    }\n    this._deferred.length = 0;\n\n    switch ((this._snapshot as any).status) {\n      case 'active':\n        this._next(snapshot);\n        break;\n      case 'done': {\n        // next observers are meant to be notified about done snapshots\n        // this can be seen as something that is different from how observable work\n        // but with observables `complete` callback is called without any arguments\n        // it's more ergonomic for XState to treat a done snapshot as a \"next\" value\n        // and the completion event as something that is separate,\n        // something that merely follows emitting that done snapshot\n        this._next(snapshot);\n\n        this._stopProcedure();\n        this._complete();\n        const doneEvent = createDoneActorEvent(\n          this.id,\n          (this._snapshot as any).output\n        );\n        if (this._parent) {\n          this.system._relay(this, this._parent, doneEvent);\n        }\n\n        break;\n      }\n      case 'error':\n        this._error((this._snapshot as any).error);\n        break;\n    }\n    this.system._sendInspectionEvent({\n      type: '@xstate.transition',\n      actorRef: this as any,\n      event,\n      sourceRef: this._lastSourceRef,\n      targetRef: this as any,\n      snapshot,\n      microsteps: this._collectedMicrosteps as any,\n      actions: this._collectedActions,\n      sent: this._collectedSent,\n      eventType: event.type\n    });\n    // reset facets after emission\n    this._collectedMicrosteps = [] as any;\n    this._collectedActions = [];\n    this._collectedSent = [];\n  }\n\n  private _flushInitialEffects(): boolean {\n    if (!this._initialEffects) {\n      return true;\n    }\n    this._forceDeferredActions = true;\n    try {\n      const logicEffects = executeExecutableEffects(\n        this._initialEffects,\n        this._actorScope\n      );\n      executeLogicEffects(logicEffects, this._actorScope);\n      this._initialEffects = undefined;\n      return true;\n    } catch (err) {\n      this._initialEffects = undefined;\n      this._deferred.length = 0;\n      this._setErrorSnapshot(err);\n      this._error(err);\n      return false;\n    } finally {\n      this._forceDeferredActions = false;\n    }\n  }\n\n  /**\n   * Subscribe an observer to an actor’s snapshot values.\n   *\n   * @remarks\n   * The observer will receive the actor’s snapshot value when it is emitted.\n   * The observer can be:\n   *\n   * - A plain function that receives the latest snapshot, or\n   * - An observer object whose `.next(snapshot)` method receives the latest\n   *   snapshot\n   *\n   * @example\n   *\n   * ```ts\n   * // Observer as a plain function\n   * const subscription = actor.subscribe((snapshot) => {\n   *   console.log(snapshot);\n   * });\n   * ```\n   *\n   * @example\n   *\n   * ```ts\n   * // Observer as an object\n   * const subscription = actor.subscribe({\n   *   next(snapshot) {\n   *     console.log(snapshot);\n   *   },\n   *   error(err) {\n   *     // ...\n   *   },\n   *   complete() {\n   *     // ...\n   *   }\n   * });\n   * ```\n   *\n   * The return value of `actor.subscribe(observer)` is a subscription object\n   * that has an `.unsubscribe()` method. You can call\n   * `subscription.unsubscribe()` to unsubscribe the observer:\n   *\n   * @example\n   *\n   * ```ts\n   * const subscription = actor.subscribe((snapshot) => {\n   *   // ...\n   * });\n   *\n   * // Unsubscribe the observer\n   * subscription.unsubscribe();\n   * ```\n   *\n   * When the actor is stopped, all of its observers will automatically be\n   * unsubscribed.\n   *\n   * @param observer - Either a plain function that receives the latest\n   *   snapshot, or an observer object whose `.next(snapshot)` method receives\n   *   the latest snapshot\n   */\n  public subscribe(observer: Observer<SnapshotFrom<TLogic>>): Subscription;\n  public subscribe(\n    nextListener?: (snapshot: SnapshotFrom<TLogic>) => void,\n    errorListener?: (error: any) => void,\n    completeListener?: () => void\n  ): Subscription;\n  public subscribe(\n    nextListenerOrObserver?:\n      | ((snapshot: SnapshotFrom<TLogic>) => void)\n      | Observer<SnapshotFrom<TLogic>>,\n    errorListener?: (error: any) => void,\n    completeListener?: () => void\n  ): Subscription {\n    const observer = toObserver(\n      nextListenerOrObserver,\n      errorListener,\n      completeListener\n    );\n\n    if (this._processingStatus !== ProcessingStatus.Stopped) {\n      this.observers.add(observer);\n    } else {\n      switch ((this._snapshot as any).status) {\n        case 'done':\n          try {\n            observer.complete?.();\n          } catch (err) {\n            reportUnhandledError(err);\n          }\n          break;\n        case 'error': {\n          const err = (this._snapshot as any).error;\n          if (!observer.error) {\n            reportUnhandledError(err);\n          } else {\n            try {\n              observer.error(err);\n            } catch (err) {\n              reportUnhandledError(err);\n            }\n          }\n          break;\n        }\n      }\n    }\n\n    return {\n      unsubscribe: () => {\n        this.observers.delete(observer);\n      }\n    };\n  }\n\n  public on<TType extends EmittedFrom<TLogic>['type'] | '*'>(\n    type: TType,\n    handler: (\n      emitted: EmittedFrom<TLogic> &\n        (TType extends '*' ? unknown : { type: TType })\n    ) => void\n  ): Subscription {\n    let listeners = this.eventListeners.get(type);\n    if (!listeners) {\n      listeners = new Set();\n      this.eventListeners.set(type, listeners);\n    }\n    listeners.add(handler);\n\n    return {\n      unsubscribe: () => {\n        listeners.delete(handler);\n      }\n    };\n  }\n\n  public select<TSelected>(\n    selector: (snapshot: SnapshotFrom<TLogic>) => TSelected,\n    equalityFn: (a: TSelected, b: TSelected) => boolean = Object.is\n  ): Readable<TSelected> {\n    return {\n      subscribe: (\n        observerOrFn:\n          | Observer<TSelected>\n          | ((value: TSelected) => void)\n          | undefined,\n        errorListener?: (error: any) => void,\n        completeListener?: () => void\n      ) => {\n        const observer = toObserver(\n          observerOrFn,\n          errorListener,\n          completeListener\n        );\n        let selected = selector(this.getSnapshot());\n        return this.subscribe({\n          next: (snapshot) => {\n            const next = selector(snapshot);\n            if (!equalityFn(selected, next)) {\n              selected = next;\n              observer.next?.(next);\n            }\n          },\n          error: observer.error,\n          complete: observer.complete\n        });\n      },\n      get: () => selector(this.getSnapshot())\n    };\n  }\n\n  /** Starts the Actor from the initial state */\n  public start(): this {\n    if (this._processingStatus === ProcessingStatus.Running) {\n      // Do not restart the service if it is already started\n      return this;\n    }\n\n    if (this._syncSnapshot) {\n      this.subscribe({\n        next: (snapshot: Snapshot<unknown>) => {\n          if (snapshot.status === 'active') {\n            this.system._relay(this, this._parent!, {\n              type: `xstate.snapshot.${this.id}`,\n              snapshot\n            });\n          }\n        },\n        error: () => {}\n      });\n    }\n\n    this.system._register(this.sessionId, this);\n    if (this.systemId) {\n      this.system._set(this.systemId, this);\n    }\n    this._processingStatus = ProcessingStatus.Running;\n\n    // TODO: this isn't correct when rehydrating\n    const initEvent = createInitEvent(this.options.input);\n    // remember source of init as parent for unified transition event\n    this._lastSourceRef = this._parent;\n\n    const status = (this._snapshot as any).status;\n\n    switch (status) {\n      case 'done':\n        // a state machine can be \"done\" upon initialization (it could reach a final state using initial microsteps)\n        // we still need to complete observers, flush deferreds etc\n        if (!this._flushInitialEffects()) {\n          return this;\n        }\n        this.update(\n          this._snapshot,\n          initEvent as unknown as EventFromLogic<TLogic>\n        );\n        // TODO: rethink cleanup of observers, mailbox, etc\n        return this;\n      case 'error':\n        this._error((this._snapshot as any).error);\n        return this;\n    }\n\n    if (!this._parent) {\n      this.system.start();\n    }\n\n    if (this.logic.start) {\n      try {\n        this.logic.start(this._snapshot, this._actorScope);\n      } catch (err) {\n        this._setErrorSnapshot(err);\n        this._error(err);\n        return this;\n      }\n    }\n\n    if (!this._flushInitialEffects()) {\n      return this;\n    }\n\n    // TODO: this notifies all subscribers but usually this is redundant\n    // there is no real change happening here\n    // we need to rethink if this needs to be refactored\n    this.update(this._snapshot, initEvent as unknown as EventFromLogic<TLogic>);\n\n    if (this._pendingEffects) {\n      const strategy =\n        this.options.timers ?? this.system._timerStrategy ?? 'resume';\n      for (const effect of this._pendingEffects) {\n        // Re-execute the pending effect with its remaining delay. Only\n        // self-targeted raises exist today; other effect types are ignored.\n        if (effect.type === '@xstate.raise') {\n          this.system.scheduler.schedule(\n            this,\n            this,\n            effect.event,\n            resolveRestoredTimerDelay(strategy, effect),\n            effect.id\n          );\n        }\n      }\n      this._pendingEffects = undefined;\n    }\n\n    this.mailbox.start();\n\n    return this;\n  }\n\n  private _process(event: EventFromLogic<TLogic>) {\n    let nextState: any;\n    let caughtError;\n    try {\n      nextState = this.logic.transition(\n        this._snapshot,\n        event,\n        this._actorScope\n      );\n    } catch (err) {\n      // we wrap it in a box so we can rethrow it later even if falsy value gets caught here\n      caughtError = { err };\n    }\n\n    if (caughtError) {\n      const { err } = caughtError;\n\n      this._setErrorSnapshot(err);\n      this._error(err);\n      return;\n    }\n\n    try {\n      const [snapshot, effects] = nextState;\n      const logicEffects = executeExecutableEffects(effects, this._actorScope);\n      this.update(snapshot, event);\n      executeLogicEffects(logicEffects, this._actorScope);\n    } catch (err) {\n      this._setErrorSnapshot(err);\n      this._error(err);\n      return;\n    }\n\n    if (event.type === XSTATE_STOP) {\n      this._stopProcedure();\n      this._complete();\n    }\n  }\n\n  /** @internal */\n  public _stop(): this {\n    if (this._processingStatus === ProcessingStatus.Stopped) {\n      return this;\n    }\n    this.mailbox.clear();\n    if (this._processingStatus === ProcessingStatus.NotStarted) {\n      this._processingStatus = ProcessingStatus.Stopped;\n      return this;\n    }\n    this.mailbox.enqueue({ type: XSTATE_STOP } as any);\n    this.system._unregister(this);\n\n    return this;\n  }\n\n  /** Stops the Actor and unsubscribe all listeners. */\n  public stop(): this {\n    if (this._parent) {\n      throw new Error('A non-root actor cannot be stopped directly.');\n    }\n    return this._stop();\n  }\n  private _complete(): void {\n    for (const observer of this.observers) {\n      try {\n        observer.complete?.();\n      } catch (err) {\n        reportUnhandledError(err);\n      }\n    }\n    this.observers.clear();\n    this.eventListeners.clear();\n  }\n\n  private _error(err: unknown): void {\n    this._stopProcedure();\n    if (!this.observers.size) {\n      if (!this._parent) {\n        reportUnhandledError(err);\n      }\n      this.eventListeners.clear();\n    } else {\n      let reportError = false;\n\n      for (const observer of this.observers) {\n        const errorListener = observer.error;\n        reportError ||= !errorListener;\n        try {\n          errorListener?.(err);\n        } catch (err2) {\n          reportUnhandledError(err2);\n        }\n      }\n      this.observers.clear();\n      this.eventListeners.clear();\n      if (reportError) {\n        reportUnhandledError(err);\n      }\n    }\n\n    if (this._parent) {\n      this.system._relay(\n        this,\n        this._parent,\n        createErrorActorEvent(this.id, err)\n      );\n    }\n  }\n  // TODO: atm children don't belong entirely to the actor so\n  // in a way - it's not even super aware of them\n  // so we can't stop them from here but we really should!\n  // right now, they are being stopped within the machine's transition\n  // but that could throw and leave us with \"orphaned\" active actors\n  private _stopProcedure(): void {\n    if (this._processingStatus !== ProcessingStatus.Running) {\n      // Actor already stopped; do nothing\n      return;\n    }\n\n    // Cancel all delayed events\n    this.system.scheduler.cancelAll(this);\n\n    // TODO: mailbox.reset\n    this.mailbox.clear();\n    // TODO: after `stop` we must prepare ourselves for receiving events again\n    // events sent *after* stop signal must be queued\n    // it seems like this should be the common behavior for all of our consumers\n    // so perhaps this should be unified somehow for all of them\n    this.mailbox = new Mailbox(this._boundProcess);\n\n    this._processingStatus = ProcessingStatus.Stopped;\n    this.system._unregister(this);\n  }\n\n  /** @internal */\n  public _send(event: EventFromLogic<TLogic>) {\n    if (this._processingStatus === ProcessingStatus.Stopped) {\n      // do nothing\n      if (isDevelopment) {\n        // TODO: circular serialization issues\n        // const eventString = ''; //JSON.stringify(event);\n\n        console.warn(\n          `Event \"${event.type}\" was sent to stopped actor \"${this.id} (${this.sessionId})\". This actor has already reached its final state, and will not transition.`\n        );\n      }\n      return;\n    }\n\n    this.mailbox.enqueue(event);\n  }\n\n  /**\n   * Sends an event to the running Actor to trigger a transition.\n   *\n   * @param event The event to send\n   */\n  public send(event: SendableEventFromLogic<TLogic>) {\n    if (isDevelopment && typeof event === 'string') {\n      throw new Error(\n        `Only event objects may be sent to actors; use .send({ type: \"${event}\" }) instead`\n      );\n    }\n    this.system._relay(undefined, this, event);\n  }\n\n  public toJSON() {\n    return {\n      xstate$$type: $$ACTOR_TYPE,\n      id: this.id\n    };\n  }\n\n  /**\n   * Obtain the internal state of the actor, which can be persisted.\n   *\n   * @remarks\n   * The internal state can be persisted from any actor, not only machines.\n   *\n   * Note that the persisted state is not the same as the snapshot from\n   * {@link Actor.getSnapshot}. Persisted state represents the internal state of\n   * the actor, while snapshots represent the actor's last emitted value.\n   *\n   * Can be restored with {@link ActorOptions.state}\n   * @see https://stately.ai/docs/persistence\n   */\n  public getPersistedSnapshot(): Snapshot<unknown>;\n  public getPersistedSnapshot(options?: unknown): Snapshot<unknown> {\n    const persisted = this.logic.getPersistedSnapshot(this._snapshot, options);\n\n    // Capture this actor's pending self-targeted effects (delayed\n    // events/transitions) as serialized action descriptors plus their\n    // runtime progress, so they can be restored on `start()`.\n    const scheduledEvents = this.system._snapshot._scheduledEvents;\n    let pendingEffects: PendingEffect[] | undefined;\n    const now = Date.now();\n    for (const key in scheduledEvents) {\n      const scheduled = scheduledEvents[key as keyof typeof scheduledEvents];\n      if (scheduled.source === this && scheduled.target === this) {\n        (pendingEffects ??= []).push({\n          type: '@xstate.raise',\n          event: scheduled.event,\n          id: scheduled.id,\n          delay: scheduled.delay,\n          startedAt: scheduled.startedAt,\n          elapsed: Math.max(0, now - scheduled.startedAt)\n        });\n      }\n    }\n\n    // If this actor was restored but not yet started, its pending effects\n    // are not in the scheduler yet — carry them through as-is.\n    pendingEffects ??= this._pendingEffects;\n\n    return pendingEffects\n      ? ({\n          ...(persisted as any),\n          _pendingEffects: pendingEffects\n        } as Snapshot<unknown>)\n      : persisted;\n  }\n\n  public [symbolObservable](): InteropSubscribable<SnapshotFrom<TLogic>> {\n    return this;\n  }\n\n  /**\n   * Read an actor’s snapshot synchronously.\n   *\n   * @remarks\n   * The snapshot represent an actor's last emitted value.\n   *\n   * When an actor receives an event, its internal state may change. An actor\n   * may emit a snapshot when a state transition occurs.\n   *\n   * Note that some actors, such as callback actors generated with\n   * `createCallbackLogic`, will not emit snapshots.\n   * @see {@link Actor.subscribe} to subscribe to an actor’s snapshot values.\n   * @see {@link Actor.getPersistedSnapshot} to persist the internal state of an actor (which is more than just a snapshot).\n   */\n  public getSnapshot(): SnapshotFrom<TLogic> {\n    if (isDevelopment && !this._snapshot) {\n      throw new Error(\n        `Snapshot can't be read while the actor initializes itself`\n      );\n    }\n    return this._snapshot;\n  }\n}\n\nfunction resolveRestoredTimerDelay(\n  strategy: TimersRestoreStrategy,\n  effect: PendingEffect\n): number {\n  if (typeof strategy === 'function') {\n    return strategy(effect);\n  }\n  switch (strategy) {\n    case 'restart':\n      return effect.delay;\n    case 'absolute':\n      return Math.max(0, effect.startedAt + effect.delay - Date.now());\n    case 'resume':\n    default:\n      return Math.max(0, effect.delay - effect.elapsed);\n  }\n}\n\nexport type RequiredActorOptionsKeys<TLogic extends AnyActorLogic> =\n  undefined extends InputFrom<TLogic> ? never : 'input';\n\n/**\n * Creates a new actor instance for the given actor logic with the provided\n * options, if any.\n *\n * @remarks\n * When you create an actor from actor logic via `createActor(logic)`, you\n * implicitly create an actor system where the created actor is the root actor.\n * Any actors spawned from this root actor and its descendants are part of that\n * actor system.\n * @example\n *\n * ```ts\n * import { createActor } from 'xstate';\n * import { someActorLogic } from './someActorLogic.ts';\n *\n * // Creating the actor, which implicitly creates an actor system with itself as the root actor\n * const actor = createActor(someActorLogic);\n *\n * actor.subscribe((snapshot) => {\n *   console.log(snapshot);\n * });\n *\n * // Actors must be started by calling `actor.start()`, which will also start the actor system.\n * actor.start();\n *\n * // Actors can receive events\n * actor.send({ type: 'someEvent' });\n *\n * // You can stop root actors by calling `actor.stop()`, which will also stop the actor system and all actors in that system.\n * actor.stop();\n * ```\n *\n * @param logic - The actor logic to create an actor from. For a state machine\n *   actor logic creator, see {@link createMachine}. Other actor logic creators\n *   include {@link createCallbackLogic}, {@link createEventObservableLogic},\n *   {@link createObservableLogic}, {@link createLogic}, and\n *   {@link createAsyncLogic}.\n * @param options - Actor options\n */\nexport function createActor<TLogic extends AnyActorLogic>(\n  logic: TLogic,\n  options?: ActorOptions<TLogic> & {\n    [K in RequiredActorOptionsKeys<TLogic>]: unknown;\n  }\n): Actor<TLogic> {\n  return new Actor(logic, options);\n}\n","import { AnyActorSystem } from '../system.ts';\nimport {\n  ActorLogic,\n  ActorRefFromLogic,\n  AnyActorRef,\n  AnyEventObject,\n  EventObject,\n  NonReducibleUnknown,\n  Snapshot\n} from '../types';\nimport { StandardSchemaV1 } from '../schema.types.ts';\nimport { createLogic as createBaseLogic } from './logic.ts';\n\ninterface CallbackInstanceState<TEvent extends EventObject> {\n  receivers: Set<(e: TEvent) => void> | undefined;\n  dispose: (() => void) | void;\n}\n\nconst instanceStates = /* #__PURE__ */ new WeakMap<\n  AnyActorRef,\n  CallbackInstanceState<any>\n>();\n\nexport type CallbackSnapshot<TInput> = Snapshot<undefined> & {\n  input: TInput;\n  effects?: Record<\n    string,\n    | { status: 'active' }\n    | { status: 'done'; output?: unknown }\n    | { status: 'error'; error: unknown }\n  >;\n};\n\nexport type CallbackActorLogic<\n  TEvent extends EventObject,\n  TInput = NonReducibleUnknown,\n  TEmitted extends EventObject = EventObject\n> = ActorLogic<\n  CallbackSnapshot<TInput>,\n  TEvent,\n  TInput,\n  AnyActorSystem,\n  TEmitted\n>;\n\n/**\n * Represents an actor created by `createCallbackLogic`.\n *\n * The type of `self` within the actor's logic.\n *\n * @example\n *\n * ```ts\n * import { createCallbackLogic, createActor } from 'xstate';\n *\n * // The events the actor receives.\n * type Event = { type: 'someEvent' };\n * // The actor's input.\n * type Input = { name: string };\n *\n * // Actor logic that logs whenever it receives an event of type `someEvent`.\n * const logic = createCallbackLogic<Event, Input>(\n *   ({ self, input, receive }) => {\n *     self;\n *     // ^? CallbackActorRef<Event, Input>\n *\n *     receive((event) => {\n *       if (event.type === 'someEvent') {\n *         console.log(`${input.name}: received \"someEvent\" event`);\n *         // logs 'myActor: received \"someEvent\" event'\n *       }\n *     });\n *   }\n * );\n *\n * const actor = createActor(logic, { input: { name: 'myActor' } });\n * //    ^? CallbackActorRef<Event, Input>\n * ```\n *\n * @see {@link createCallbackLogic}\n */\nexport type CallbackActorRef<\n  TEvent extends EventObject,\n  TInput = NonReducibleUnknown\n> = ActorRefFromLogic<CallbackActorLogic<TEvent, TInput>>;\n\ntype Receiver<TEvent extends EventObject> = (\n  listener: {\n    bivarianceHack(event: TEvent): void;\n  }['bivarianceHack']\n) => void;\n\nexport type CallbackLogicFunction<\n  TEvent extends EventObject = AnyEventObject,\n  TSentEvent extends EventObject = AnyEventObject,\n  TInput = NonReducibleUnknown,\n  TEmitted extends EventObject = EventObject\n> = ({\n  input,\n  system,\n  self,\n  sendBack,\n  receive,\n  emit\n}: {\n  /**\n   * Data that was provided to the callback actor\n   *\n   * @see {@link https://stately.ai/docs/input | Input docs}\n   */\n  input: TInput;\n  /** The actor system to which the callback actor belongs */\n  system: AnyActorSystem;\n  /** The parent actor of the callback actor */\n  self: CallbackActorRef<TEvent>;\n  /** A function that can send events back to the parent actor */\n  sendBack: (event: TSentEvent) => void;\n  /**\n   * A function that can be called with a listener function argument; the\n   * listener is then called whenever events are received by the callback actor\n   */\n  receive: Receiver<TEvent>;\n  emit: (emitted: TEmitted) => void;\n}) => (() => void) | void;\n\nexport interface CallbackLogicConfig<\n  TEvent extends EventObject = AnyEventObject,\n  TSentEvent extends EventObject = AnyEventObject,\n  TInput = NonReducibleUnknown,\n  TEmitted extends EventObject = EventObject,\n  TInputSchema extends StandardSchemaV1 = StandardSchemaV1\n> {\n  schemas?: {\n    input?: TInputSchema;\n  };\n  run: CallbackLogicFunction<TEvent, TSentEvent, TInput, TEmitted>;\n}\n\n/**\n * An actor logic creator which returns callback logic as defined by a callback\n * function.\n *\n * @remarks\n * Useful for subscription-based or other free-form logic that can send events\n * back to the parent actor.\n *\n * Actors created from callback logic (“callback actors”) can:\n *\n * - Receive events via the `receive` function\n * - Send events to the parent actor via the `sendBack` function\n *\n * Callback actors are a bit different from other actors in that they:\n *\n * - Do not work with `onDone`\n * - Do not produce a snapshot using `.getSnapshot()`\n * - Do not emit values when used with `.subscribe()`\n * - Can not be stopped with `.stop()`\n *\n * @example\n *\n * ```typescript\n * const callbackLogic = createCallbackLogic(({ sendBack, receive }) => {\n *   let lockStatus = 'unlocked';\n *\n *   const handler = (event) => {\n *     if (lockStatus === 'locked') {\n *       return;\n *     }\n *     sendBack(event);\n *   };\n *\n *   receive((event) => {\n *     if (event.type === 'lock') {\n *       lockStatus = 'locked';\n *     } else if (event.type === 'unlock') {\n *       lockStatus = 'unlocked';\n *     }\n *   });\n *\n *   document.body.addEventListener('click', handler);\n *\n *   return () => {\n *     document.body.removeEventListener('click', handler);\n *   };\n * });\n * ```\n *\n * @param callback - The callback function used to describe the callback logic\n *   The callback function is passed an object with the following properties:\n *\n *   - `receive` - A function that can send events back to the parent actor; the\n *       listener is then called whenever events are received by the callback\n *       actor\n *   - `sendBack` - A function that can send events back to the parent actor\n *   - `input` - Data that was provided to the callback actor\n *   - `self` - The parent actor of the callback actor\n *   - `system` - The actor system to which the callback actor belongs The callback\n *       function can (optionally) return a cleanup function, which is called\n *       when the actor is stopped.\n *\n * @returns Callback logic\n * @see {@link CallbackLogicFunction} for more information about the callback function and its object argument\n * @see {@link https://stately.ai/docs/input | Input docs} for more information about how input is passed\n */\nexport function createCallbackLogic<\n  TEvent extends EventObject,\n  const TInputSchema extends StandardSchemaV1,\n  TEmitted extends EventObject = EventObject\n>(\n  config: CallbackLogicConfig<\n    TEvent,\n    AnyEventObject,\n    StandardSchemaV1.InferOutput<TInputSchema>,\n    TEmitted,\n    TInputSchema\n  > & {\n    schemas: {\n      input: TInputSchema;\n    };\n  }\n): CallbackActorLogic<\n  TEvent,\n  StandardSchemaV1.InferOutput<TInputSchema>,\n  TEmitted\n>;\nexport function createCallbackLogic<\n  TEvent extends EventObject,\n  TInput = NonReducibleUnknown,\n  TEmitted extends EventObject = EventObject\n>(\n  config: CallbackLogicConfig<TEvent, AnyEventObject, TInput, TEmitted> & {\n    schemas?: undefined;\n  }\n): CallbackActorLogic<TEvent, TInput, TEmitted>;\nexport function createCallbackLogic<\n  TEvent extends EventObject,\n  TInput = NonReducibleUnknown,\n  TEmitted extends EventObject = EventObject\n>(\n  callback: CallbackLogicFunction<TEvent, AnyEventObject, TInput, TEmitted>\n): CallbackActorLogic<TEvent, TInput, TEmitted>;\nexport function createCallbackLogic<\n  TEvent extends EventObject,\n  TInput = NonReducibleUnknown,\n  TEmitted extends EventObject = EventObject\n>(\n  callbackOrConfig:\n    | CallbackLogicFunction<TEvent, AnyEventObject, TInput, TEmitted>\n    | CallbackLogicConfig<TEvent, AnyEventObject, TInput, TEmitted>\n): CallbackActorLogic<TEvent, TInput, TEmitted> {\n  const callback =\n    typeof callbackOrConfig === 'function'\n      ? callbackOrConfig\n      : callbackOrConfig.run;\n  const schemas =\n    typeof callbackOrConfig === 'function'\n      ? undefined\n      : callbackOrConfig.schemas;\n\n  return createBaseLogic<undefined, undefined, TEvent, TInput, TEmitted>({\n    schemas,\n    context: undefined,\n    run: (args, enq) => {\n      const { event, input, self, system } = args;\n      const emit = (args as any).emit as (emitted: TEmitted) => void;\n      const callbackState = instanceStates.get(self as any);\n      callbackState?.receivers?.forEach((receiver) => receiver(event));\n\n      enq.effect('callback', () => {\n        const callbackState: CallbackInstanceState<TEvent> = {\n          receivers: undefined,\n          dispose: undefined\n        };\n\n        instanceStates.set(self as any, callbackState);\n\n        callbackState.dispose = callback({\n          input,\n          system,\n          self: self as any,\n          sendBack: (event) => {\n            if (self.getSnapshot().status === 'stopped') {\n              return;\n            }\n            const parent = (self as any)._parent;\n            if (parent) {\n              system._relay(self as any, parent, event);\n            }\n          },\n          receive: (listener) => {\n            callbackState.receivers ??= new Set();\n            callbackState.receivers.add(listener);\n          },\n          emit: emit as (emitted: TEmitted) => void\n        });\n\n        return () => {\n          instanceStates.delete(self as any);\n          callbackState.receivers?.clear();\n          callbackState.dispose?.();\n        };\n      });\n    }\n  }) as unknown as CallbackActorLogic<TEvent, TInput, TEmitted>;\n}\n","import { XSTATE_STOP } from '../constants';\nimport { StandardSchemaV1 } from '../schema.types.ts';\nimport { AnyActorSystem } from '../system.ts';\nimport {\n  ActorLogic,\n  ActorFromLogic,\n  ActorRefFromLogic,\n  AnyActor,\n  EventObject,\n  NonReducibleUnknown,\n  Snapshot,\n  Subscribable,\n  Subscription\n} from '../types';\nimport { createLogic as createBaseLogic } from './logic.ts';\n\nconst XSTATE_OBSERVABLE_NEXT = 'xstate.observable.next';\nconst XSTATE_OBSERVABLE_ERROR = 'xstate.observable.error';\nconst XSTATE_OBSERVABLE_COMPLETE = 'xstate.observable.complete';\n\nexport type ObservableSnapshot<\n  TContext,\n  TInput extends NonReducibleUnknown\n> = Snapshot<undefined> & {\n  context: TContext | undefined;\n  input: TInput | undefined;\n  effects?: Record<\n    string,\n    | { status: 'active' }\n    | { status: 'done'; output?: unknown }\n    | { status: 'error'; error: unknown }\n  >;\n  _subscription: Subscription | undefined;\n};\n\nexport type ObservableActorLogic<\n  TContext,\n  TInput extends NonReducibleUnknown,\n  TEmitted extends EventObject = EventObject\n> = ActorLogic<\n  ObservableSnapshot<TContext, TInput>,\n  { type: string; [k: string]: unknown },\n  TInput,\n  AnyActorSystem,\n  TEmitted\n>;\n\n/**\n * Represents an actor created by `createObservableLogic` or\n * `createEventObservableLogic`.\n *\n * The type of `self` within the actor's logic.\n *\n * @example\n *\n * ```ts\n * import { createObservableLogic, createActor } from 'xstate';\n * import { interval } from 'rxjs';\n *\n * // The type of the value observed by the actor's logic.\n * type Context = number;\n * // The actor's input.\n * type Input = { period?: number };\n *\n * // Actor logic that observes a number incremented every `input.period`\n * // milliseconds (default: 1_000).\n * const logic = createObservableLogic<Context, Input>(\n *   ({ input, self }) => {\n *     self;\n *     // ^? ObservableActor<Event, Input>\n *\n *     return interval(input.period ?? 1_000);\n *   }\n * );\n *\n * const actor = createActor(logic, { input: { period: 2_000 } });\n * //    ^? ObservableActor<Event, Input>\n * ```\n *\n * @see {@link createObservableLogic}\n * @see {@link createEventObservableLogic}\n */\nexport type ObservableActorRef<TContext> = ActorRefFromLogic<\n  ObservableActorLogic<TContext, any>\n>;\n\ntype ObservableActor<\n  TContext,\n  TInput extends NonReducibleUnknown = any,\n  TEmitted extends EventObject = EventObject\n> = ActorFromLogic<ObservableActorLogic<TContext, TInput, TEmitted>>;\n\nexport type ObservableLogicFunction<\n  TContext,\n  TInput extends NonReducibleUnknown,\n  TEmitted extends EventObject = EventObject\n> = ({\n  input,\n  system,\n  self,\n  emit\n}: {\n  input: TInput;\n  system: AnyActorSystem;\n  self: ObservableActor<TContext, TInput, TEmitted>;\n  emit: (emitted: TEmitted) => void;\n}) => Subscribable<TContext>;\n\nexport interface ObservableLogicConfig<\n  TContext,\n  TInput extends NonReducibleUnknown,\n  TEmitted extends EventObject = EventObject,\n  TInputSchema extends StandardSchemaV1 = StandardSchemaV1\n> {\n  schemas?: {\n    input?: TInputSchema;\n  };\n  run: ObservableLogicFunction<TContext, TInput, TEmitted>;\n}\n\nexport type EventObservableLogicFunction<\n  TEvent extends EventObject,\n  TInput extends NonReducibleUnknown,\n  TEmitted extends EventObject = EventObject\n> = ({\n  input,\n  system,\n  self,\n  emit\n}: {\n  input: TInput;\n  system: AnyActorSystem;\n  self: ObservableActor<TEvent, TInput, TEmitted>;\n  emit: (emitted: TEmitted) => void;\n}) => Subscribable<TEvent>;\n\nexport interface EventObservableLogicConfig<\n  TEvent extends EventObject,\n  TInput extends NonReducibleUnknown,\n  TEmitted extends EventObject = EventObject,\n  TInputSchema extends StandardSchemaV1 = StandardSchemaV1\n> {\n  schemas?: {\n    input?: TInputSchema;\n  };\n  run: EventObservableLogicFunction<TEvent, TInput, TEmitted>;\n}\n\n/**\n * Observable actor logic is described by an observable stream of values. Actors\n * created from observable logic (“observable actors”) can:\n *\n * - Emit snapshots of the observable’s emitted value\n *\n * The observable’s emitted value is used as its observable actor’s `context`.\n *\n * Sending events to observable actors will have no effect.\n *\n * @example\n *\n * ```ts\n * import { createObservableLogic, createActor } from 'xstate';\n * import { interval } from 'rxjs';\n *\n * const logic = createObservableLogic((obj) => interval(1000));\n *\n * const actor = createActor(logic);\n *\n * actor.subscribe((snapshot) => {\n *   console.log(snapshot.context);\n * });\n *\n * actor.start();\n * // At every second:\n * // Logs 0\n * // Logs 1\n * // Logs 2\n * // ...\n * ```\n *\n * @param observableCreator A function that creates an observable. It receives\n *   one argument, an object with the following properties:\n *\n *   - `input` - Data that was provided to the observable actor\n *   - `self` - The parent actor\n *   - `system` - The actor system to which the observable actor belongs\n *\n *   It should return a {@link Subscribable}, which is compatible with an RxJS\n *   Observable, although RxJS is not required to create them.\n * @see {@link https://rxjs.dev} for documentation on RxJS Observable and observable creators.\n * @see {@link Subscribable} interface in XState, which is based on and compatible with RxJS Observable.\n */\nexport function createObservableLogic<\n  TContext,\n  const TInputSchema extends StandardSchemaV1,\n  TEmitted extends EventObject = EventObject\n>(\n  config: ObservableLogicConfig<\n    TContext,\n    StandardSchemaV1.InferOutput<TInputSchema>,\n    TEmitted,\n    TInputSchema\n  > & {\n    schemas: {\n      input: TInputSchema;\n    };\n  }\n): ObservableActorLogic<\n  TContext,\n  StandardSchemaV1.InferOutput<TInputSchema>,\n  TEmitted\n>;\nexport function createObservableLogic<\n  TContext,\n  TInput extends NonReducibleUnknown,\n  TEmitted extends EventObject = EventObject\n>(\n  config: ObservableLogicConfig<TContext, TInput, TEmitted> & {\n    schemas?: undefined;\n  }\n): ObservableActorLogic<TContext, TInput, TEmitted>;\nexport function createObservableLogic<\n  TContext,\n  TInput extends NonReducibleUnknown,\n  TEmitted extends EventObject = EventObject\n>(\n  observableCreator: ObservableLogicFunction<TContext, TInput, TEmitted>\n): ObservableActorLogic<TContext, TInput, TEmitted>;\nexport function createObservableLogic<\n  TContext,\n  TInput extends NonReducibleUnknown,\n  TEmitted extends EventObject = EventObject\n>(\n  observableCreatorOrConfig:\n    | ObservableLogicFunction<TContext, TInput, TEmitted>\n    | ObservableLogicConfig<TContext, TInput, TEmitted>\n): ObservableActorLogic<TContext, TInput, TEmitted> {\n  const observableCreator =\n    typeof observableCreatorOrConfig === 'function'\n      ? observableCreatorOrConfig\n      : observableCreatorOrConfig.run;\n  const schemas =\n    typeof observableCreatorOrConfig === 'function'\n      ? undefined\n      : observableCreatorOrConfig.schemas;\n\n  return createBaseLogic<\n    TContext | undefined,\n    undefined,\n    { type: string; [k: string]: unknown },\n    TInput,\n    TEmitted\n  >({\n    schemas,\n    context: undefined,\n    run: (args, enq) => {\n      const { event, input, self, system } = args;\n      const emit = (args as any).emit as (emitted: TEmitted) => void;\n      switch (event.type) {\n        case XSTATE_OBSERVABLE_NEXT: {\n          return {\n            context: event.data as TContext\n          };\n        }\n        case XSTATE_OBSERVABLE_ERROR:\n          return {\n            status: 'error',\n            error: (event as any).data,\n            input: undefined as TInput | undefined,\n            effects: {\n              observable: { status: 'error', error: (event as any).data }\n            }\n          };\n        case XSTATE_OBSERVABLE_COMPLETE:\n          return {\n            status: 'done',\n            input: undefined as TInput | undefined,\n            effects: {\n              observable: { status: 'done' }\n            }\n          };\n      }\n\n      enq.effect('observable', () => {\n        const actorSelf = self as unknown as AnyActor;\n        const subscription = observableCreator({\n          input,\n          system,\n          self: self as any,\n          emit: emit as (emitted: TEmitted) => void\n        }).subscribe({\n          next: (value) => {\n            system._relay(actorSelf, actorSelf, {\n              type: XSTATE_OBSERVABLE_NEXT,\n              data: value\n            });\n          },\n          error: (err) => {\n            system._relay(actorSelf, actorSelf, {\n              type: XSTATE_OBSERVABLE_ERROR,\n              data: err\n            });\n          },\n          complete: () => {\n            system._relay(actorSelf, actorSelf, {\n              type: XSTATE_OBSERVABLE_COMPLETE\n            });\n          }\n        });\n\n        return () => subscription.unsubscribe();\n      });\n    }\n  }) as unknown as ObservableActorLogic<TContext, TInput, TEmitted>;\n}\n\n/**\n * Creates event observable logic that listens to an observable that delivers\n * event objects.\n *\n * Event observable actor logic is described by an observable stream of\n * {@link https://stately.ai/docs/transitions#event-objects | event objects}.\n * Actors created from event observable logic (“event observable actors”) can:\n *\n * - Implicitly send events to its parent actor\n * - Emit snapshots of its emitted event objects\n *\n * Sending events to event observable actors will have no effect.\n *\n * @example\n *\n * ```ts\n * import {\n *   createEventObservableLogic,\n *   Subscribable,\n *   EventObject,\n *   createMachine,\n *   createActor\n * } from 'xstate';\n * import { fromEvent } from 'rxjs';\n *\n * const mouseClickLogic = createEventObservableLogic(\n *   () => fromEvent(document.body, 'click') as Subscribable<EventObject>\n * );\n *\n * const canvasMachine = createMachine({\n *   invoke: {\n *     // Will send mouse `click` events to the canvas actor\n *     src: mouseClickLogic\n *   }\n * });\n *\n * const canvasActor = createActor(canvasMachine);\n * canvasActor.start();\n * ```\n *\n * @param lazyObservable A function that creates an observable that delivers\n *   event objects. It receives one argument, an object with the following\n *   properties:\n *\n *   - `input` - Data that was provided to the event observable actor\n *   - `self` - The parent actor\n *   - `system` - The actor system to which the event observable actor belongs.\n *\n *   It should return a {@link Subscribable}, which is compatible with an RxJS\n *   Observable, although RxJS is not required to create them.\n */\nexport function createEventObservableLogic<\n  TEvent extends EventObject,\n  const TInputSchema extends StandardSchemaV1,\n  TEmitted extends EventObject = EventObject\n>(\n  config: EventObservableLogicConfig<\n    TEvent,\n    StandardSchemaV1.InferOutput<TInputSchema>,\n    TEmitted,\n    TInputSchema\n  > & {\n    schemas: {\n      input: TInputSchema;\n    };\n  }\n): ObservableActorLogic<\n  TEvent,\n  StandardSchemaV1.InferOutput<TInputSchema>,\n  TEmitted\n>;\nexport function createEventObservableLogic<\n  TEvent extends EventObject,\n  TInput extends NonReducibleUnknown,\n  TEmitted extends EventObject = EventObject\n>(\n  config: EventObservableLogicConfig<TEvent, TInput, TEmitted> & {\n    schemas?: undefined;\n  }\n): ObservableActorLogic<TEvent, TInput, TEmitted>;\nexport function createEventObservableLogic<\n  TEvent extends EventObject,\n  TInput extends NonReducibleUnknown,\n  TEmitted extends EventObject = EventObject\n>(\n  lazyObservable: EventObservableLogicFunction<TEvent, TInput, TEmitted>\n): ObservableActorLogic<TEvent, TInput, TEmitted>;\nexport function createEventObservableLogic<\n  TEvent extends EventObject,\n  TInput extends NonReducibleUnknown,\n  TEmitted extends EventObject = EventObject\n>(\n  lazyObservableOrConfig:\n    | EventObservableLogicFunction<TEvent, TInput, TEmitted>\n    | EventObservableLogicConfig<TEvent, TInput, TEmitted>\n): ObservableActorLogic<TEvent, TInput, TEmitted> {\n  const lazyObservable =\n    typeof lazyObservableOrConfig === 'function'\n      ? lazyObservableOrConfig\n      : lazyObservableOrConfig.run;\n\n  // TODO: event types\n  const logic: ObservableActorLogic<TEvent, TInput, TEmitted> = {\n    config: lazyObservable,\n    transition: (state, event) => {\n      if (state.status !== 'active') {\n        return [state, []];\n      }\n\n      switch (event.type) {\n        case XSTATE_OBSERVABLE_ERROR:\n          return [\n            {\n              ...state,\n              status: 'error',\n              error: (event as any).data,\n              input: undefined,\n              _subscription: undefined\n            },\n            []\n          ];\n        case XSTATE_OBSERVABLE_COMPLETE:\n          return [\n            {\n              ...state,\n              status: 'done',\n              input: undefined,\n              _subscription: undefined\n            },\n            []\n          ];\n        case XSTATE_STOP:\n          state._subscription!.unsubscribe();\n          return [\n            {\n              ...state,\n              status: 'stopped',\n              input: undefined,\n              _subscription: undefined\n            },\n            []\n          ];\n        default:\n          return [state, []];\n      }\n    },\n    initialTransition: (input, _) => [\n      {\n        status: 'active',\n        output: undefined,\n        error: undefined,\n        context: undefined,\n        input,\n        _subscription: undefined\n      },\n      []\n    ],\n    getInitialSnapshot: (actorScope, input) =>\n      logic.initialTransition(input, actorScope)[0],\n    start: (state, { self, system, emit }) => {\n      if (state.status === 'done') {\n        // Do not restart a completed observable\n        return;\n      }\n\n      state._subscription = lazyObservable({\n        input: state.input!,\n        system,\n        self,\n        emit\n      }).subscribe({\n        next: (value) => {\n          if (self._parent) {\n            system._relay(self, self._parent, value);\n          }\n        },\n        error: (err) => {\n          system._relay(self, self, {\n            type: XSTATE_OBSERVABLE_ERROR,\n            data: err\n          });\n        },\n        complete: () => {\n          system._relay(self, self, { type: XSTATE_OBSERVABLE_COMPLETE });\n        }\n      });\n    },\n    getPersistedSnapshot: ({ _subscription, ...snapshot }) => snapshot,\n    restoreSnapshot: (snapshot: any) => ({\n      ...snapshot,\n      _subscription: undefined\n    })\n  };\n\n  return logic;\n}\n","import { parseDelayToMilliseconds } from '../delay.ts';\nimport { XSTATE_INIT } from '../constants.ts';\nimport { StandardSchemaV1 } from '../schema.types.ts';\nimport { AnyActorSystem } from '../system.ts';\nimport {\n  ActorLogic,\n  ActorFromLogic,\n  ActorRefFromLogic,\n  AnyActor,\n  EventObject,\n  NonReducibleUnknown,\n  Snapshot\n} from '../types.ts';\nimport {\n  XSTATE_LOGIC_EFFECT_REJECT,\n  XSTATE_LOGIC_EFFECT_RESOLVE,\n  XSTATE_LOGIC_EFFECT_START,\n  createLogic as createBaseLogic\n} from './logic.ts';\n\nexport type AsyncSnapshot<TOutput, TInput> = Snapshot<TOutput> & {\n  input: TInput | undefined;\n  effects?: Record<\n    string,\n    | { status: 'active' }\n    | { status: 'done'; output?: unknown }\n    | { status: 'error'; error: unknown }\n  >;\n};\n\nconst XSTATE_ASYNC_RESOLVE = 'xstate.async.resolve';\nconst XSTATE_ASYNC_REJECT = 'xstate.async.reject';\n\nexport type AsyncActorLogic<\n  TOutput,\n  TInput = unknown,\n  TEmitted extends EventObject = EventObject\n> = ActorLogic<\n  AsyncSnapshot<TOutput, TInput>,\n  { type: string; [k: string]: unknown },\n  TInput,\n  AnyActorSystem,\n  TEmitted\n>;\n\nexport type AsyncActorRef<TOutput> = ActorRefFromLogic<\n  AsyncActorLogic<TOutput, unknown>\n>;\n\ntype AsyncActor<\n  TOutput,\n  TInput = unknown,\n  TEmitted extends EventObject = EventObject\n> = ActorFromLogic<AsyncActorLogic<TOutput, TInput, TEmitted>>;\n\nexport interface LogicArgs<TOutput, TInput> {\n  /** Data that was provided to the async actor. */\n  input: TInput;\n  /** The actor system to which the async actor belongs. */\n  system: AnyActorSystem;\n  /** The async actor. */\n  self: AsyncActor<TOutput, TInput>;\n  /** Aborted when the async actor is stopped or times out. */\n  signal: AbortSignal;\n}\n\nexport interface LogicEnqueue<TEmitted extends EventObject> {\n  /** Emits an event that can be observed with `actor.on(...)`. */\n  emit: (emitted: TEmitted) => void;\n  /**\n   * Executes async work as a durable effect keyed by `key`.\n   *\n   * @experimental The durability semantics (step journaling, replay, and\n   *   resumption across persistence) are not finalized and may change.\n   */\n  step: <TStepOutput>(\n    key: string,\n    exec: () => TStepOutput | PromiseLike<TStepOutput>\n  ) => Promise<TStepOutput>;\n}\n\nexport type LogicFunction<\n  TOutput,\n  TInput = NonReducibleUnknown,\n  TEmitted extends EventObject = EventObject\n> = (\n  args: LogicArgs<TOutput, TInput>,\n  enq: LogicEnqueue<TEmitted>\n) => PromiseLike<TOutput>;\n\nexport interface LogicConfig<\n  TOutput,\n  TInput = NonReducibleUnknown,\n  TEmitted extends EventObject = EventObject,\n  TInputSchema extends StandardSchemaV1 = StandardSchemaV1,\n  TOutputSchema extends StandardSchemaV1 = StandardSchemaV1\n> {\n  /**\n   * Stable identifier for this async logic. This identifies the logic, not a\n   * particular actor instance.\n   */\n  id?: string;\n  /** Schemas for inferring async logic types. */\n  schemas?: {\n    input?: TInputSchema;\n    output?: TOutputSchema;\n  };\n  /** Maximum time this async logic may run before it is aborted and errors. */\n  timeout?: number | string;\n  /** The async work to execute when the actor starts. */\n  run: LogicFunction<TOutput, TInput, TEmitted>;\n}\n\nexport class TimeoutError extends Error {\n  constructor(timeout: number | string) {\n    super(`Async logic timed out after ${timeout}.`);\n    this.name = 'TimeoutError';\n  }\n}\n\n/**\n * Represents an actor created by `createAsyncLogic`.\n *\n * The type of `self` within the actor's logic.\n *\n * @example\n *\n * ```ts\n * import { createAsyncLogic, createActor } from 'xstate';\n *\n * // The actor's resolved output\n * type Output = string;\n * // The actor's input.\n * type Input = { message: string };\n *\n * // Actor logic that fetches the url of an image of a cat saying `input.message`.\n * const logic = createAsyncLogic<Output, Input>({\n *   run: async ({ input, self }, enq) => {\n *     self;\n *     // ^? AsyncActor<Output, Input>\n *     enq.emit({ type: 'request.start' });\n *\n *     const data = await fetch(\n *       `https://cataas.com/cat/says/${input.message}`\n *     );\n *     const url = await data.json();\n *     return url;\n *   }\n * });\n *\n * const actor = createActor(logic, { input: { message: 'hello world' } });\n * //    ^? AsyncActor<Output, Input>\n * ```\n *\n * @see {@link createAsyncLogic}\n */\n\n/**\n * An actor logic creator which returns async logic as defined by an async\n * process that resolves or rejects after some time.\n *\n * Actors created from async actor logic can:\n *\n * - Output the resolved value of the async process\n * - Error with the rejected value of the async process\n * - Abort when stopped or timed out\n *\n * Sending events to async actors will have no effect.\n *\n * @example\n *\n * ```ts\n * const asyncLogic = createAsyncLogic({\n *   id: 'fetch-user',\n *   timeout: '30s',\n *   run: async ({ signal }, enq) => {\n *     enq.emit({ type: 'request.start' });\n *     const result = await fetch('https://example.com/...', {\n *       signal\n *     }).then((data) => data.json());\n *\n *     return result;\n *   }\n * });\n *\n * const asyncActor = createActor(asyncLogic);\n * asyncActor.subscribe((snapshot) => {\n *   console.log(snapshot);\n * });\n * asyncActor.start();\n * // => {\n * //   output: undefined,\n * //   status: 'active'\n * //   ...\n * // }\n *\n * // After promise resolves\n * // => {\n * //   output: { ... },\n * //   status: 'done',\n * //   ...\n * // }\n * ```\n *\n * @param asyncLogic A config object with a `run` function which returns a\n *   Promise, and accepts an object with the following properties:\n *\n *   - `input` - Data that was provided to the async actor\n *   - `self` - The async actor ref\n *   - `system` - The actor system to which the async actor belongs\n *   - `signal` - An abort signal for cancellation\n *\n *   `run` also receives an `enq` object with the following properties:\n *\n *   - `emit` - Emits an event that can be observed with `actor.on(...)`\n *\n * @see {@link https://stately.ai/docs/input | Input docs} for more information about how input is passed\n */\nexport function createAsyncLogic<\n  const TInputSchema extends StandardSchemaV1,\n  const TOutputSchema extends StandardSchemaV1,\n  TEmitted extends EventObject = EventObject\n>(\n  asyncLogic: LogicConfig<\n    StandardSchemaV1.InferOutput<TOutputSchema>,\n    StandardSchemaV1.InferOutput<TInputSchema>,\n    TEmitted,\n    TInputSchema,\n    TOutputSchema\n  > & {\n    schemas: {\n      input: TInputSchema;\n      output: TOutputSchema;\n    };\n  }\n): AsyncActorLogic<\n  StandardSchemaV1.InferOutput<TOutputSchema>,\n  StandardSchemaV1.InferOutput<TInputSchema>,\n  TEmitted\n> & { id?: string };\nexport function createAsyncLogic<\n  TOutput,\n  const TInputSchema extends StandardSchemaV1,\n  TEmitted extends EventObject = EventObject\n>(\n  asyncLogic: LogicConfig<\n    TOutput,\n    StandardSchemaV1.InferOutput<TInputSchema>,\n    TEmitted,\n    TInputSchema\n  > & {\n    schemas: {\n      input: TInputSchema;\n      output?: never;\n    };\n  }\n): AsyncActorLogic<\n  TOutput,\n  StandardSchemaV1.InferOutput<TInputSchema>,\n  TEmitted\n> & { id?: string };\nexport function createAsyncLogic<\n  const TOutputSchema extends StandardSchemaV1,\n  TInput = NonReducibleUnknown,\n  TEmitted extends EventObject = EventObject\n>(\n  asyncLogic: LogicConfig<\n    StandardSchemaV1.InferOutput<TOutputSchema>,\n    TInput,\n    TEmitted,\n    StandardSchemaV1,\n    TOutputSchema\n  > & {\n    schemas: {\n      input?: never;\n      output: TOutputSchema;\n    };\n  }\n): AsyncActorLogic<\n  StandardSchemaV1.InferOutput<TOutputSchema>,\n  TInput,\n  TEmitted\n> & { id?: string };\nexport function createAsyncLogic<\n  TOutput,\n  TInput = NonReducibleUnknown,\n  TEmitted extends EventObject = EventObject\n>(\n  asyncLogic: Omit<LogicConfig<TOutput, TInput, TEmitted>, 'schemas'> & {\n    schemas?: undefined;\n  }\n): AsyncActorLogic<TOutput, TInput, TEmitted> & { id?: string };\nexport function createAsyncLogic<\n  TOutput,\n  TInput = NonReducibleUnknown,\n  TEmitted extends EventObject = EventObject\n>(\n  asyncLogic: LogicConfig<TOutput, TInput, TEmitted>\n): AsyncActorLogic<TOutput, TInput, TEmitted> & { id?: string } {\n  const config = asyncLogic;\n\n  function waitForEffect<TStepOutput>(\n    self: AsyncActorRef<TOutput>,\n    key: string\n  ): Promise<TStepOutput> {\n    return new Promise((resolve, reject) => {\n      const subscription = self.subscribe((snapshot) => {\n        const effect = snapshot.effects?.[key];\n\n        if (effect?.status === 'done') {\n          subscription.unsubscribe();\n          resolve(effect.output as TStepOutput);\n        } else if (effect?.status === 'error') {\n          subscription.unsubscribe();\n          reject(effect.error as Error);\n        }\n      });\n    });\n  }\n\n  return createBaseLogic<\n    undefined,\n    TOutput,\n    { type: string; [k: string]: unknown },\n    TInput,\n    TEmitted\n  >({\n    id: config.id,\n    schemas: config.schemas,\n    context: undefined,\n    run: ({ event, input, self, system }, enq) => {\n      switch (event.type) {\n        case XSTATE_ASYNC_RESOLVE: {\n          const resolvedValue = (event as any).data ?? (event as any).output;\n          return {\n            status: 'done',\n            output: resolvedValue,\n            input: undefined as TInput | undefined,\n            effects: {\n              async: { status: 'done', output: resolvedValue }\n            }\n          };\n        }\n        case XSTATE_ASYNC_REJECT: {\n          const error = (event as any).data ?? (event as any).error;\n          return {\n            status: 'error',\n            error,\n            input: undefined as TInput | undefined,\n            effects: {\n              async: { status: 'error', error }\n            }\n          };\n        }\n      }\n\n      if (event.type !== XSTATE_INIT) {\n        return;\n      }\n\n      enq.effect(() => {\n        const actorSelf = self as unknown as AnyActor;\n        const controller = new AbortController();\n        const timeout = config.timeout;\n        const timeoutMs = parseDelayToMilliseconds(timeout);\n        const timeoutId =\n          timeoutMs === undefined\n            ? undefined\n            : system._clock.setTimeout(() => {\n                if (self.getSnapshot().status !== 'active') {\n                  return;\n                }\n                controller.abort();\n                system._relay(actorSelf, actorSelf, {\n                  type: XSTATE_ASYNC_REJECT,\n                  data: new TimeoutError(timeout!)\n                });\n              }, timeoutMs);\n\n        const clearTimeout = () => {\n          if (timeoutId !== undefined) {\n            system._clock.clearTimeout(timeoutId);\n          }\n        };\n\n        const resolvedPromise = Promise.resolve(\n          config.run(\n            {\n              input,\n              system,\n              self: self as any,\n              signal: controller.signal\n            },\n            {\n              emit: enq.emit,\n              step: async (key, exec) => {\n                const effect = self.getSnapshot().effects?.[key];\n\n                if (effect?.status === 'done') {\n                  return effect.output as any;\n                }\n\n                if (effect?.status === 'error') {\n                  throw effect.error;\n                }\n\n                if (effect?.status === 'active') {\n                  return waitForEffect(self as any, key) as any;\n                }\n\n                system._relay(actorSelf, actorSelf, {\n                  type: XSTATE_LOGIC_EFFECT_START,\n                  key\n                });\n\n                try {\n                  const output = await exec();\n                  system._relay(actorSelf, actorSelf, {\n                    type: XSTATE_LOGIC_EFFECT_RESOLVE,\n                    key,\n                    output\n                  });\n                  return output;\n                } catch (error) {\n                  system._relay(actorSelf, actorSelf, {\n                    type: XSTATE_LOGIC_EFFECT_REJECT,\n                    key,\n                    error\n                  });\n                  throw error;\n                }\n              }\n            }\n          )\n        );\n\n        resolvedPromise.then(\n          (response) => {\n            clearTimeout();\n            if (self.getSnapshot().status !== 'active') {\n              return;\n            }\n            system._relay(actorSelf, actorSelf, {\n              type: XSTATE_ASYNC_RESOLVE,\n              data: response\n            });\n          },\n          (errorData) => {\n            clearTimeout();\n            if (self.getSnapshot().status !== 'active') {\n              return;\n            }\n            system._relay(actorSelf, actorSelf, {\n              type: XSTATE_ASYNC_REJECT,\n              data: errorData\n            });\n          }\n        );\n\n        return () => {\n          controller.abort();\n          clearTimeout();\n        };\n      });\n\n      return {\n        effects: {\n          async: { status: 'active' }\n        }\n      };\n    }\n  }) as unknown as AsyncActorLogic<TOutput, TInput, TEmitted> & { id?: string };\n}\n","import { createActor } from '../createActor.ts';\nimport type { ActorFromLogic } from '../types.ts';\nimport { createLogic } from './logic.ts';\nexport {\n  createCallbackLogic,\n  type CallbackActorLogic,\n  type CallbackActorRef,\n  type CallbackLogicConfig,\n  type CallbackSnapshot,\n  type CallbackLogicFunction\n} from './callback.ts';\nexport {\n  createObservableLogic,\n  createEventObservableLogic,\n  type EventObservableLogicConfig,\n  type EventObservableLogicFunction,\n  type ObservableActorLogic,\n  type ObservableActorRef,\n  type ObservableLogicConfig,\n  type ObservableLogicFunction,\n  type ObservableSnapshot\n} from './observable.ts';\nexport {\n  createLogic,\n  type LogicActorLogic,\n  type LogicActorRef,\n  type LogicArgs,\n  type LogicConfig,\n  type LogicEffect,\n  type LogicEffectState,\n  type LogicEnqueue,\n  type LogicFunction,\n  type LogicPatch,\n  type LogicSnapshot\n} from './logic.ts';\nexport {\n  createAsyncLogic,\n  type AsyncActorLogic,\n  type AsyncActorRef,\n  type AsyncSnapshot,\n  type LogicArgs as AsyncLogicArgs,\n  type LogicConfig as AsyncLogicConfig,\n  type LogicEnqueue as AsyncLogicEnqueue,\n  type LogicFunction as AsyncLogicFunction,\n  TimeoutError\n} from './promise.ts';\nexport {\n  createListenerLogic,\n  listenerLogic,\n  type ListenerActorLogic,\n  type ListenerActorRef,\n  type ListenerSnapshot,\n  type ListenerInput\n} from './listener.ts';\nexport {\n  createSubscriptionLogic,\n  subscriptionLogic,\n  type SubscriptionActorLogic,\n  type SubscriptionActorRef,\n  type SubscriptionSnapshot,\n  type SubscriptionInput,\n  type SubscriptionMappers\n} from './subscription.ts';\n\nconst emptyLogic = /* #__PURE__ */ createLogic<undefined, undefined>({\n  context: undefined,\n  run: () => undefined\n});\n\nexport function createEmptyActor(): ActorFromLogic<typeof emptyLogic> {\n  return createActor(emptyLogic);\n}\n"],"names":["Mailbox","constructor","_process","this","_active","_current","_last","start","flush","clear","next","enqueue","event","enqueued","value","consumed","XSTATE_INIT","XSTATE_STOP","createInitEvent","input","type","reportUnhandledError","err","setTimeout","symbolObservable","Symbol","observable","subscriptions","WeakMap","createAttachedLogic","attach","initialTransition","_","status","output","undefined","error","state","self","system","target","actor","getSnapshot","subscription","parentSubscription","torndown","teardown","unsubscribe","parent","_parent","subscribe","complete","set","transition","get","delete","getInitialSnapshot","actorScope","getPersistedSnapshot","snapshot","restoreSnapshot","relayMappedToParent","getEvent","_relay","createListenerLogic","eventType","mapper","isPartialWildcard","endsWith","on","emittedEvent","descriptor","partialEventTokens","split","eventTokens","tokenIndex","length","partialEventToken","eventToken","matchesEventDescriptor","listenerLogic","createSubscriptionLogic","mappers","done","onSnapshot","subscriptionLogic","parseDelayToMilliseconds","delay","duration","normalizedDuration","trim","millisecondsMatch","match","parseInt","secondsMatch","wholePart","hasDecimal","fracPart","padEnd","slice","iso8601DurationMatch","groups","weeks","days","hours","minutes","seconds","toNumber","Number","replace","parseDurationToMilliseconds","toObserver","nextHandler","errorHandler","completionHandler","isObserver","bind","createScheduledEventId","id","sessionId","effectStates","XSTATE_LOGIC_EFFECT_RESOLVE","XSTATE_LOGIC_EFFECT_REJECT","XSTATE_LOGIC_EFFECT_START","getEffectState","Map","executeLogicEffects","effects","effect","emit","key","cleanup","exec","has","values","createLogic","config","trackedEffects","enq","emitted","push","sendBack","sentEvent","raise","raisedEvent","keyOrExec","maybeExec","enqueueEffect","patch","run","context","nextSnapshot","Object","keys","logic","assign","resolveContext","executingCustomAction","ProcessingStatus","defaultOptions","clock","fn","ms","clearTimeout","logger","console","log","isExecutableActionObject","executeExecutableEffects","logicEffects","actionExecutor","Actor","options","_snapshot","_boundProcess","mailbox","observers","Set","eventListeners","_processingStatus","NotStarted","_forceDeferredActions","_syncSnapshot","ref","_actorScope","_lastSourceRef","_collectedMicrosteps","_collectedActions","_collectedSent","_initialEffects","systemId","trigger","src","_deferred","_pendingEffects","resolvedOptions","syncSnapshot","inspect","rootActor","idCounter","children","keyedActors","reverseKeyedActors","inspectionObservers","timerMap","recordSent","source","size","targetRef","targetId","scheduler","schedule","Math","random","toString","scheduledEvent","startedAt","Date","now","scheduledEventId","_scheduledEvents","timeout","deliver","cancel","cancelAll","targetMachine","isInternalEventType","Error","_send","_bookId","_register","_unregister","getAll","fromEntries","entries","_set","existing","observerOrFn","observer","add","_sendInspectionEvent","resolvedInspectionEvent","rootId","forEach","scheduledEvents","scheduledId","_clock","_logger","_timerStrategy","timers","createSystem","defer","stopChild","child","_stop","listeners","wildcardListener","handler","action","params","saveExecutingCustomAction","Running","send","Proxy","payload","persistedState","rest","actorRef","parentRef","_setErrorSnapshot","_next","update","i","deferredFn","_stopProcedure","_complete","doneEvent","invokeId","actorId","_error","sourceRef","microsteps","actions","sent","_flushInitialEffects","nextListenerOrObserver","errorListener","completeListener","Stopped","select","selector","equalityFn","is","selected","initEvent","strategy","resolveRestoredTimerDelay","nextState","caughtError","stop","reportError","err2","toJSON","xstate$$type","persisted","pendingEffects","scheduled","elapsed","max","instanceStates","XSTATE_OBSERVABLE_NEXT","XSTATE_OBSERVABLE_ERROR","XSTATE_OBSERVABLE_COMPLETE","XSTATE_ASYNC_RESOLVE","XSTATE_ASYNC_REJECT","TimeoutError","super","name","emptyLogic","asyncLogic","createBaseLogic","schemas","resolvedValue","data","async","actorSelf","controller","AbortController","timeoutMs","timeoutId","abort","Promise","resolve","signal","step","reject","waitForEffect","then","response","errorData","callbackOrConfig","callback","args","callbackState","receivers","receiver","dispose","receive","listener","lazyObservableOrConfig","lazyObservable","_subscription","observableCreatorOrConfig","observableCreator"],"mappings":"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"}