aifsmjs 0.5.3 → 0.5.6

package/README.md

@@ -1,14 +1,16 @@
 # aifsmjs
 
 [![npm version](https://img.shields.io/npm/v/aifsmjs.svg)](https://www.npmjs.com/package/aifsmjs)
-[![CI](https://github.com/yshengliao/aifsmjs/actions/workflows/ci.yml/badge.svg)](https://github.com/yshengliao/aifsmjs/actions/workflows/ci.yml)
+[![CI](https://github.com/islumina/aifsmjs/actions/workflows/ci.yml/badge.svg)](https://github.com/islumina/aifsmjs/actions/workflows/ci.yml)
 [![License](https://img.shields.io/badge/license-MIT-brightgreen.svg)](LICENSE)
 [![AI Generated](https://img.shields.io/badge/AI_Generated-Claude_Code_Opus_4.7_Max-blueviolet.svg)](https://www.anthropic.com/claude-code)
 [![繁體中文](https://img.shields.io/badge/lang-繁體中文-red.svg)](README_ZHTW.md)
 
 > A small, strict FSM library for any TypeScript/JS app that needs deterministic, replayable state transitions. Lifecycle is a pure `step()` function. Chain-of-Responsibility intuition is reserved for cross-cutting concerns (observe / persist / replay), never for the transition core.
 
-Part of the [ai\*js micro-runtime ecosystem](https://github.com/yshengliao) — see also [aibridgejs](https://github.com/yshengliao/aibridgejs) (cross-context RPC) and [aiecsjs](https://github.com/yshengliao/aiecsjs) (ECS).
+Part of the [ai\*js micro-runtime ecosystem](https://github.com/islumina) — see also [aibridgejs](https://github.com/islumina/aibridgejs) (cross-context RPC) and [aiecsjs](https://github.com/islumina/aiecsjs) (ECS).
+
+> **Status: 0.5.6.** Core FSM, hierarchical sub-machines, guards & effects, scheduler, replay, inspect, and PBT helpers are all live. See [CHANGELOG.md](CHANGELOG.md) for release history.
 
 **Primary audience**: developers building stateful flows — multi-step forms, checkout funnels, auth flows, tutorial sequences, document-status workflows, scene flow in interactive apps, and the same patterns in browser-based games (PixiJS / Svelte 5 / plain Canvas / WebGL). The core is **environment-neutral** (pure function + adapter boundary): browser, Node, Bun, Deno, Flutter WebView, and Web Workers all work. The Roadmap section keeps gaming-specific niceties (tick hook, ECS bridge) as opt-in subpaths, not core surface.
 
@@ -289,6 +291,8 @@ const runtime = createRuntime(def, impl, {
 
 Koa-style `(ctx, next) => void` pipeline. `ctx` is `{ prev, next, event, effects, changed }`, all deep-frozen. **Cannot cancel a transition** — `next()` must be called; the return value carries no meaning.
 
+Two boundaries to respect (both stable for 1.x, detailed in [STABILITY.md](STABILITY.md)): skipping `next()` is **not** enforced and silently drops every later middleware (and the `recorder` / `persist` sinks) for that event; and a synchronous throw from a middleware (e.g. `persist` on non-serialisable context) propagates to the caller but leaves the snapshot **committed yet unannounced** — `notify()` and `on('transition')` are skipped. Do **not** call `runtime.send()` from inside the pipeline: the inner event runs its full pipeline before the outer frame finishes, so the `recorder` log is reordered and `replay()` diverges.
+
 ### `aifsmjs/replay` — Pure event log replay
 
 ```typescript
@@ -493,8 +497,8 @@ Example-first, PBT-augmented. Lesson from jssm: "3000+ tests / 100% coverage" tu
 
 - **Example tests** (vitest): for every src module, write happy path + edge + error-message triplets.
 - **PBT smoke**: each generic property runs 50 iterations as an invariant guard, not as a coverage source.
-- **CI-enforced thresholds**: `@vitest/coverage-v8` is wired to **100% statements / 100% lines / 100% functions / ≥90% branches**. The few defensive invariant-guard branches (e.g. runtime determinism mismatch) carry `/* v8 ignore */` annotations with rationale.
-- **Size budget**: `scripts/check-size.mjs` enforces per-subpath gzip caps in CI — core ≤4.7 KB (raised in 0.3.0 for sub-machine sugar), replay ≤1.8 KB, pbt ≤5.5 KB (raised in 0.3.0 because `pbt` transitively imports `createRuntime`), others ≤1 KB. Exceeding any cap fails the build.
+- **CI-enforced thresholds**: `@vitest/coverage-v8` is wired to **100% lines / 100% functions / ≥95% statements / ≥90% branches**. The few defensive invariant-guard branches (e.g. runtime determinism mismatch) carry `/* v8 ignore */` annotations with rationale.
+- **Size budget**: `scripts/check-size.mjs` enforces per-subpath gzip caps in CI, measured as each entry's transitive closure (entry + shared chunks — the build code-splits so error classes keep cross-subpath identity) — core ≤6.5 KB, pbt ≤8.5 KB (transitively imports `createRuntime`), replay ≤3.3 KB, effects ≤1.7 KB, guards ≤1.5 KB, timer ≤1.2 KB, inspect ≤1 KB. Exceeding any cap fails the build.
 
 ### The 6 built-in generic properties
 

package/README_ZHTW.md

@@ -1,14 +1,16 @@
 # aifsmjs
 
 [![npm version](https://img.shields.io/npm/v/aifsmjs.svg)](https://www.npmjs.com/package/aifsmjs)
-[![CI](https://github.com/yshengliao/aifsmjs/actions/workflows/ci.yml/badge.svg)](https://github.com/yshengliao/aifsmjs/actions/workflows/ci.yml)
+[![CI](https://github.com/islumina/aifsmjs/actions/workflows/ci.yml/badge.svg)](https://github.com/islumina/aifsmjs/actions/workflows/ci.yml)
 [![License](https://img.shields.io/badge/license-MIT-brightgreen.svg)](LICENSE)
 [![AI Generated](https://img.shields.io/badge/AI_Generated-Claude_Code_Opus_4.7_Max-blueviolet.svg)](https://www.anthropic.com/claude-code)
 [![English](https://img.shields.io/badge/lang-English-blue.svg)](README.md)
 
 > 一個小而嚴格的 FSM library，為任何需要可重現、可重播狀態流轉的 TypeScript/JS app 而生：把 lifecycle 寫成 pure `step()`，把 Chain-of-Responsibility 直覺收斂到 cross-cutting concerns（observe / persist / replay）── 而非 transition 主流程。
 
-隸屬 [ai\*js micro-runtime 生態系](https://github.com/yshengliao) ─ 另見 [aibridgejs](https://github.com/yshengliao/aibridgejs)（cross-context RPC）與 [aiecsjs](https://github.com/yshengliao/aiecsjs)（ECS）。
+隸屬 [ai\*js micro-runtime 生態系](https://github.com/islumina) ─ 另見 [aibridgejs](https://github.com/islumina/aibridgejs)（cross-context RPC）與 [aiecsjs](https://github.com/islumina/aiecsjs)（ECS）。
+
+> **狀態：0.5.6。** 核心 FSM、階層式 sub-machine、guards 與 effects、scheduler、replay、inspect、PBT helpers 全部上線。發版歷史見 [CHANGELOG.md](CHANGELOG.md)。
 
 **主要受眾**：所有處理 stateful flow 的工程師 ── 多步驟表單、checkout 流程、auth flow、教學引導步驟、文件審批狀態機、互動 app 的 scene flow，以及瀏覽器遊戲的相同模式（PixiJS / Svelte 5 / 純 Canvas / WebGL）。Library 本身**環境中立**（pure core + adapter 邊界）：browser、Node、Bun、Deno、Flutter WebView、Web Worker 全部都跑。Roadmap 段把遊戲特有的便利功能（tick hook、ECS bridge）保留為 opt-in subpath，不進 core surface。
 
@@ -288,7 +290,7 @@ const runtime = createRuntime(def, impl, {
 
 Koa-style `(ctx, next) => void` pipeline。`ctx` 是 `{ prev, next, event, effects, changed }`，全部 deep-frozen。**不能中止 transition**——`next()` 必呼叫，回傳值無語意。
 
-### `aifsmjs/replay` — Pure event log replay
+兩個須留意的邊界（1.x 內穩定，詳見 [STABILITY.md](STABILITY.md)）：跳過 `next()` **不會**被擋下，且該 event 之後的 middleware（含 `recorder` / `persist` sink）全部被靜默丟棄；middleware 同步 throw（例如 `persist` 遇非可序列化 context）會傳回 caller，但 snapshot **已 commit 卻未通知**——`notify()` 與 `on('transition')` 被跳過。請**勿**在 pipeline 內呼叫 `runtime.send()`：inner event 會先跑完整條 pipeline 才輪到 outer frame，導致 `recorder` log 順序錯置、`replay()` 發散。
 
 ```typescript
 import { replay } from "aifsmjs/replay";
@@ -487,8 +489,8 @@ aifsmjs 在幾個常見議題上做了刻意取捨，跟主流 FSM library 寫
 
 - **Example tests**（vitest）：對每個 src module 寫 happy path + 邊界 + error message 三類。
 - **PBT smoke**：每條 generic property 跑 50 runs，作為 invariant guard，不追求 coverage。
-- **CI 強制門檻**：`@vitest/coverage-v8` 設 **100% statements / 100% lines / 100% functions / ≥90% branches**。少數 defensive invariant-guard 分支（例如 runtime determinism mismatch）標 `/* v8 ignore */` 並寫明原因。
-- **Size budget**：`scripts/check-size.mjs` 在 CI 檢查每個 subpath gzip 大小，超過預算（core ≤4.7 KB、replay ≤1.8 KB、pbt ≤5.5 KB、其他 ≤1 KB；0.3.0 為了 sub-machine sugar 提高 core / pbt 上限）即 fail。
+- **CI 強制門檻**：`@vitest/coverage-v8` 設 **100% lines / 100% functions / ≥95% statements / ≥90% branches**。少數 defensive invariant-guard 分支（例如 runtime determinism mismatch）標 `/* v8 ignore */` 並寫明原因。
+- **Size budget**：`scripts/check-size.mjs` 在 CI 檢查每個 subpath gzip 大小，量測單位是 entry 的 transitive closure（entry + 共享 chunk——build 採 code-splitting 以維持 error class 跨 subpath identity），超過預算（core ≤6.5 KB、pbt ≤8.5 KB、replay ≤3.3 KB、effects ≤1.7 KB、guards ≤1.5 KB、timer ≤1.2 KB、inspect ≤1 KB）即 fail。
 
 ### 內建的 6 條 generic properties
 

package/dist/chunk-2MME5V4F.cjs

@@ -0,0 +1,384 @@
+'use strict';
+
+var chunkI354FONA_cjs = require('./chunk-I354FONA.cjs');
+var chunkCDK25FTD_cjs = require('./chunk-CDK25FTD.cjs');
+
+// 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 = chunkI354FONA_cjs.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 && chunkCDK25FTD_cjs.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 chunkI354FONA_cjs.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(chunkI354FONA_cjs.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 (chunkCDK25FTD_cjs.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 = chunkI354FONA_cjs.normalizeTransitions(state.on[event.type]);
+    if (list.length === 0) return false;
+    for (const t of list) {
+      if (!t.guard || chunkCDK25FTD_cjs.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 = chunkI354FONA_cjs.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 = chunkI354FONA_cjs.normalizeTransitions(state.on?.[event.type]);
+    if (list.length === 0) return false;
+    for (const t of list) {
+      if (!t.guard) return true;
+      if (chunkCDK25FTD_cjs.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;
+}
+
+exports.InvalidDefinitionError = InvalidDefinitionError;
+exports.RESET_EVENT_TYPE = RESET_EVENT_TYPE;
+exports.RuntimeDisposedError = RuntimeDisposedError;
+exports.SubMachineError = SubMachineError;
+exports.createMachine = createMachine;
+exports.createRuntime = createRuntime;
+exports.defineMachine = defineMachine;
+exports.initialSnapshot = initialSnapshot;
+exports.setup = setup;
+//# sourceMappingURL=chunk-2MME5V4F.cjs.map
+//# sourceMappingURL=chunk-2MME5V4F.cjs.map

package/dist/chunk-2MME5V4F.cjs.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/fsm/types.ts","../src/fsm/definition.ts","../src/fsm/runtime.ts"],"names":["normalizeTransitions","isAsyncGuardFn","freezeSnapshot","deepFreeze","isThenable","evalGuard","step"],"mappings":"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","file":"chunk-2MME5V4F.cjs","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-3B2USJ3H.cjs

@@ -0,0 +1,18 @@
+'use strict';
+
+// src/effects/enqueuer.ts
+function createEnqueuer(sink) {
+  return Object.freeze({
+    effect(type, payload) {
+      if (payload === void 0) {
+        sink.push(Object.freeze({ type }));
+      } else {
+        sink.push(Object.freeze({ type, payload }));
+      }
+    }
+  });
+}
+
+exports.createEnqueuer = createEnqueuer;
+//# sourceMappingURL=chunk-3B2USJ3H.cjs.map
+//# sourceMappingURL=chunk-3B2USJ3H.cjs.map

package/dist/chunk-3B2USJ3H.cjs.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/effects/enqueuer.ts"],"names":[],"mappings":";;;AAUO,SAAS,eAAe,IAAA,EAAuD;AACpF,EAAA,OAAO,OAAO,MAAA,CAAO;AAAA,IACnB,MAAA,CAAO,MAAc,OAAA,EAAmB;AACtC,MAAA,IAAI,YAAY,MAAA,EAAW;AACzB,QAAA,IAAA,CAAK,KAAK,MAAA,CAAO,MAAA,CAAO,EAAE,IAAA,EAAM,CAAC,CAAA;AAAA,MACnC,CAAA,MAAO;AACL,QAAA,IAAA,CAAK,KAAK,MAAA,CAAO,MAAA,CAAO,EAAE,IAAA,EAAM,OAAA,EAAS,CAAC,CAAA;AAAA,MAC5C;AAAA,IACF;AAAA,GACD,CAAA;AACH","file":"chunk-3B2USJ3H.cjs","sourcesContent":["import type { Enqueuer } from \"../fsm/types.js\";\n\n/**\n * Build a closure-based Enqueuer that pushes effects into the supplied sink.\n * Each `step()` invocation creates one such enqueuer and discards it\n * afterwards; the sink is the effects array later returned to the caller.\n *\n * Lives in `effects/` because the Enqueuer concept is the effects-domain API\n * — `step()` imports it from here.\n */\nexport function createEnqueuer(sink: { type: string; payload?: unknown }[]): Enqueuer {\n  return Object.freeze({\n    effect(type: string, payload?: unknown) {\n      if (payload === undefined) {\n        sink.push(Object.freeze({ type }));\n      } else {\n        sink.push(Object.freeze({ type, payload }));\n      }\n    },\n  });\n}\n"]}

package/dist/chunk-A7U7QQL5.js

@@ -0,0 +1,52 @@
+// src/fsm/evaluator.ts
+var UnknownGuardError = class extends Error {
+  guardName;
+  constructor(guardName) {
+    super(`aifsmjs: guard "${guardName}" not found in implementations.guards`);
+    this.name = "UnknownGuardError";
+    this.guardName = guardName;
+  }
+};
+var AsyncGuardError = class extends Error {
+  guardName;
+  constructor(guardName) {
+    super(
+      `aifsmjs: guard "${guardName}" must be sync; received a Promise. Async guards break determinism and replay. Move I/O into an effect.`
+    );
+    this.name = "AsyncGuardError";
+    this.guardName = guardName;
+  }
+};
+function isAsyncGuardFn(fn) {
+  if (typeof fn !== "function") return false;
+  return fn.constructor?.name === "AsyncFunction";
+}
+function isThenable(x) {
+  return x !== null && (typeof x === "object" || typeof x === "function") && typeof x.then === "function";
+}
+function resolveGuard(ref, impl) {
+  if (typeof ref === "function") return ref;
+  const fn = impl.guards?.[ref];
+  if (!fn) throw new UnknownGuardError(ref);
+  return fn;
+}
+function evalGuard(ref, context, event, impl, value) {
+  const fn = resolveGuard(ref, impl);
+  const guardName = typeof ref === "string" ? ref : fn.name || "<inline>";
+  if (isAsyncGuardFn(fn)) {
+    throw new AsyncGuardError(guardName);
+  }
+  const args = { context, event };
+  const guardsMap = impl.guards;
+  if (guardsMap) args.guards = guardsMap;
+  if (value !== void 0) args.value = value;
+  const result = fn(args);
+  if (isThenable(result)) {
+    throw new AsyncGuardError(guardName);
+  }
+  return result;
+}
+
+export { AsyncGuardError, UnknownGuardError, evalGuard, isAsyncGuardFn, isThenable, resolveGuard };
+//# sourceMappingURL=chunk-A7U7QQL5.js.map
+//# sourceMappingURL=chunk-A7U7QQL5.js.map