aifsmjs 0.5.3 → 0.5.6

package/dist/chunk-VZCSHTOI.js

@@ -0,0 +1,374 @@
+import { freezeSnapshot, step, normalizeTransitions, deepFreeze } from './chunk-ZLQ7HZCE.js';
+import { evalGuard, isAsyncGuardFn, isThenable } from './chunk-A7U7QQL5.js';
+
+// src/fsm/types.ts
+var RESET_EVENT_TYPE = "@@aifsmjs/RESET";
+
+// src/fsm/definition.ts
+var InvalidDefinitionError = class extends Error {
+  constructor(message) {
+    super(`aifsmjs: ${message}`);
+    this.name = "InvalidDefinitionError";
+  }
+};
+function validateDefinition(def) {
+  if (!def.id || typeof def.id !== "string") {
+    throw new InvalidDefinitionError("definition must have a non-empty string `id`");
+  }
+  if (!def.states || typeof def.states !== "object") {
+    throw new InvalidDefinitionError("definition must have a `states` object");
+  }
+  const stateKeys = Object.keys(def.states);
+  if (stateKeys.length === 0) {
+    throw new InvalidDefinitionError("`states` must declare at least one state");
+  }
+  if (!def.initial || !stateKeys.includes(def.initial)) {
+    throw new InvalidDefinitionError(
+      `\`initial\` "${String(def.initial)}" is not declared in states (${stateKeys.join(", ")})`
+    );
+  }
+  for (const [stateName, stateDef] of Object.entries(def.states)) {
+    if (stateDef.sub !== void 0) {
+      const sub = stateDef.sub;
+      const subStates = sub.states;
+      const subInitial = sub.initial;
+      if (typeof sub !== "object" || sub === null || typeof subStates !== "object" || subStates === null || typeof subInitial !== "string" || // initial must name one of the sub's own states — otherwise the child
+      // boots pointing at a non-existent state and no-ops forever (FSM-S-02).
+      !Object.hasOwn(subStates, subInitial)) {
+        throw new InvalidDefinitionError(
+          `state "${stateName}".sub is not a valid sub-machine definition (missing states or initial)`
+        );
+      }
+    }
+    if (!stateDef.on) continue;
+    for (const [evtType, entry] of Object.entries(stateDef.on)) {
+      const transitions = normalizeTransitions(entry);
+      for (const t of transitions) {
+        if (t.target !== void 0 && !stateKeys.includes(t.target)) {
+          throw new InvalidDefinitionError(
+            `transition ${stateName} -[${evtType}]-> "${String(t.target)}" targets an unknown state`
+          );
+        }
+        if (t.guard !== void 0 && isAsyncGuardFn(t.guard)) {
+          throw new InvalidDefinitionError(
+            `transition ${stateName} -[${evtType}]-> uses an async guard. Guards must be sync; move I/O into an effect.`
+          );
+        }
+      }
+    }
+  }
+}
+function defineMachine(def) {
+  const normalized = !("context" in def) ? { ...def, context: {} } : def;
+  validateDefinition(normalized);
+  return normalized;
+}
+function setup() {
+  return {
+    defineMachine: (def) => {
+      const cast = !("context" in def) ? { ...def, context: {} } : def;
+      validateDefinition(cast);
+      return cast;
+    }
+  };
+}
+function initialSnapshot(def) {
+  const isFinal = def.states[def.initial]?.final === true;
+  return freezeSnapshot({
+    value: def.initial,
+    context: def.context,
+    status: isFinal ? "final" : "active"
+  });
+}
+function createMachine(def, impl, opts) {
+  return createRuntime(defineMachine(def), impl, opts ?? {});
+}
+
+// src/fsm/runtime.ts
+var RuntimeDisposedError = class extends Error {
+  constructor() {
+    super("aifsmjs: runtime has been disposed; send()/reset() are not allowed");
+    this.name = "RuntimeDisposedError";
+  }
+};
+var SubMachineError = class extends Error {
+  parentState;
+  phase;
+  cause;
+  constructor(parentState, phase, cause) {
+    super(`aifsmjs: sub-machine ${phase} failed at parent state "${parentState}"`, { cause });
+    this.name = "SubMachineError";
+    this.parentState = parentState;
+    this.phase = phase;
+    this.cause = cause;
+  }
+};
+var RESET_EVENT = Object.freeze({ type: RESET_EVENT_TYPE });
+function composeMiddleware(middleware) {
+  return (ctx, finalNext) => {
+    let index = -1;
+    const dispatch = (i) => {
+      if (i <= index) throw new Error("aifsmjs: next() called multiple times in middleware");
+      index = i;
+      const fn = middleware[i];
+      if (!fn) {
+        finalNext();
+        return;
+      }
+      fn(ctx, () => dispatch(i + 1));
+    };
+    dispatch(0);
+  };
+}
+function createRuntime(def, impl, opts = {}) {
+  let snapshot = initialSnapshot(def);
+  const listeners = /* @__PURE__ */ new Set();
+  const middlewareChain = opts.middleware && opts.middleware.length > 0 ? composeMiddleware(opts.middleware) : void 0;
+  const shouldDispatch = opts.dispatchEffects !== false;
+  const controller = new AbortController();
+  let disposed = false;
+  let childRuntime;
+  let childAbortCleanup;
+  const eventListeners = {
+    transition: /* @__PURE__ */ new Set(),
+    error: /* @__PURE__ */ new Set(),
+    dispose: /* @__PURE__ */ new Set()
+  };
+  const externalAbortCleanups = /* @__PURE__ */ new Set();
+  function emit(type, payload) {
+    for (const fn of Array.from(eventListeners[type])) fn(payload);
+  }
+  function notify(committed) {
+    const captured = committed ?? snapshot;
+    for (const l of Array.from(listeners)) l(captured);
+  }
+  function runMiddleware(prev, event, effects, changed) {
+    if (!middlewareChain) return;
+    middlewareChain(deepFreeze({ prev, next: snapshot, event, effects, changed }), () => {
+    });
+  }
+  function dispatchEffects(effects, context, event) {
+    if (!impl.effects || effects.length === 0) return;
+    for (const eff of effects) {
+      const handler = impl.effects[eff.type];
+      if (!handler) continue;
+      const r = handler(eff, { context, event, signal: controller.signal });
+      if (isThenable(r)) {
+        Promise.resolve(r).catch((err) => {
+          emit("error", { error: err, event });
+        });
+      }
+    }
+  }
+  function wireChildAbort(child) {
+    if (controller.signal.aborted) {
+      try {
+        child.dispose();
+      } catch {
+      }
+      return () => {
+      };
+    }
+    const onAbort = () => {
+      try {
+        child.dispose();
+      } catch {
+      }
+    };
+    controller.signal.addEventListener("abort", onAbort, { once: true });
+    return () => controller.signal.removeEventListener("abort", onAbort);
+  }
+  function initChildFor(stateValue) {
+    const stateDef = def.states[stateValue];
+    const sub = stateDef?.sub;
+    if (sub === void 0) return;
+    let newChild;
+    try {
+      newChild = createRuntime(sub, stateDef.subImpl ?? {});
+    } catch (cause) {
+      throw new SubMachineError(stateValue, "init", cause);
+    }
+    childRuntime = newChild;
+    childAbortCleanup = wireChildAbort(newChild);
+  }
+  function findChosenIsExternal(value, event, context) {
+    const state = def.states[value];
+    if (!state?.on) return false;
+    const list = normalizeTransitions(state.on[event.type]);
+    if (list.length === 0) return false;
+    for (const t of list) {
+      if (!t.guard || evalGuard(t.guard, context, event, impl, value)) {
+        return t.target !== void 0;
+      }
+    }
+    return false;
+  }
+  function applySubLifecycle(prevValue, nextValue) {
+    const prevStateDef = def.states[prevValue];
+    const nextStateDef = def.states[nextValue];
+    if (prevStateDef?.sub !== void 0 && childRuntime !== void 0) {
+      const child = childRuntime;
+      childRuntime = void 0;
+      childAbortCleanup?.();
+      childAbortCleanup = void 0;
+      try {
+        child.dispose();
+      } catch (cause) {
+        throw new SubMachineError(prevValue, "dispose", cause);
+      }
+    }
+    if (nextStateDef?.sub !== void 0) {
+      initChildFor(nextValue);
+    }
+  }
+  function send(event) {
+    if (disposed) throw new RuntimeDisposedError();
+    const prev = snapshot;
+    const result = step(def, prev, event, impl);
+    const isExternal = result.changed && (prev.value !== result.snapshot.value || findChosenIsExternal(prev.value, event, prev.context));
+    if (result.changed && isExternal) applySubLifecycle(prev.value, result.snapshot.value);
+    snapshot = result.snapshot;
+    const committed = result.snapshot;
+    runMiddleware(prev, event, result.effects, result.changed);
+    if (shouldDispatch) dispatchEffects(result.effects, committed.context, event);
+    if (result.changed) {
+      notify(committed);
+      emit("transition", {
+        prev,
+        next: committed,
+        event,
+        effects: result.effects,
+        changed: true
+      });
+    }
+    return snapshot;
+  }
+  function reset(event) {
+    if (disposed) throw new RuntimeDisposedError();
+    const prev = snapshot;
+    const nextSnap = initialSnapshot(def);
+    const changed = prev.value !== nextSnap.value;
+    if (childRuntime) {
+      const child = childRuntime;
+      childRuntime = void 0;
+      childAbortCleanup?.();
+      childAbortCleanup = void 0;
+      try {
+        child.dispose();
+      } catch (cause) {
+        throw new SubMachineError(prev.value, "dispose", cause);
+      }
+    }
+    const initStateDef = def.states[nextSnap.value];
+    if (initStateDef?.sub) {
+      initChildFor(nextSnap.value);
+    }
+    snapshot = nextSnap;
+    const committed = nextSnap;
+    const triggerEvent = event ?? RESET_EVENT;
+    runMiddleware(prev, triggerEvent, [], changed);
+    if (changed) {
+      notify(committed);
+      emit("transition", {
+        prev,
+        next: committed,
+        event: triggerEvent,
+        effects: [],
+        changed: true
+      });
+    }
+    return snapshot;
+  }
+  function can(event) {
+    if (disposed || snapshot.status === "final") return false;
+    const state = def.states[snapshot.value];
+    if (!state) return false;
+    const list = normalizeTransitions(state.on?.[event.type]);
+    if (list.length === 0) return false;
+    for (const t of list) {
+      if (!t.guard) return true;
+      if (evalGuard(t.guard, snapshot.context, event, impl, snapshot.value)) return true;
+    }
+    return false;
+  }
+  function on(type, listener, options) {
+    if (disposed || options?.signal?.aborted) return () => {
+    };
+    const target = eventListeners[type];
+    let detachAbort;
+    const cleanup = () => {
+      target.delete(wrapped);
+      if (detachAbort) {
+        detachAbort();
+        externalAbortCleanups.delete(detachAbort);
+      }
+    };
+    let wrapped = listener;
+    if (options?.once) {
+      wrapped = (payload) => {
+        cleanup();
+        listener(payload);
+      };
+    }
+    target.add(wrapped);
+    const signal = options?.signal;
+    if (signal) {
+      const onAbort = () => cleanup();
+      signal.addEventListener("abort", onAbort, { once: true });
+      detachAbort = () => signal.removeEventListener("abort", onAbort);
+      externalAbortCleanups.add(detachAbort);
+    }
+    return cleanup;
+  }
+  function dispose() {
+    if (disposed) return;
+    disposed = true;
+    if (childRuntime) {
+      childAbortCleanup?.();
+      childAbortCleanup = void 0;
+      try {
+        childRuntime.dispose();
+      } catch {
+      }
+      childRuntime = void 0;
+    }
+    controller.abort();
+    listeners.clear();
+    emit("dispose", void 0);
+    for (const set of Object.values(eventListeners)) set.clear();
+    for (const cleanup of externalAbortCleanups) cleanup();
+    externalAbortCleanups.clear();
+  }
+  const runtime = {
+    getSnapshot: () => snapshot,
+    snapshot: () => snapshot,
+    send,
+    can,
+    reset,
+    dispose,
+    on,
+    get disposed() {
+      return disposed;
+    },
+    get signal() {
+      return controller.signal;
+    },
+    subscribe(listener) {
+      if (disposed) return () => {
+      };
+      listeners.add(listener);
+      return () => listeners.delete(listener);
+    },
+    subRuntime: () => childRuntime,
+    onTransition: (handler, options) => on("transition", handler, options)
+  };
+  const bootStateDef = def.states[snapshot.value];
+  if (bootStateDef?.sub) {
+    initChildFor(snapshot.value);
+  }
+  return runtime;
+}
+
+export { InvalidDefinitionError, RESET_EVENT_TYPE, RuntimeDisposedError, SubMachineError, createMachine, createRuntime, defineMachine, initialSnapshot, setup };
+//# sourceMappingURL=chunk-VZCSHTOI.js.map
+//# sourceMappingURL=chunk-VZCSHTOI.js.map

package/dist/chunk-VZCSHTOI.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/fsm/types.ts","../src/fsm/definition.ts","../src/fsm/runtime.ts"],"names":[],"mappings":"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","file":"chunk-VZCSHTOI.js","sourcesContent":["// All public types live here so AI agents and humans can read the entire\n// public surface in one file.\n\nexport type Effect = Readonly<{ type: string; payload?: unknown }>;\n\nexport type Enqueuer = Readonly<{\n  effect: (type: string, payload?: unknown) => void;\n}>;\n\nexport type GuardArgs<Ctx, Evt> = Readonly<{\n  context: Ctx;\n  event: Evt;\n  /**\n   * Optional guard registry, threaded by `evalGuard` so combinators can resolve\n   * string refs nested inside `and / or / not`. Inline user guards may safely\n   * ignore this field — it is `undefined` when guards are evaluated outside of\n   * `evalGuard` (e.g. in unit tests calling the function directly).\n   */\n  guards?: Readonly<Record<string, Guard<Ctx, Evt>>>;\n  /**\n   * Current state value, threaded by `evalGuard` from the live snapshot. Used\n   * by the `stateIn` combinator. `undefined` when guards are called outside of\n   * a lifecycle evaluation.\n   */\n  value?: string;\n}>;\n\nexport type Guard<Ctx, Evt> = (args: GuardArgs<Ctx, Evt>) => boolean;\n\nexport type Action<Ctx, Evt> = (args: {\n  context: Ctx;\n  event: Evt;\n  enqueue: Enqueuer;\n}) => Partial<Ctx> | void;\n\nexport type EffectHandler<Ctx, Evt> = (\n  effect: Effect,\n  args: { context: Ctx; event: Evt; signal: AbortSignal },\n) => void | Promise<void>;\n\nexport type GuardRef<Ctx, Evt> = string | Guard<Ctx, Evt>;\nexport type ActionRef<Ctx, Evt> = string | Action<Ctx, Evt>;\n\nexport type TransitionDef<Ctx, Evt, States extends string> = Readonly<{\n  target?: States;\n  guard?: GuardRef<Ctx, Evt>;\n  actions?: readonly ActionRef<Ctx, Evt>[];\n}>;\n\n/**\n * A single transition as written in a `StateDef.on` map. Either the full\n * {@link TransitionDef} object form, or the string shorthand `\"targetState\"`\n * (à la XState) which the resolver normalizes to `{ target: \"targetState\" }`\n * before processing. The shorthand carries no guard or actions.\n *\n * @since 0.5.3\n */\nexport type TransitionConfig<Ctx, Evt, States extends string> =\n  | States\n  | TransitionDef<Ctx, Evt, States>;\n\n/**\n * @experimental v0.3.0\n *\n * A nested machine definition attachable to StateDef.sub. The type parameters\n * are independent from the parent machine's <Ctx, Evt, States>; sub-machines\n * may have entirely unrelated context and event shapes.\n *\n * This is an alias for MachineDef — sub-machines have the same definition\n * shape as top-level machines. The relationship is purely lifecycle:\n * a sub-machine instance is created when its parent state becomes active\n * and disposed when the parent state exits.\n */\nexport type SubMachineDef<\n  SubCtx,\n  SubEvt extends { type: string },\n  SubStates extends string,\n> = MachineDef<SubCtx, SubEvt, SubStates>;\n\nexport type StateDef<Ctx, Evt, States extends string> = Readonly<{\n  on?: Readonly<\n    Record<\n      string,\n      TransitionConfig<Ctx, Evt, States> | readonly TransitionConfig<Ctx, Evt, States>[]\n    >\n  >;\n  entry?: readonly ActionRef<Ctx, Evt>[];\n  exit?: readonly ActionRef<Ctx, Evt>[];\n  final?: boolean;\n  /**\n   * Optional sub-machine. When the runtime enters a state with `sub`,\n   * the sub-machine is lazily instantiated; when it exits, the sub-machine\n   * is disposed. See STABILITY.md for the experimental contract.\n   *\n   * The generic parameters are erased to `any` because sub-machine type\n   * parameters are intentionally independent from the parent's `Ctx` / `Evt`\n   * / `States`. `MachineDef`'s generics are invariant (guards / actions\n   * consume them), so the storage position must use `any` rather than\n   * `unknown`. Caller narrows via `runtime.subRuntime() as Runtime<...>`.\n   *\n   * @experimental since 0.3.0\n   */\n  // biome-ignore lint/suspicious/noExplicitAny: see JSDoc — invariant generic escape hatch\n  sub?: MachineDef<any, any, any>;\n  /**\n   * Implementations for `sub`. Ignored if `sub` is absent. Defaults to `{}`\n   * (sub-machine must rely on inline guards / actions / effects only).\n   *\n   * @experimental since 0.3.0\n   */\n  // biome-ignore lint/suspicious/noExplicitAny: same reason as `sub` above\n  subImpl?: Implementations<any, any>;\n}>;\n\nexport type MachineDef<Ctx, Evt extends { type: string }, States extends string> = Readonly<{\n  id: string;\n  initial: States;\n  context: Ctx;\n  states: Readonly<Record<States, StateDef<Ctx, Evt, States>>>;\n}>;\n\n/**\n * Input shape accepted by `defineMachine` / `setup().defineMachine`. Identical\n * to {@link MachineDef} except `context` is **optional** — when omitted it\n * defaults to `{}` (paired with the `Ctx = Record<string, never>` default type\n * parameter). The returned value is always a fully-normalized\n * {@link MachineDef} with `context` present, so downstream consumers are\n * unaffected.\n *\n * @since 0.5.3\n */\nexport type MachineConfig<Ctx, Evt extends { type: string }, States extends string> = Readonly<{\n  id: string;\n  initial: States;\n  states: Readonly<Record<States, StateDef<Ctx, Evt, States>>>;\n}> &\n  // `context` may be omitted only when `Ctx` has no required properties (e.g. the\n  // default `Record<string, never>`). If `Ctx` has required fields it must be\n  // supplied, so omitting it can't silently default to `{}` and crash at runtime.\n  (Record<string, never> extends Ctx ? { readonly context?: Ctx } : { readonly context: Ctx });\n\nexport type Snapshot<Ctx, States extends string> = Readonly<{\n  value: States;\n  context: Ctx;\n  status: \"active\" | \"final\";\n}>;\n\nexport type Implementations<Ctx, Evt> = Readonly<{\n  guards?: Readonly<Record<string, Guard<Ctx, Evt>>>;\n  actions?: Readonly<Record<string, Action<Ctx, Evt>>>;\n  effects?: Readonly<Record<string, EffectHandler<Ctx, Evt>>>;\n}>;\n\nexport type StepResult<Ctx, States extends string> = Readonly<{\n  snapshot: Snapshot<Ctx, States>;\n  effects: readonly Effect[];\n  changed: boolean;\n}>;\n\n/**\n * Sentinel event type that `Runtime.reset()` synthesises when the caller does\n * not pass an explicit event. Middleware receives it through\n * `MiddlewareContext.event`. Exposed so user code can discriminate.\n */\nexport const RESET_EVENT_TYPE = \"@@aifsmjs/RESET\" as const;\nexport type ResetEvent = Readonly<{ type: typeof RESET_EVENT_TYPE }>;\n\nexport type MiddlewareContext<Ctx, Evt, States extends string> = Readonly<{\n  prev: Snapshot<Ctx, States>;\n  next: Snapshot<Ctx, States>;\n  /**\n   * The triggering event. May be the user's `Evt` (from `send()` or an\n   * explicit `reset(event)`) or the `ResetEvent` sentinel emitted by a\n   * `reset()` with no event argument.\n   */\n  event: Evt | ResetEvent;\n  effects: readonly Effect[];\n  changed: boolean;\n}>;\n\nexport type Middleware<Ctx, Evt, States extends string> = (\n  ctx: MiddlewareContext<Ctx, Evt, States>,\n  next: () => void,\n) => void;\n\n/**\n * Payload of the `'transition'` runtime event — emitted after each `send()` or\n * `reset()` that actually changed the snapshot value.\n */\nexport type RuntimeTransitionEvent<Ctx, Evt, States extends string> = Readonly<{\n  prev: Snapshot<Ctx, States>;\n  next: Snapshot<Ctx, States>;\n  event: Evt | ResetEvent;\n  effects: readonly Effect[];\n  changed: boolean;\n}>;\n\n/**\n * Payload of the `'error'` runtime event — currently emitted for async effect\n * handler rejections (which would otherwise become unhandled). Synchronous\n * throws from effect handlers and middleware still propagate to the caller of\n * `send()` / `reset()`.\n */\nexport type RuntimeErrorEvent<Evt> = Readonly<{\n  error: unknown;\n  event: Evt | ResetEvent | undefined;\n}>;\n\nexport type RuntimeEventMap<Ctx, Evt, States extends string> = {\n  transition: RuntimeTransitionEvent<Ctx, Evt, States>;\n  error: RuntimeErrorEvent<Evt>;\n  dispose: void;\n};\n\nexport interface Runtime<Ctx, Evt extends { type: string }, States extends string> {\n  getSnapshot(): Snapshot<Ctx, States>;\n  /** Alias for `getSnapshot()`. */\n  snapshot(): Snapshot<Ctx, States>;\n  send(event: Evt): Snapshot<Ctx, States>;\n  /**\n   * Predict whether sending `event` would fire a transition. Reuses\n   * `resolveTransitions` + `evalGuard` without applying any actions. Guards\n   * are expected to be pure; `can` then matches `send` for the same input.\n   */\n  can(event: Evt): boolean;\n  subscribe(listener: (snap: Snapshot<Ctx, States>) => void): () => void;\n  /**\n   * EventTarget-like typed listener API. Returns an unsubscribe function.\n   * `options.signal` removes the listener when aborted; `options.once`\n   * removes the listener after the first invocation. After `dispose()`,\n   * `on()` is a no-op and returns a no-op unsubscribe.\n   */\n  on<K extends keyof RuntimeEventMap<Ctx, Evt, States>>(\n    type: K,\n    listener: (payload: RuntimeEventMap<Ctx, Evt, States>[K]) => void,\n    options?: { signal?: AbortSignal; once?: boolean },\n  ): () => void;\n  /**\n   * Re-initialise the runtime to the definition's initial snapshot. Triggers\n   * subscribers but does NOT run entry actions (reset = re-birth, not\n   * \"transition into initial\"). Throws RuntimeDisposedError if disposed.\n   * If an `event` is supplied, middleware sees it as the trigger; otherwise\n   * a sentinel `{ type: \"@@aifsmjs/RESET\" }` is synthesised.\n   */\n  reset(event?: Evt): Snapshot<Ctx, States>;\n  /**\n   * Tear down: abort the internal AbortController (effect handlers see signal\n   * fire), clear listeners, and mark this runtime as disposed. Subsequent\n   * send()/reset() calls throw RuntimeDisposedError. Idempotent.\n   */\n  dispose(): void;\n  /**\n   * True after `dispose()` has been called.\n   */\n  readonly disposed: boolean;\n  /**\n   * AbortSignal scoped to this runtime's lifetime. Fires once on dispose().\n   * Threaded to every EffectHandler invocation; external integrations\n   * (e.g. component teardown) can also attach `signal.addEventListener(\"abort\", ...)`.\n   */\n  readonly signal: AbortSignal;\n  /**\n   * @experimental v0.3.0\n   *\n   * Returns the currently active sub-Runtime for the current parent state,\n   * or undefined if:\n   *   - the current state has no `sub` definition, OR\n   *   - the sub-Runtime failed to initialise (SubMachineError was thrown\n   *     from `send()` / `reset()` / `createRuntime` per the spec contract),\n   *     OR\n   *   - the parent runtime has been disposed.\n   *\n   * The returned Runtime is typed at the loosest sub-machine signature.\n   * Caller casts to the concrete sub type.\n   *\n   * Re-entry: when the parent leaves and re-enters a state with `sub`, a\n   * fresh sub-Runtime is constructed. Previous sub-Runtime references held\n   * by the caller are stale and MUST NOT be used (disposed).\n   */\n  subRuntime(): Runtime<unknown, { type: string }, string> | undefined;\n  /**\n   * Semantic sugar for `runtime.on('transition', handler, opts)`. Returns\n   * the same unsubscribe function. Sharing the same listener Set with\n   * `on('transition', ...)` means registration order determines invocation\n   * order across both APIs.\n   *\n   * @since 0.3.0\n   */\n  onTransition(\n    handler: (payload: RuntimeTransitionEvent<Ctx, Evt, States>) => void,\n    options?: { signal?: AbortSignal; once?: boolean },\n  ): () => void;\n}\n\nexport type RuntimeOptions<Ctx, Evt, States extends string> = Readonly<{\n  middleware?: readonly Middleware<Ctx, Evt, States>[];\n  /**\n   * If false, do not dispatch effects through the effect handler map.\n   * Useful for replay / dry-run modes. Defaults to true.\n   */\n  dispatchEffects?: boolean;\n}>;\n","import { isAsyncGuardFn } from \"./evaluator.js\";\nimport { normalizeTransitions } from \"./resolver.js\";\nimport { createRuntime } from \"./runtime.js\";\nimport { freezeSnapshot } from \"./snapshot.js\";\nimport type {\n  Implementations,\n  MachineConfig,\n  MachineDef,\n  Runtime,\n  RuntimeOptions,\n  Snapshot,\n  StateDef,\n} from \"./types.js\";\n\nexport class InvalidDefinitionError extends Error {\n  constructor(message: string) {\n    super(`aifsmjs: ${message}`);\n    this.name = \"InvalidDefinitionError\";\n  }\n}\n\nfunction validateDefinition<Ctx, Evt extends { type: string }, States extends string>(\n  def: MachineDef<Ctx, Evt, States>,\n): void {\n  if (!def.id || typeof def.id !== \"string\") {\n    throw new InvalidDefinitionError(\"definition must have a non-empty string `id`\");\n  }\n  /* v8 ignore next 3 — additional safety: TS prevents non-object `states`; this guards untyped JS callers. */\n  if (!def.states || typeof def.states !== \"object\") {\n    throw new InvalidDefinitionError(\"definition must have a `states` object\");\n  }\n  const stateKeys = Object.keys(def.states) as States[];\n  if (stateKeys.length === 0) {\n    throw new InvalidDefinitionError(\"`states` must declare at least one state\");\n  }\n  if (!def.initial || !stateKeys.includes(def.initial)) {\n    throw new InvalidDefinitionError(\n      `\\`initial\\` \"${String(def.initial)}\" is not declared in states (${stateKeys.join(\", \")})`,\n    );\n  }\n  for (const [stateName, stateDef] of Object.entries(def.states) as [\n    States,\n    (typeof def.states)[States],\n  ][]) {\n    // §4 shallow sub-shape check (~35 B gzip)\n    if (stateDef.sub !== undefined) {\n      const sub = stateDef.sub;\n      const subStates = (sub as { states?: unknown }).states;\n      const subInitial = (sub as { initial?: unknown }).initial;\n      if (\n        typeof sub !== \"object\" ||\n        sub === null ||\n        typeof subStates !== \"object\" ||\n        subStates === null ||\n        typeof subInitial !== \"string\" ||\n        // initial must name one of the sub's own states — otherwise the child\n        // boots pointing at a non-existent state and no-ops forever (FSM-S-02).\n        !Object.hasOwn(subStates as object, subInitial)\n      ) {\n        throw new InvalidDefinitionError(\n          `state \"${stateName}\".sub is not a valid sub-machine definition (missing states or initial)`,\n        );\n      }\n    }\n    if (!stateDef.on) continue;\n    for (const [evtType, entry] of Object.entries(stateDef.on)) {\n      const transitions = normalizeTransitions(entry);\n      for (const t of transitions) {\n        if (t.target !== undefined && !stateKeys.includes(t.target)) {\n          throw new InvalidDefinitionError(\n            `transition ${stateName} -[${evtType}]-> \"${String(t.target)}\" targets an unknown state`,\n          );\n        }\n        if (t.guard !== undefined && isAsyncGuardFn(t.guard)) {\n          throw new InvalidDefinitionError(\n            `transition ${stateName} -[${evtType}]-> uses an async guard. Guards must be sync; move I/O into an effect.`,\n          );\n        }\n      }\n    }\n  }\n}\n\n/**\n * Validate a machine definition shape and return it. When `context` is\n * provided the same reference is returned; when it is omitted a shallow copy\n * with `context: {}` is returned. Validation is intentionally shallow.\n *\n * Two call forms:\n *\n *   defineMachine<Ctx, Evt, States>({ ... })\n *     Explicit generics. Use when you need full control (e.g. union event\n *     types). Required because TypeScript cannot otherwise infer `Evt`.\n *\n *   setup<Ctx, Evt>().defineMachine({ ... })\n *     Curried form. Lets `States` be inferred from `keyof states`, so you\n *     can omit it. Recommended for typical usage.\n */\nexport function defineMachine<\n  Ctx = Record<string, never>,\n  Evt extends { type: string } = { type: string },\n  States extends string = string,\n>(def: MachineConfig<Ctx, Evt, States>): MachineDef<Ctx, Evt, States> {\n  const normalized = (!(\"context\" in def) ? { ...def, context: {} as Ctx } : def) as MachineDef<\n    Ctx,\n    Evt,\n    States\n  >;\n  validateDefinition(normalized);\n  return normalized;\n}\n\n/**\n * Curried builder so `States` can be inferred from `keyof states` without\n * `initial` collapsing it to a single literal. Pass `Ctx` and `Evt` as the\n * type arguments; pass the def to the returned `defineMachine`.\n *\n *   const machine = setup<MyCtx, MyEvt>().defineMachine({\n *     id: \"m\",\n *     initial: \"a\",\n *     context: { ... },\n *     states: { a: {...}, b: {...} },  // States inferred as \"a\" | \"b\"\n *   });\n */\nexport function setup<\n  Ctx = Record<string, never>,\n  Evt extends { type: string } = { type: string },\n>(): {\n  defineMachine: <const States extends string>(\n    def: Readonly<{\n      id: string;\n      initial: NoInfer<States>;\n      states: Readonly<Record<States, StateDef<Ctx, Evt, States>>>;\n    }> &\n      (Record<string, never> extends Ctx ? { readonly context?: Ctx } : { readonly context: Ctx }),\n  ) => MachineDef<Ctx, Evt, States>;\n} {\n  return {\n    defineMachine: <const States extends string>(\n      def: Readonly<{\n        id: string;\n        initial: NoInfer<States>;\n        states: Readonly<Record<States, StateDef<Ctx, Evt, States>>>;\n      }> &\n        (Record<string, never> extends Ctx\n          ? { readonly context?: Ctx }\n          : { readonly context: Ctx }),\n    ) => {\n      const cast = (!(\"context\" in def)\n        ? { ...def, context: {} as Ctx }\n        : def) as unknown as MachineDef<Ctx, Evt, States>;\n      validateDefinition(cast);\n      return cast;\n    },\n  };\n}\n\n/**\n * Build the initial snapshot for a machine.\n */\nexport function initialSnapshot<Ctx, Evt extends { type: string }, States extends string>(\n  def: MachineDef<Ctx, Evt, States>,\n): Snapshot<Ctx, States> {\n  const isFinal = def.states[def.initial]?.final === true;\n  return freezeSnapshot({\n    value: def.initial,\n    context: def.context,\n    status: isFinal ? (\"final\" as const) : (\"active\" as const),\n  });\n}\n\n/**\n * Convenience factory that composes `defineMachine` and `createRuntime` in\n * one call for the common case where you do not need to keep the machine\n * definition around for serialization or sharing.\n *\n * For type inference over `States` from `keyof states`, prefer\n * `setup<Ctx, Evt>().defineMachine(...)` then pass the result to\n * `createRuntime` separately. `createMachine` is the spec-style entry point\n * documented in the ai*js ecosystem review.\n */\nexport function createMachine<Ctx, Evt extends { type: string }, States extends string>(\n  def: MachineDef<Ctx, Evt, States>,\n  impl: Implementations<Ctx, Evt>,\n  opts?: RuntimeOptions<Ctx, Evt, States>,\n): Runtime<Ctx, Evt, States> {\n  return createRuntime(defineMachine(def), impl, opts ?? {});\n}\n","import { initialSnapshot } from \"./definition.js\";\nimport { evalGuard, isThenable } from \"./evaluator.js\";\nimport { step } from \"./lifecycle.js\";\nimport { normalizeTransitions } from \"./resolver.js\";\nimport { deepFreeze } from \"./snapshot.js\";\nimport {\n  type Effect,\n  type Implementations,\n  type MachineDef,\n  type Middleware,\n  RESET_EVENT_TYPE,\n  type ResetEvent,\n  type Runtime,\n  type RuntimeEventMap,\n  type RuntimeOptions,\n  type RuntimeTransitionEvent,\n  type Snapshot,\n} from \"./types.js\";\n\nexport class RuntimeDisposedError extends Error {\n  constructor() {\n    super(\"aifsmjs: runtime has been disposed; send()/reset() are not allowed\");\n    this.name = \"RuntimeDisposedError\";\n  }\n}\n\n/**\n * Thrown by `send()` / `reset()` when a sub-machine init or dispose throws.\n *\n * Invariants:\n * - `phase: \"init\"` — child constructor threw. Parent snapshot was rolled\n *   back to `prev`; no middleware ran; no `'transition'` emitted; no effects.\n * - `phase: \"dispose\"` — previous child's `dispose()` threw during transition.\n *   Parent snapshot was rolled back to `prev`; child reference is cleared.\n * - Never thrown from `runtime.dispose()` cascade (never-throws contract).\n *\n * @since 0.3.0\n */\nexport class SubMachineError extends Error {\n  readonly parentState: string;\n  readonly phase: \"init\" | \"dispose\";\n  override readonly cause: unknown;\n\n  constructor(parentState: string, phase: \"init\" | \"dispose\", cause: unknown) {\n    super(`aifsmjs: sub-machine ${phase} failed at parent state \"${parentState}\"`, { cause });\n    this.name = \"SubMachineError\";\n    this.parentState = parentState;\n    this.phase = phase;\n    this.cause = cause; // belt-and-suspenders: legacy bundlers ignore ES2022 cause option\n  }\n}\n\nconst RESET_EVENT: ResetEvent = Object.freeze({ type: RESET_EVENT_TYPE });\n\nfunction composeMiddleware<Ctx, Evt, States extends string>(\n  middleware: readonly Middleware<Ctx, Evt, States>[],\n): Middleware<Ctx, Evt, States> {\n  return (ctx, finalNext) => {\n    let index = -1;\n    const dispatch = (i: number): void => {\n      if (i <= index) throw new Error(\"aifsmjs: next() called multiple times in middleware\");\n      index = i;\n      const fn = middleware[i];\n      if (!fn) {\n        finalNext();\n        return;\n      }\n      fn(ctx, () => dispatch(i + 1));\n    };\n    dispatch(0);\n  };\n}\n\n/**\n * Build a thin stateful runtime around a machine. `send()` calls `step()`,\n * runs the read-only middleware pipeline, dispatches effects, and notifies\n * subscribers. The runtime owns an `AbortController`; `dispose()` aborts it\n * and clears all state.\n */\nexport function createRuntime<Ctx, Evt extends { type: string }, States extends string>(\n  def: MachineDef<Ctx, Evt, States>,\n  impl: Implementations<Ctx, Evt>,\n  opts: RuntimeOptions<Ctx, Evt, States> = {},\n): Runtime<Ctx, Evt, States> {\n  let snapshot: Snapshot<Ctx, States> = initialSnapshot(def);\n  const listeners = new Set<(snap: Snapshot<Ctx, States>) => void>();\n  const middlewareChain =\n    opts.middleware && opts.middleware.length > 0 ? composeMiddleware(opts.middleware) : undefined;\n  const shouldDispatch = opts.dispatchEffects !== false;\n  const controller = new AbortController();\n  let disposed = false;\n  // §3.1 sub-machine state. childRuntime is the live child; childAbortCleanup\n  // detaches the parent-abort listener attached by wireChildAbort. Both are\n  // cleared together whenever the child is replaced or disposed (P1-3 fix).\n  let childRuntime: Runtime<unknown, { type: string }, string> | undefined;\n  let childAbortCleanup: (() => void) | undefined;\n\n  type EventListeners = {\n    [K in keyof RuntimeEventMap<Ctx, Evt, States>]: Set<\n      (payload: RuntimeEventMap<Ctx, Evt, States>[K]) => void\n    >;\n  };\n  const eventListeners: EventListeners = {\n    transition: new Set(),\n    error: new Set(),\n    dispose: new Set(),\n  };\n  const externalAbortCleanups = new Set<() => void>();\n\n  function emit<K extends keyof RuntimeEventMap<Ctx, Evt, States>>(\n    type: K,\n    payload: RuntimeEventMap<Ctx, Evt, States>[K],\n  ): void {\n    // Snapshot-before-iterate (family canonical, aieventjs .slice()): a\n    // listener that subscribes/unsubscribes another during dispatch must not\n    // mutate the set being walked. One array alloc per emit, matching the\n    // family's accepted cost (FAM-S-03).\n    for (const fn of Array.from(eventListeners[type])) fn(payload);\n  }\n\n  function notify(committed?: Snapshot<Ctx, States>) {\n    const captured = committed ?? snapshot;\n    // Snapshot-before-iterate, as above (FAM-S-03).\n    for (const l of Array.from(listeners)) l(captured);\n  }\n\n  function runMiddleware(\n    prev: Snapshot<Ctx, States>,\n    event: Evt | ResetEvent,\n    effects: readonly Effect[],\n    changed: boolean,\n  ) {\n    if (!middlewareChain) return;\n    middlewareChain(deepFreeze({ prev, next: snapshot, event, effects, changed }), () => {});\n  }\n\n  function dispatchEffects(effects: readonly Effect[], context: Ctx, event: Evt): void {\n    if (!impl.effects || effects.length === 0) return;\n    for (const eff of effects) {\n      const handler = impl.effects[eff.type];\n      if (!handler) continue;\n      const r = handler(eff, { context, event, signal: controller.signal });\n      // isThenable (not instanceof Promise) so cross-realm Promises and\n      // user-defined PromiseLike results also have their rejections routed to\n      // the 'error' channel; Promise.resolve() normalises them (FSM-B-03).\n      if (isThenable(r)) {\n        Promise.resolve(r).catch((err: unknown) => {\n          emit(\"error\", { error: err, event });\n        });\n      }\n    }\n  }\n\n  // §3.1 Attach one-shot abort listener: parent dispose → child.dispose().\n  // Returns a cleanup fn that detaches the listener; caller stores it in\n  // `childAbortCleanup` and invokes when the child is replaced/disposed\n  // (P1-3 fix: prevent stale listeners accumulating on the parent signal).\n  function wireChildAbort(child: Runtime<unknown, { type: string }, string>): () => void {\n    /* v8 ignore next 7 — parent may already be aborted in edge cases; dispose still runs */\n    if (controller.signal.aborted) {\n      try {\n        child.dispose();\n      } catch {\n        /* swallow */\n      }\n      return () => {};\n    }\n    /* v8 ignore next 7 — defensive: dispose() pre-cleans this listener and\n       disposes the child manually before calling controller.abort(), so\n       onAbort fires only if external code aborts the controller bypassing\n       dispose(). Internal-only controller has no such external path today. */\n    const onAbort = () => {\n      try {\n        child.dispose();\n      } catch {\n        /* swallow */\n      }\n    };\n    controller.signal.addEventListener(\"abort\", onAbort, { once: true });\n    return () => controller.signal.removeEventListener(\"abort\", onAbort);\n  }\n\n  // §3.1 Instantiate the child for `stateValue` (which must have a `sub`) and\n  // wire its parent-abort listener, committing both to childRuntime /\n  // childAbortCleanup. Throws SubMachineError(phase: \"init\") on failure; the\n  // caller must NOT commit the parent snapshot on throw. Single source of the\n  // init+wire sequence shared by applySubLifecycle, reset(), and bootstrap\n  // (FSM-C-01) — keeps the most failure-sensitive path in one place.\n  function initChildFor(stateValue: States): void {\n    const stateDef = def.states[stateValue];\n    const sub = stateDef?.sub;\n    /* v8 ignore next 2 — callers only invoke this after checking stateDef.sub\n       is defined; the guard documents that precondition and is never taken. */\n    if (sub === undefined) return;\n    let newChild: Runtime<unknown, { type: string }, string>;\n    try {\n      newChild = createRuntime(sub, stateDef.subImpl ?? {});\n    } catch (cause) {\n      throw new SubMachineError(stateValue as string, \"init\", cause);\n    }\n    childRuntime = newChild;\n    childAbortCleanup = wireChildAbort(newChild);\n  }\n\n  // §3.3 Re-resolve guards to find the chosen transition and determine\n  // whether it is external (has a `target`). Replaces the v0.3.0 dev\n  // hasSelfTargetMarker heuristic that over-reported when an event had both\n  // internal (no-target) and self-target (target === value) candidates\n  // (P1-2 fix). Cost: one extra guard evaluation pass per same-value event.\n  function findChosenIsExternal(value: States, event: Evt, context: Ctx): boolean {\n    const state = def.states[value];\n    if (!state?.on) return false;\n    const list = normalizeTransitions(state.on[event.type]);\n    if (list.length === 0) return false;\n    for (const t of list) {\n      if (!t.guard || evalGuard(t.guard, context, event, impl, value)) {\n        return t.target !== undefined;\n      }\n    }\n    /* v8 ignore next — defensive: caller only invokes when step() returned\n       changed=true, which guarantees a matching guard exists in the same\n       candidate list. The for-loop above always returns before this line. */\n    return false;\n  }\n\n  // §3.1 Dispose old child and/or init new child. Throws SubMachineError on failure.\n  // Caller must NOT commit snapshot on throw.\n  function applySubLifecycle(prevValue: States, nextValue: States): void {\n    const prevStateDef = def.states[prevValue];\n    const nextStateDef = def.states[nextValue];\n    if (prevStateDef?.sub !== undefined && childRuntime !== undefined) {\n      const child = childRuntime;\n      childRuntime = undefined;\n      childAbortCleanup?.();\n      childAbortCleanup = undefined;\n      try {\n        child.dispose();\n      } catch (cause) {\n        throw new SubMachineError(prevValue as string, \"dispose\", cause);\n      }\n    }\n    if (nextStateDef?.sub !== undefined) {\n      initChildFor(nextValue);\n    }\n  }\n\n  function send(event: Evt): Snapshot<Ctx, States> {\n    if (disposed) throw new RuntimeDisposedError();\n    const prev = snapshot;\n    const result = step(def, prev, event, impl);\n    const isExternal =\n      result.changed &&\n      (prev.value !== result.snapshot.value ||\n        findChosenIsExternal(prev.value, event, prev.context));\n    // Sub lifecycle BEFORE snapshot commit (§3.4); throws SubMachineError on failure → no commit\n    if (result.changed && isExternal) applySubLifecycle(prev.value, result.snapshot.value);\n    snapshot = result.snapshot;\n    const committed = result.snapshot;\n    runMiddleware(prev, event, result.effects, result.changed);\n    if (shouldDispatch) dispatchEffects(result.effects, committed.context, event);\n    if (result.changed) {\n      notify(committed);\n      emit(\"transition\", {\n        prev,\n        next: committed,\n        event,\n        effects: result.effects,\n        changed: true,\n      } as RuntimeTransitionEvent<Ctx, Evt, States>);\n    }\n    return snapshot;\n  }\n\n  function reset(event?: Evt): Snapshot<Ctx, States> {\n    if (disposed) throw new RuntimeDisposedError();\n    const prev = snapshot;\n    const nextSnap = initialSnapshot(def);\n    const changed = prev.value !== nextSnap.value;\n    // Dispose current child (§3.5)\n    if (childRuntime) {\n      const child = childRuntime;\n      childRuntime = undefined;\n      childAbortCleanup?.();\n      childAbortCleanup = undefined;\n      try {\n        child.dispose();\n      } catch (cause) {\n        throw new SubMachineError(prev.value as string, \"dispose\", cause);\n      }\n    }\n    // Init child for new initial state if it has sub (§3.5)\n    const initStateDef = def.states[nextSnap.value];\n    if (initStateDef?.sub) {\n      initChildFor(nextSnap.value);\n    }\n    snapshot = nextSnap;\n    // Capture the committed snapshot before notify()/emit so a subscriber that\n    // re-entrantly send()s (which advances the mutable `snapshot`) cannot\n    // corrupt this reset's payload — mirrors send()'s 0.2.0 fix (FSM-B-01).\n    const committed = nextSnap;\n    const triggerEvent: Evt | ResetEvent = event ?? RESET_EVENT;\n    runMiddleware(prev, triggerEvent, [], changed);\n    if (changed) {\n      notify(committed);\n      emit(\"transition\", {\n        prev,\n        next: committed,\n        event: triggerEvent,\n        effects: [],\n        changed: true,\n      } as RuntimeTransitionEvent<Ctx, Evt, States>);\n    }\n    // Return the live snapshot (consistent with send()): under a re-entrant\n    // send() from a subscriber, this reflects the latest committed state. Only\n    // the emitted payload above is pinned to this reset's own outcome.\n    return snapshot;\n  }\n\n  function can(event: Evt): boolean {\n    if (disposed || snapshot.status === \"final\") return false;\n    const state = def.states[snapshot.value];\n    /* v8 ignore next — defensive: snapshot.value always corresponds to a declared state. */\n    if (!state) return false;\n    const list = normalizeTransitions(state.on?.[event.type]);\n    if (list.length === 0) return false;\n    for (const t of list) {\n      if (!t.guard) return true;\n      if (evalGuard(t.guard, snapshot.context, event, impl, snapshot.value)) return true;\n    }\n    return false;\n  }\n\n  function on<K extends keyof RuntimeEventMap<Ctx, Evt, States>>(\n    type: K,\n    listener: (payload: RuntimeEventMap<Ctx, Evt, States>[K]) => void,\n    options?: { signal?: AbortSignal; once?: boolean },\n  ): () => void {\n    if (disposed || options?.signal?.aborted) return () => {};\n    const target = eventListeners[type];\n    let detachAbort: (() => void) | undefined;\n    // Full teardown shared by the once-wrapper, the abort handler, and the\n    // returned unsubscribe so every path detaches the abort listener too — a\n    // once-handler that also passed a { signal } previously left the abort\n    // listener attached until dispose()/abort (memory leak).\n    const cleanup = (): void => {\n      target.delete(wrapped);\n      if (detachAbort) {\n        detachAbort();\n        externalAbortCleanups.delete(detachAbort);\n      }\n    };\n    let wrapped: (payload: RuntimeEventMap<Ctx, Evt, States>[K]) => void = listener;\n    if (options?.once) {\n      wrapped = (payload) => {\n        cleanup();\n        listener(payload);\n      };\n    }\n    target.add(wrapped);\n    const signal = options?.signal;\n    if (signal) {\n      const onAbort = () => cleanup();\n      signal.addEventListener(\"abort\", onAbort, { once: true });\n      detachAbort = () => signal.removeEventListener(\"abort\", onAbort);\n      externalAbortCleanups.add(detachAbort);\n    }\n    return cleanup;\n  }\n\n  function dispose(): void {\n    if (disposed) return;\n    disposed = true;\n    // Cascade child dispose; swallow exceptions (dispose contract) (§3.6)\n    if (childRuntime) {\n      childAbortCleanup?.();\n      childAbortCleanup = undefined;\n      try {\n        childRuntime.dispose();\n      } catch {\n        /* swallow */\n      }\n      childRuntime = undefined;\n    }\n    controller.abort();\n    listeners.clear();\n    emit(\"dispose\", undefined as RuntimeEventMap<Ctx, Evt, States>[\"dispose\"]);\n    for (const set of Object.values(eventListeners)) set.clear();\n    for (const cleanup of externalAbortCleanups) cleanup();\n    externalAbortCleanups.clear();\n  }\n\n  const runtime: Runtime<Ctx, Evt, States> = {\n    getSnapshot: () => snapshot,\n    snapshot: () => snapshot,\n    send,\n    can,\n    reset,\n    dispose,\n    on,\n    get disposed() {\n      return disposed;\n    },\n    get signal() {\n      return controller.signal;\n    },\n    subscribe(listener) {\n      if (disposed) return () => {};\n      listeners.add(listener);\n      return () => listeners.delete(listener);\n    },\n    subRuntime: () => childRuntime,\n    onTransition: (handler, options) => on(\"transition\", handler, options),\n  };\n\n  // §2 Bootstrap: if initial state has sub, instantiate child BEFORE returning.\n  // Failure throws SubMachineError(initialState, \"init\", cause).\n  const bootStateDef = def.states[snapshot.value];\n  if (bootStateDef?.sub) {\n    initChildFor(snapshot.value);\n  }\n\n  return runtime;\n}\n"]}

package/dist/chunk-ZLQ7HZCE.js

@@ -0,0 +1,142 @@
+import { createEnqueuer } from './chunk-JKZAOPQC.js';
+import { evalGuard } from './chunk-A7U7QQL5.js';
+
+// src/fsm/resolver.ts
+function normalizeTransition(entry) {
+  return typeof entry === "string" ? { target: entry } : entry;
+}
+function normalizeTransitions(entry) {
+  if (entry === void 0) return [];
+  if (Array.isArray(entry)) {
+    return entry.some((t) => typeof t === "string") ? entry.map((t) => normalizeTransition(t)) : entry;
+  }
+  return [normalizeTransition(entry)];
+}
+function resolveTransitions(def, stateValue, eventType) {
+  const state = def.states[stateValue];
+  if (!state || !state.on) return [];
+  return normalizeTransitions(state.on[eventType]);
+}
+
+// src/fsm/snapshot.ts
+var IS_DEV = typeof process !== "undefined" && typeof process.env !== "undefined" && process.env.NODE_ENV !== "production";
+function isPlainObject(value) {
+  if (value === null || typeof value !== "object") return false;
+  const proto = Object.getPrototypeOf(value);
+  return proto === Object.prototype || proto === null;
+}
+function deepFreeze(value) {
+  if (value === null || typeof value !== "object") return value;
+  if (Object.isFrozen(value)) return value;
+  Object.freeze(value);
+  if (Array.isArray(value)) {
+    for (const item of value) deepFreeze(item);
+  } else if (isPlainObject(value)) {
+    for (const key of Object.keys(value)) {
+      deepFreeze(value[key]);
+    }
+  }
+  return value;
+}
+function freezeSnapshot(snap) {
+  return IS_DEV ? deepFreeze(snap) : Object.freeze(snap);
+}
+function createSnapshot(args) {
+  return freezeSnapshot({
+    value: args.value,
+    context: args.context,
+    status: args.status ?? "active"
+  });
+}
+
+// src/fsm/updater.ts
+function isPlainRecord(value) {
+  if (value === null || typeof value !== "object") return false;
+  const proto = Object.getPrototypeOf(value);
+  return proto === Object.prototype || proto === null;
+}
+function assign(updater) {
+  return ({ context, event }) => updater({ context, event });
+}
+function mergeContext(current, patch) {
+  if (patch === void 0 || patch === null) return current;
+  if (isPlainRecord(current) && isPlainRecord(patch)) {
+    return { ...current, ...patch };
+  }
+  return patch;
+}
+
+// src/fsm/lifecycle.ts
+var UnknownActionError = class extends Error {
+  actionName;
+  constructor(actionName) {
+    super(`aifsmjs: action "${actionName}" not found in implementations.actions`);
+    this.name = "UnknownActionError";
+    this.actionName = actionName;
+  }
+};
+function resolveAction(ref, impl) {
+  if (typeof ref === "function") return ref;
+  const fn = impl.actions?.[ref];
+  if (!fn) throw new UnknownActionError(ref);
+  return fn;
+}
+function runActions(refs, ctx, event, impl, effectSink) {
+  if (!refs || refs.length === 0) return ctx;
+  const enqueue = createEnqueuer(effectSink);
+  let current = ctx;
+  for (const ref of refs) {
+    const fn = resolveAction(ref, impl);
+    const patch = fn({ context: current, event, enqueue });
+    current = mergeContext(current, patch);
+  }
+  return current;
+}
+function pickTransition(candidates, ctx, event, impl, value) {
+  for (const t of candidates) {
+    if (!t.guard) return t;
+    if (evalGuard(t.guard, ctx, event, impl, value)) return t;
+  }
+  return void 0;
+}
+function step(def, snapshot, event, impl) {
+  if (snapshot.status === "final") {
+    return Object.freeze({ snapshot, effects: [], changed: false });
+  }
+  const state = def.states[snapshot.value];
+  if (!state) {
+    return Object.freeze({ snapshot, effects: [], changed: false });
+  }
+  const candidateList = normalizeTransitions(state.on?.[event.type]);
+  const chosen = pickTransition(candidateList, snapshot.context, event, impl, snapshot.value);
+  if (!chosen) {
+    return Object.freeze({ snapshot, effects: [], changed: false });
+  }
+  const isExternal = chosen.target !== void 0;
+  const nextStateValue = chosen.target ?? snapshot.value;
+  const nextState = def.states[nextStateValue];
+  const effectSink = [];
+  let ctx = snapshot.context;
+  if (isExternal) {
+    ctx = runActions(state.exit, ctx, event, impl, effectSink);
+  }
+  ctx = runActions(chosen.actions, ctx, event, impl, effectSink);
+  if (isExternal && nextState) {
+    ctx = runActions(nextState.entry, ctx, event, impl, effectSink);
+  }
+  const status = nextState?.final === true ? "final" : "active";
+  const nextSnapshot = freezeSnapshot({
+    value: nextStateValue,
+    context: ctx,
+    status
+  });
+  return Object.freeze({
+    snapshot: nextSnapshot,
+    effects: Object.freeze(effectSink.slice()),
+    changed: true
+  });
+}
+
+export { UnknownActionError, assign, createSnapshot, deepFreeze, freezeSnapshot, mergeContext, normalizeTransition, normalizeTransitions, resolveTransitions, step };
+//# sourceMappingURL=chunk-ZLQ7HZCE.js.map
+//# sourceMappingURL=chunk-ZLQ7HZCE.js.map

package/dist/chunk-ZLQ7HZCE.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/fsm/resolver.ts","../src/fsm/snapshot.ts","../src/fsm/updater.ts","../src/fsm/lifecycle.ts"],"names":[],"mappings":"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","file":"chunk-ZLQ7HZCE.js","sourcesContent":["import type { MachineDef, TransitionConfig, TransitionDef } from \"./types.js\";\n\n/**\n * Normalize a single transition config into its object form. The string\n * shorthand `\"targetState\"` (à la XState) becomes `{ target: \"targetState\" }`;\n * the object form is returned unchanged. Centralised here so every consumer\n * (`step`, `resolveTransitions`, `can`, validation) sees the same shape.\n *\n * @since 0.5.3\n */\nexport function normalizeTransition<Ctx, Evt, States extends string>(\n  entry: TransitionConfig<Ctx, Evt, States>,\n): TransitionDef<Ctx, Evt, States> {\n  return typeof entry === \"string\" ? ({ target: entry } as TransitionDef<Ctx, Evt, States>) : entry;\n}\n\n/**\n * Normalize the raw `state.on[eventType]` value (object, string shorthand, or\n * an array mixing both) into an ordered list of {@link TransitionDef} objects.\n * Declaration order is preserved.\n *\n * @since 0.5.3\n */\nexport function normalizeTransitions<Ctx, Evt, States extends string>(\n  entry:\n    | TransitionConfig<Ctx, Evt, States>\n    | readonly TransitionConfig<Ctx, Evt, States>[]\n    | undefined,\n): readonly TransitionDef<Ctx, Evt, States>[] {\n  if (entry === undefined) return [];\n  if (Array.isArray(entry)) {\n    // Hot path (send/step/can run this per event): when no string shorthand is\n    // present, return the original array instead of allocating a normalized copy.\n    return entry.some((t) => typeof t === \"string\")\n      ? entry.map((t) => normalizeTransition(t))\n      : (entry as readonly TransitionDef<Ctx, Evt, States>[]);\n  }\n  return [normalizeTransition(entry as TransitionConfig<Ctx, Evt, States>)];\n}\n\n/**\n * Return all transition candidates for (state, eventType). Order is preserved\n * from the declaration so that guard fallthrough behaves predictably. String\n * shorthands are normalized to `{ target }` objects.\n *\n * If the event has no entry under the given state, an empty array is returned.\n */\nexport function resolveTransitions<Ctx, Evt extends { type: string }, States extends string>(\n  def: MachineDef<Ctx, Evt, States>,\n  stateValue: States,\n  eventType: string,\n): readonly TransitionDef<Ctx, Evt, States>[] {\n  const state = def.states[stateValue];\n  if (!state || !state.on) return [];\n  return normalizeTransitions(state.on[eventType]);\n}\n","import type { Snapshot } from \"./types.js\";\n\nconst IS_DEV =\n  typeof process !== \"undefined\" &&\n  typeof process.env !== \"undefined\" &&\n  process.env.NODE_ENV !== \"production\";\n\nfunction isPlainObject(value: unknown): value is Record<string, unknown> {\n  if (value === null || typeof value !== \"object\") return false;\n  const proto = Object.getPrototypeOf(value);\n  return proto === Object.prototype || proto === null;\n}\n\nexport function deepFreeze<T>(value: T): T {\n  if (value === null || typeof value !== \"object\") return value;\n  if (Object.isFrozen(value)) return value;\n  Object.freeze(value);\n  if (Array.isArray(value)) {\n    for (const item of value) deepFreeze(item);\n  } else if (isPlainObject(value)) {\n    for (const key of Object.keys(value)) {\n      deepFreeze((value as Record<string, unknown>)[key]);\n    }\n  }\n  return value;\n}\n\n/**\n * Wrap a freshly built snapshot. In dev mode the whole tree is deep-frozen so\n * accidental mutation throws immediately. In production only the top object is\n * frozen, keeping the cost negligible.\n */\nexport function freezeSnapshot<C, S extends string>(snap: Snapshot<C, S>): Snapshot<C, S> {\n  // IS_DEV is always true in vitest; the production branch (`Object.freeze`)\n  // is exercised only when NODE_ENV === \"production\" and is intentionally\n  // left out of the coverage threshold.\n  return IS_DEV ? deepFreeze(snap) : Object.freeze(snap);\n}\n\nexport function createSnapshot<C, S extends string>(args: {\n  value: S;\n  context: C;\n  status?: \"active\" | \"final\";\n}): Snapshot<C, S> {\n  return freezeSnapshot({\n    value: args.value,\n    context: args.context,\n    status: args.status ?? \"active\",\n  });\n}\n","import type { Action } from \"./types.js\";\n\nfunction isPlainRecord(value: unknown): value is Record<string, unknown> {\n  if (value === null || typeof value !== \"object\") return false;\n  const proto = Object.getPrototypeOf(value);\n  return proto === Object.prototype || proto === null;\n}\n\n/**\n * Build an Action that returns a Partial<Ctx> from a pure updater.\n * The partial is merged into the current context by `step()`.\n */\nexport function assign<Ctx, Evt>(\n  updater: (args: { context: Ctx; event: Evt }) => Partial<Ctx>,\n): Action<Ctx, Evt> {\n  return ({ context, event }) => updater({ context, event });\n}\n\n/**\n * Merge a partial context update into the current context. Plain-object\n * contexts get a shallow merge; non-object contexts get replaced wholesale.\n *\n * The function never mutates either argument.\n */\nexport function mergeContext<Ctx>(current: Ctx, patch: Partial<Ctx> | void): Ctx {\n  if (patch === undefined || patch === null) return current;\n  if (isPlainRecord(current) && isPlainRecord(patch)) {\n    return { ...current, ...patch } as Ctx;\n  }\n  return patch as Ctx;\n}\n","import { createEnqueuer } from \"../effects/enqueuer.js\";\nimport { evalGuard } from \"./evaluator.js\";\nimport { normalizeTransitions } from \"./resolver.js\";\nimport { freezeSnapshot } from \"./snapshot.js\";\nimport type {\n  Action,\n  ActionRef,\n  Effect,\n  Implementations,\n  MachineDef,\n  Snapshot,\n  StepResult,\n  TransitionDef,\n} from \"./types.js\";\nimport { mergeContext } from \"./updater.js\";\n\nexport class UnknownActionError extends Error {\n  readonly actionName: string;\n  constructor(actionName: string) {\n    super(`aifsmjs: action \"${actionName}\" not found in implementations.actions`);\n    this.name = \"UnknownActionError\";\n    this.actionName = actionName;\n  }\n}\n\nfunction resolveAction<Ctx, Evt>(\n  ref: ActionRef<Ctx, Evt>,\n  impl: Implementations<Ctx, Evt>,\n): Action<Ctx, Evt> {\n  if (typeof ref === \"function\") return ref;\n  const fn = impl.actions?.[ref];\n  if (!fn) throw new UnknownActionError(ref);\n  return fn;\n}\n\nfunction runActions<Ctx, Evt>(\n  refs: readonly ActionRef<Ctx, Evt>[] | undefined,\n  ctx: Ctx,\n  event: Evt,\n  impl: Implementations<Ctx, Evt>,\n  effectSink: Effect[],\n): Ctx {\n  if (!refs || refs.length === 0) return ctx;\n  const enqueue = createEnqueuer(effectSink as { type: string; payload?: unknown }[]);\n  let current = ctx;\n  for (const ref of refs) {\n    const fn = resolveAction(ref, impl);\n    const patch = fn({ context: current, event, enqueue });\n    current = mergeContext(current, patch);\n  }\n  return current;\n}\n\nfunction pickTransition<Ctx, Evt, States extends string>(\n  candidates: readonly TransitionDef<Ctx, Evt, States>[],\n  ctx: Ctx,\n  event: Evt,\n  impl: Implementations<Ctx, Evt>,\n  value: States,\n): TransitionDef<Ctx, Evt, States> | undefined {\n  for (const t of candidates) {\n    if (!t.guard) return t;\n    if (evalGuard(t.guard, ctx, event, impl, value)) return t;\n  }\n  return undefined;\n}\n\n/**\n * Compute the next snapshot and collected effects from a single event.\n *\n * Order is fixed and uninterruptible:\n *   1. resolve candidate transitions for (state, event.type)\n *   2. evaluate guards in declaration order; pick the first passing one\n *   3. if external (target defined), run exit actions of the old state\n *   4. run transition.actions in declaration order\n *   5. if external, run entry actions of the new state\n *   6. return { snapshot, effects, changed }\n *\n * The function is pure: it never dispatches effects and never mutates inputs.\n */\nexport function step<Ctx, Evt extends { type: string }, States extends string>(\n  def: MachineDef<Ctx, Evt, States>,\n  snapshot: Snapshot<Ctx, States>,\n  event: Evt,\n  impl: Implementations<Ctx, Evt>,\n): StepResult<Ctx, States> {\n  // Final state is inert: it never reacts to events.\n  if (snapshot.status === \"final\") {\n    return Object.freeze({ snapshot, effects: [] as readonly Effect[], changed: false });\n  }\n\n  const state = def.states[snapshot.value];\n  /* v8 ignore next 3 — defensive: snapshot.value is always validated against def.states by defineMachine + initialSnapshot. */\n  if (!state) {\n    return Object.freeze({ snapshot, effects: [] as readonly Effect[], changed: false });\n  }\n\n  const candidateList = normalizeTransitions(state.on?.[event.type]);\n\n  const chosen = pickTransition(candidateList, snapshot.context, event, impl, snapshot.value);\n  if (!chosen) {\n    return Object.freeze({ snapshot, effects: [] as readonly Effect[], changed: false });\n  }\n\n  const isExternal = chosen.target !== undefined;\n  const nextStateValue = (chosen.target ?? snapshot.value) as States;\n  const nextState = def.states[nextStateValue];\n\n  const effectSink: Effect[] = [];\n  let ctx = snapshot.context;\n\n  if (isExternal) {\n    ctx = runActions(state.exit, ctx, event, impl, effectSink);\n  }\n  ctx = runActions(chosen.actions, ctx, event, impl, effectSink);\n  if (isExternal && nextState) {\n    ctx = runActions(nextState.entry, ctx, event, impl, effectSink);\n  }\n\n  const status: \"active\" | \"final\" = nextState?.final === true ? \"final\" : \"active\";\n  const nextSnapshot = freezeSnapshot({\n    value: nextStateValue,\n    context: ctx,\n    status,\n  });\n\n  return Object.freeze({\n    snapshot: nextSnapshot,\n    effects: Object.freeze(effectSink.slice()) as readonly Effect[],\n    changed: true,\n  });\n}\n"]}