@demlik/tea 0.1.2 → 0.3.0

package/dist/{core-BoB6t7dB.d.ts → core-42kapW0n.d.ts}

@@ -7,6 +7,13 @@ declare function formOf(machine: {
     update: object;
     __form?: UpdateForm;
 }): UpdateForm;
+declare class NoCellError extends Error {
+    readonly msgType: string;
+    readonly stateName: string;
+    readonly name = "NoCellError";
+    readonly _tag: "NoCellError";
+    constructor(msgType: string, stateName: string);
+}
 declare function applyCell<S, M extends {
     type: string;
 }, C extends Cmd>(machine: {
@@ -38,7 +45,7 @@ type Transitions<S extends {
     };
 };
 type Cmd<T extends string = string> = {
-    type: T;
+    readonly type: T;
 };
 declare const Cmd: {
     /**
@@ -107,9 +114,46 @@ type SubId = string & {
  */
 declare function subId(s: string): SubId;
 type Sub<T extends string = string> = {
-    id: SubId;
-    type: T;
+    readonly id: SubId;
+    readonly type: T;
 };
+type Dispose = () => void;
+declare function structuralHash(deps: unknown): string;
+interface DepKeyedSub<S, M, Ctx = unknown> {
+    /**
+     * The slice of state this Sub depends on. `null` ⇒ the Sub is inactive in
+     * this state (the substrate disposes it if it was running). Non-null ⇒ the
+     * Sub is active, keyed on `structuralHash(deps)`.
+     *
+     * Pure (invariant 2). Plain JSON-compatible data only (invariant 1) — the
+     * structural hash walks it deterministically.
+     */
+    readonly deps: (state: S) => unknown;
+    /**
+     * Open the resource for the current `state` (whose `deps` the kernel just
+     * found non-null). Receives `dispatch` to fire follow-up Msgs (a timer's
+     * fire, an inbound frame) and the machine's `ctx` (the host's transport
+     * factory, storage handles). Returns the `Dispose` the substrate runs on
+     * teardown / re-arm. Same role as a `subscribe[type]` handler's returned
+     * cleanup.
+     *
+     * `source` takes `state` (not the deps slice) so the slice type `D` never
+     * escapes the entry — each battery's `.depKeyed` closes over its own typed
+     * deps internally (cast-free existential: the entry that produced the deps
+     * is the entry that consumes them).
+     */
+    readonly source: (state: S, dispatch: (msg: M) => void, ctx: Ctx) => Dispose;
+}
+interface Identity<S, M> {
+    /** The identity THIS instance owns. Pure (invariant 2); plain value. */
+    readonly ofState: (state: S) => unknown;
+    /**
+     * The identity a message is addressed to, or `undefined` when the message
+     * carries no identity (lifecycle / pre-identity messages — never dropped).
+     * Pure (invariant 2); plain value when defined.
+     */
+    readonly ofMsg: (msg: M) => unknown;
+}
 interface Port<T> {
     readonly __brand: "port";
     readonly name: string;
@@ -127,15 +171,25 @@ interface PortEmitter {
     emit<T>(port: Port<T>, value: T): void;
 }
 type NoCtx = Readonly<Record<never, never>>;
-/** Spelled-out alias for `NoCtx`, for sites that prefer the long name. */
+/**
+ * Spelled-out alias for `NoCtx`.
+ *
+ * @deprecated Use {@link NoCtx}. One Way to Do Each Thing — `NoCtx` is the
+ * single non-deprecated name for the context-free-ctx marker (this alias has
+ * no in-tree uses). Kept as a re-export for one minor per the deprecate-don't-
+ * delete policy in `MAINTAINING.md`, then removed.
+ */
 type ContextFree = NoCtx;
 type Interpret<M extends {
     type: string;
 }, C extends Cmd, Ctx> = {
     [K in C["type"]]: (cmd: Extract<C, {
         type: K;
-    }>, ctx: Ctx & PortEmitter) => Promise<M | void>;
+    }>, ctx: Ctx & PortEmitter, dispatch?: (msg: M) => void) => Promise<M | void>;
 };
+type InterpretDetached<C extends Cmd, Allowed extends {
+    type: string;
+}, Ctx> = (cmd: C, ctx: Ctx & PortEmitter, dispatch: (msg: Allowed) => void) => Promise<void>;
 type Subscribe<M extends {
     type: string;
 }, U extends Sub, Ctx> = {
@@ -166,6 +220,48 @@ type Machine<S, M extends {
     update: Reducer<S, M, C> | ([S] extends [{
         type: string;
     }] ? Transitions<S, M, C> : never);
+    /**
+     * Dep-keyed Subs. Each declares the state slice it depends on; the substrate
+     * derives the id (`structuralHash(deps)`) and the gate (`deps` non-null) and
+     * folds them into the SAME reconcile loop `subscriptions` feeds. The author
+     * never writes `subId(...)` and never lists Subs in a central
+     * `subscriptions(state)` aggregate — a per-Sub gate travels with the Sub, so
+     * a new phase can't silently forget to arm it.
+     *
+     * The deps slice type is erased to `unknown` per entry — each Sub's slice
+     * differs, but the slice type never crosses this field (the kernel only needs
+     * to hash it and pass `state` back to that same entry's `source`).
+     *
+     * Optional and independent of `subscriptions` / `subscribe`: a machine that
+     * omits `subs` reconciles exactly as before.
+     *
+     * Strengthens invariant 4 (lifecycle owned by the substrate) and invariant 7
+     * (identity derived, not hand-authored).
+     */
+    subs?: ReadonlyArray<DepKeyedSub<S, M, Ctx>>;
+    /**
+     * Instance-identity filter. Declares THIS instance's identity once; the
+     * substrate drops any message addressed to a DIFFERENT identity before it
+     * reaches `update`. Replaces the per-cell `if (msg.runId !== state.runId)`
+     * guard entirely — the reducer never sees a foreign-instance message, so no
+     * cell needs to check.
+     *
+     * Opt-in: a machine that omits `identity` skips the filter (every message
+     * reaches `update`, exactly as before). A message whose `ofMsg` returns
+     * `undefined` is identity-agnostic and always reaches `update` (lifecycle /
+     * pre-identity messages).
+     *
+     * Strengthens invariant 7 (identity is explicit — declared once, enforced by
+     * the substrate) and invariant 6 (mis-addressed messages dropped at one
+     * observable point, not per cell).
+     */
+    identity?: Identity<S, M>;
+    /**
+     * Manual Sub aggregate — the documented escape hatch, KEPT alongside `subs`.
+     * The machine that needs cross-Sub logic the per-Sub `deps` fold can't
+     * express lists Subs here; the substrate reconciles them via `subscribe`.
+     * Both paths feed ONE reconcile pass.
+     */
     subscriptions?: (state: S) => readonly U[];
     subscribe?: Subscribe<M, U, Ctx>;
     /**
@@ -180,9 +276,12 @@ type Machine<S, M extends {
     interpret?: Interpret<M, C, Ctx>;
 } : {
     interpret: Interpret<M, C, Ctx>;
+}) & ([U] extends [Sub<never>] ? unknown : {
+    subscriptions: (state: S) => readonly U[];
+    subscribe: Subscribe<M, U, Ctx>;
 });
 declare function foldMsgs<S, M extends {
     type: string;
 }, C extends Cmd, U extends Sub, Ctx>(machine: Machine<S, M, C, U, Ctx>, base: S, msgs: readonly M[]): S;
 
-export { Cmd as C, type Interpret as I, type Machine as M, type NoCtx as N, type Port as P, type Reducer as R, type Sub as S, type Transitions as T, type UpdateForm as U, type SubId as a, type ContextFree as b, type PortEmitter as c, type Subscribe as d, type SyncReturn as e, applyCell as f, detectUpdateForm as g, foldMsgs as h, formOf as i, msgKeysOf as m, subId as s };
+export { Cmd as C, type DepKeyedSub as D, type InterpretDetached as I, type Machine as M, type NoCtx as N, type Port as P, type Reducer as R, type Sub as S, type Transitions as T, type UpdateForm as U, type SubId as a, type PortEmitter as b, type Interpret as c, type ContextFree as d, type Dispose as e, type Identity as f, type Subscribe as g, type SyncReturn as h, applyCell as i, detectUpdateForm as j, foldMsgs as k, formOf as l, msgKeysOf as m, NoCellError as n, subId as o, structuralHash as s };

package/dist/deadline/index.d.ts

@@ -1,5 +1,5 @@
-import { S as Sub } from '../core-BoB6t7dB.js';
-import { S as SubscribeHandler } from '../types-B-8bcAp8.js';
+import { S as Sub, a as SubId } from '../core-42kapW0n.js';
+import { S as SubscribeHandler } from '../types-KbL3W1mj.js';
 
 /**
  * @demlik/tea/deadline — a one-shot Sub that fires when an ABSOLUTE wall-clock
@@ -29,6 +29,21 @@ import { S as SubscribeHandler } from '../types-B-8bcAp8.js';
  * (invariant 2) — and is exercised in tests via vitest fake timers, matching
  * the no-injection convention of the `fromTimeout` / `fromInterval` exemplars.
  *
+ * WHAT BACKS THE TIMER IS THE HOST'S CHOICE. `setTimeout` is the universal
+ * default, but it is not universal: a Durable Object that hibernates has no
+ * live `setTimeout` to wake it, so its deadline must be backed by a `do_alarm`
+ * registered on the alarm registry; a test host wants a fake-timer schedule.
+ * That backing is the `ArmTimer` seam — `subscribeWith(armTimer)` builds the
+ * `subscribe.deadline` cell from a host-plugged timer, and `subscribeDeadline`
+ * IS `subscribeWith(setTimeoutArmTimer())`. One deadline surface, three hosts;
+ * there is no second Sub type and no second `atMs` anchor to keep in sync.
+ *
+ * The anchor is what makes the seam safe. `atMs` is ABSOLUTE, so whatever backs
+ * it arms to a fixed wall-clock instant: the host computes the gap itself
+ * (`atMs - Date.now()`), and on a host that just rehydrated after hibernation
+ * that gap is the SHRUNKEN remainder — the deadline honours the original target
+ * rather than resetting to a fresh full-length window.
+ *
  * Strengthens invariant 4 (external time is a subscription — the deadline is a
  * `Sub` the runtime reconciles, never a `setTimeout` leaked into a reducer) and
  * invariant 7 (identity is explicit — the Sub carries a stable `SubId`, so the
@@ -105,15 +120,66 @@ type DeadlineExceeded = {
  */
 declare function deadlineSub(id: string, atMs: number, opts?: DeadlineOpts): DeadlineSub;
 /**
- * The `subscribe["deadline"]` cell. Arms a one-shot timer for the remaining
- * delay `max(0, atMs - Date.now())` and dispatches `deadlineExceeded(...)` when
- * it fires; returns a cleanup that clears the pending timer.
+ * The host-plugged timer backing. Given the deadline's stable `id`, its
+ * absolute `atMs`, and the Msg to fire, arm the platform-appropriate timer
+ * (DO alarm registry, `setTimeout`, fake timer) and return a cleanup that
+ * cancels the pending fire.
+ *
+ * `id` is the Sub's reconcile id — a registry-backed host (the DO alarm slot)
+ * keys its entry on `id` so the cleanup deletes the EXACT entry the substrate
+ * reconciled. A `setTimeout`-backed host ignores `id` (the closure holds the
+ * handle).
+ *
+ * The host computes the gap itself: `atMs - Date.now()` is the REMAINING time.
+ * On a host that just rehydrated after hibernation that gap is the shrunken
+ * remainder — the deadline is NOT reset to its full length. That recomputation
+ * is the reason `atMs` rides on the Sub as an absolute instant rather than a
+ * delay: the anchor is what every backing agrees on.
+ */
+type ArmTimer<M> = (id: SubId, atMs: number, msg: M, dispatch: (msg: M) => void) => () => void;
+/**
+ * Build the `subscribe["deadline"]` cell from a host-plugged `armTimer`. This
+ * module owns the Sub shape, the anchor, and the Msg; the HOST owns what backs
+ * the timer. The returned handler reads `id` + `atMs` off the Sub, builds the
+ * `deadlineExceeded(...)` Msg, and hands all three to `armTimer`.
+ *
+ * Use it when `setTimeout` is the wrong backing — most concretely a Durable
+ * Object, which hibernates and must register a `do_alarm` instead:
+ *
+ *   subscribe: {
+ *     deadline: subscribeWith((id, atMs, msg, dispatch) =>
+ *       alarms.register(id, atMs, () => dispatch(msg)),
+ *     ),
+ *   }
+ *
+ * For the `setTimeout` default, use {@link subscribeDeadline} — it is exactly
+ * `subscribeWith(setTimeoutArmTimer())`, so there is one deadline surface and
+ * one anchor, not a second one per host.
+ */
+declare function subscribeWith(armTimer: ArmTimer<DeadlineExceeded>): SubscribeHandler<DeadlineSub, DeadlineExceeded, unknown>;
+/**
+ * The `setTimeout` timer backing — for node / browser / any host whose timer is
+ * a plain `setTimeout`. Arms for the REMAINING time (`max(0, atMs - Date.now())`,
+ * floored at 0 so an already-past deadline fires on the NEXT tick rather than
+ * synchronously inside the reconcile pass), so a deadline re-derived after a
+ * rehydrate fires at the original instant, not a fresh full window.
+ *
+ * Composes on `fromTimeout` rather than redrawing `setTimeout` /
+ * `clearTimeout`: this package has ONE timer lifecycle, and the arm-timer seam
+ * plugs into it instead of forking it. A hibernating host does NOT use this —
+ * it plugs its own `armTimer` (a `do_alarm` registration) into
+ * {@link subscribeWith}.
+ */
+declare function setTimeoutArmTimer(): ArmTimer<DeadlineExceeded>;
+/**
+ * The `subscribe["deadline"]` cell for the DEFAULT `setTimeout` backing. Arms a
+ * one-shot timer for the remaining delay `max(0, atMs - Date.now())` and
+ * dispatches `deadlineExceeded(...)` when it fires; returns a cleanup that
+ * clears the pending timer.
  *
- * Composes on `fromTimeout`: it adapts the absolute `atMs` on the Sub to the
- * relative `delayMs` that `fromTimeout` schedules against, then hands off the
- * `setTimeout` / `clearTimeout` lifecycle wholesale. A past deadline collapses
- * to `delayMs: 0`, so `fromTimeout` fires on the next tick — asynchronously,
- * never inside the reconcile pass.
+ * It is `subscribeWith(setTimeoutArmTimer())` — the default backing named, not
+ * a separate implementation, so the host-plugged path and the default path can
+ * never disagree about the anchor.
  *
  * Assign directly to a `Subscribe` cell:
  *
@@ -129,4 +195,4 @@ declare const subscribeDeadline: SubscribeHandler<DeadlineSub, DeadlineExceeded,
  */
 declare function deadlineExceeded(id: string, atMs: number): DeadlineExceeded;
 
-export { type DeadlineExceeded, type DeadlineOpts, type DeadlineSub, deadlineExceeded, deadlineSub, subscribeDeadline };
+export { type ArmTimer, type DeadlineExceeded, type DeadlineOpts, type DeadlineSub, deadlineExceeded, deadlineSub, setTimeoutArmTimer, subscribeDeadline, subscribeWith };

package/dist/deadline/index.js

@@ -1,6 +1,6 @@
-export { deadlineExceeded, deadlineSub, subscribeDeadline } from '../chunk-K7Q23EQ4.js';
+export { deadlineExceeded, deadlineSub, setTimeoutArmTimer, subscribeDeadline, subscribeWith } from '../chunk-RMX4EOQK.js';
 import '../chunk-2YFLOCWX.js';
-import '../chunk-MMH7CW5K.js';
-import '../chunk-QLA76GIT.js';
+import '../chunk-BP2R7TPP.js';
+import '../chunk-PBDYW2TU.js';
 //# sourceMappingURL=index.js.map
 //# sourceMappingURL=index.js.map

package/dist/devtools/index.js

@@ -1,7 +1,7 @@
+import { typeOf, indexPath, unionKeys, keyPath } from '../chunk-EWJP3YYP.js';
 import { jsx, jsxs } from 'react/jsx-runtime';
 import { useRef, useEffect, useState, useCallback } from 'react';
 
-// src/devtools/msg-log.tsx
 function MsgLog({ history, className }) {
   return /* @__PURE__ */ jsx("div", { className: `tea-dt-log${className ? ` ${className}` : ""}`, children: history.map((r, i) => /* @__PURE__ */ jsxs(
     "div",
@@ -17,13 +17,6 @@ function MsgLog({ history, className }) {
 }
 
 // src/devtools/state-diff.ts
-function typeOf(v) {
-  if (v === null) return "null";
-  if (v === void 0) return "undefined";
-  if (Array.isArray(v)) return "array";
-  if (typeof v === "object") return "object";
-  return "primitive";
-}
 function diffState(expected, actual) {
   const out = [];
   walk(expected, actual, "state", out);
@@ -50,16 +43,15 @@ function walk(expected, actual, path, out) {
     const aa = actual;
     const len = Math.max(ae.length, aa.length);
     for (let i = 0; i < len; i++) {
-      walk(ae[i], aa[i], `${path}[${i}]`, out);
+      walk(ae[i], aa[i], indexPath(path, i), out);
     }
     return;
   }
   if (te === "object") {
     const oe = expected;
     const oa = actual;
-    const keys = [.../* @__PURE__ */ new Set([...Object.keys(oe), ...Object.keys(oa)])].sort();
-    for (const key of keys) {
-      walk(oe[key], oa[key], `${path}.${key}`, out);
+    for (const key of unionKeys(oe, oa)) {
+      walk(oe[key], oa[key], keyPath(path, key), out);
     }
     return;
   }
@@ -96,36 +88,24 @@ function changeRow(c) {
       return /* @__PURE__ */ jsxs("div", { className: "tea-dt-diff-row tea-dt-diff-changed", children: [
         /* @__PURE__ */ jsx("span", { className: "tea-dt-diff-mark", children: "~" }),
         /* @__PURE__ */ jsx("span", { className: "tea-dt-diff-path", children: c.path }),
-        /* @__PURE__ */ jsx("span", { className: "tea-dt-diff-old", children: fmt(c.expected) }),
+        /* @__PURE__ */ jsx("span", { className: "tea-dt-diff-old", children: fmtValue(c.expected) }),
         /* @__PURE__ */ jsx("span", { className: "tea-dt-diff-arrow", children: "\u2192" }),
-        /* @__PURE__ */ jsx("span", { className: "tea-dt-diff-new", children: fmt(c.actual) })
+        /* @__PURE__ */ jsx("span", { className: "tea-dt-diff-new", children: fmtValue(c.actual) })
       ] }, c.path);
     case "removed":
       return /* @__PURE__ */ jsxs("div", { className: "tea-dt-diff-row tea-dt-diff-removed", children: [
         /* @__PURE__ */ jsx("span", { className: "tea-dt-diff-mark", children: "-" }),
         /* @__PURE__ */ jsx("span", { className: "tea-dt-diff-path", children: c.path }),
-        /* @__PURE__ */ jsx("span", { className: "tea-dt-diff-old", children: fmt(c.expected) })
+        /* @__PURE__ */ jsx("span", { className: "tea-dt-diff-old", children: fmtValue(c.expected) })
       ] }, c.path);
     case "added":
       return /* @__PURE__ */ jsxs("div", { className: "tea-dt-diff-row tea-dt-diff-added", children: [
         /* @__PURE__ */ jsx("span", { className: "tea-dt-diff-mark", children: "+" }),
         /* @__PURE__ */ jsx("span", { className: "tea-dt-diff-path", children: c.path }),
-        /* @__PURE__ */ jsx("span", { className: "tea-dt-diff-new", children: fmt(c.actual) })
+        /* @__PURE__ */ jsx("span", { className: "tea-dt-diff-new", children: fmtValue(c.actual) })
       ] }, c.path);
   }
 }
-function fmt(v) {
-  if (v === void 0) return "undefined";
-  if (typeof v === "number" && Number.isNaN(v)) return "NaN";
-  if (typeof v === "bigint") return `${v}n`;
-  if (typeof v === "string") return JSON.stringify(v);
-  if (typeof v === "function" || typeof v === "symbol") return String(v);
-  try {
-    return JSON.stringify(v) ?? String(v);
-  } catch {
-    return String(v);
-  }
-}
 function StateDiff({ expected, actual, className }) {
   const changes = diffState(expected, actual);
   return /* @__PURE__ */ jsx(

package/dist/devtools/index.js.map

@@ -1 +1 @@
-{"version":3,"sources":["../../src/devtools/msg-log.tsx","../../src/devtools/state-diff.ts","../../src/devtools/state-diff-view.tsx","../../src/devtools/state-inspector.tsx","../../src/devtools/use-msg-history.ts"],"names":["jsxs","jsx","useRef"],"mappings":"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","file":"index.js","sourcesContent":["export type MsgLogEntry = {\n  /** Display timestamp (whatever format you produced). */\n  ts: string;\n  /** Visual category — drives the row icon. Defaults to \"msg\" via CSS. */\n  kind?: \"msg\" | \"sub\" | \"cmd\" | \"ok\" | \"fail\";\n  /** Row text — usually the Msg tag plus a short detail. */\n  text: string;\n};\n\nexport interface MsgLogProps {\n  history: readonly MsgLogEntry[];\n  className?: string;\n}\n\nexport function MsgLog({ history, className }: MsgLogProps) {\n  return (\n    <div className={`tea-dt-log${className ? ` ${className}` : \"\"}`}>\n      {history.map((r, i) => (\n        <div\n          key={`${r.ts}-${i}`}\n          className={`tea-dt-row tea-dt-${r.kind ?? \"msg\"}`}\n        >\n          <span className=\"tea-dt-t\">{r.ts}</span>\n          <span className=\"tea-dt-m\">{r.text}</span>\n        </div>\n      ))}\n    </div>\n  );\n}\n","// ---------------------------------------------------------------------------\n// state-diff — the RICHER cousin of trace-replay's first-divergence walk.\n//\n// `../trace-replay` answers \"did the state drift, and where FIRST?\" — it stops\n// at the first differing cell because a regression check only needs to point at\n// one. This module answers the fuller devtools question: \"show me EVERY cell\n// that differs,\" classified as added / removed / changed, ready to render.\n//\n// Same substrate, same path grammar (root `state`, `foo[2]` for arrays,\n// `foo.bar` for objects, sorted-union key order, `Object.is` leaf equality) so\n// a path printed here is the SAME string trace-replay would print for that\n// cell. The two tools are deliberately consistent: a `divergence.path` from a\n// replay result indexes straight into this module's `StateChange[]`.\n//\n// Pure + zero-dep on purpose — runs in Node, in tests, in a Worker. The React\n// view (`./state-diff.tsx`) is the only React-touching layer.\n// ---------------------------------------------------------------------------\n\n/**\n * A single differing cell between two states.\n *\n *   - `kind: \"added\"`   — the path exists in `actual` but not `expected`\n *                         (`expected` is `undefined`).\n *   - `kind: \"removed\"` — the path exists in `expected` but not `actual`\n *                         (`actual` is `undefined`).\n *   - `kind: \"changed\"` — the path exists on both sides with differing leaf\n *                         values (or differing kinds, e.g. object vs array).\n */\nexport interface StateChange {\n  /** Access path from the state root, e.g. `state.items[1].status`. */\n  path: string;\n  /** How the cell differs between the two states. */\n  kind: \"added\" | \"removed\" | \"changed\";\n  /** The value on the `expected` side (`undefined` when `added`). */\n  expected: unknown;\n  /** The value on the `actual` side (`undefined` when `removed`). */\n  actual: unknown;\n}\n\n/** Coarse type tag used by the walk to decide how to recurse. Mirrors trace-replay. */\nfunction typeOf(\n  v: unknown,\n): \"null\" | \"undefined\" | \"array\" | \"object\" | \"primitive\" {\n  if (v === null) return \"null\";\n  if (v === undefined) return \"undefined\";\n  if (Array.isArray(v)) return \"array\";\n  if (typeof v === \"object\") return \"object\";\n  return \"primitive\";\n}\n\n/**\n * Deep-walk two states and return EVERY differing cell, in deterministic\n * pre-order (the node before its children; children in array-index order, then\n * sorted-union key order for objects). The empty array means the two states are\n * deeply equal.\n *\n * Equality + path grammar match `../trace-replay`'s `firstDivergence` exactly:\n *   - `Object.is` leaf equality, so `NaN` equals `NaN` and `+0` ≠ `-0`.\n *   - arrays index by `[i]`; a length mismatch is NOT reported at the array\n *     node — instead each surplus/missing element surfaces as its own\n *     added/removed child, which is what a devtools list wants to show.\n *   - objects walk the sorted union of both sides' keys; a key on only one\n *     side becomes an `added`/`removed` child.\n *   - the root path is `\"state\"`.\n *\n * Scope is JSON-shaped state (the same substrate trace-replay targets):\n * primitives, null/undefined, arrays, plain objects. A differing kind at a node\n * (object vs array, number vs string) is reported as a single `changed` at that\n * node — the walk does not descend into mismatched kinds.\n */\nexport function diffState(expected: unknown, actual: unknown): StateChange[] {\n  const out: StateChange[] = [];\n  walk(expected, actual, \"state\", out);\n  return out;\n}\n\nfunction walk(\n  expected: unknown,\n  actual: unknown,\n  path: string,\n  out: StateChange[],\n): void {\n  // Identity / primitive fast path. Equal cells contribute nothing. `Object.is`\n  // so NaN equals NaN and +0 ≠ -0 — same intent as trace-replay's leaf check.\n  if (Object.is(expected, actual)) return;\n\n  const te = typeOf(expected);\n  const ta = typeOf(actual);\n\n  // A present/absent pair at this node is an add or a remove — the structural\n  // signal a viewer color-codes differently from a value change.\n  if (te === \"undefined\") {\n    out.push({ path, kind: \"added\", expected, actual });\n    return;\n  }\n  if (ta === \"undefined\") {\n    out.push({ path, kind: \"removed\", expected, actual });\n    return;\n  }\n\n  // Different kinds at a present node (object vs array, number vs string,\n  // value vs null) — one `changed` at the node; do not descend into mismatched\n  // shapes, mirroring trace-replay's \"this node IS the divergence\".\n  if (te !== ta) {\n    out.push({ path, kind: \"changed\", expected, actual });\n    return;\n  }\n\n  if (te === \"array\") {\n    const ae = expected as unknown[];\n    const aa = actual as unknown[];\n    // Walk the union of indices so surplus elements on EITHER side surface as\n    // their own added/removed children (vs trace-replay, which reports a length\n    // mismatch at the array node and stops). A viewer wants the per-element\n    // detail.\n    const len = Math.max(ae.length, aa.length);\n    for (let i = 0; i < len; i++) {\n      walk(ae[i], aa[i], `${path}[${i}]`, out);\n    }\n    return;\n  }\n\n  if (te === \"object\") {\n    const oe = expected as Record<string, unknown>;\n    const oa = actual as Record<string, unknown>;\n    // Sorted union of keys — deterministic regardless of insertion order, so\n    // two states with the same data in different key order produce no changes,\n    // and the reported order is reproducible run-to-run.\n    const keys = [...new Set([...Object.keys(oe), ...Object.keys(oa)])].sort();\n    for (const key of keys) {\n      walk(oe[key], oa[key], `${path}.${key}`, out);\n    }\n    return;\n  }\n\n  // Two present primitives (string/number/boolean/bigint/symbol) or two\n  // differing nulls that failed the Object.is fast path — a leaf change.\n  out.push({ path, kind: \"changed\", expected, actual });\n}\n\n/** Render a single value compactly for the text diff. Strings get quotes so\n * `\"3\"` is visibly distinct from `3`; everything else is JSON-ish, with the\n * `undefined`/`NaN`/`BigInt` cases JSON.stringify mishandles spelled out. */\nfunction fmtValue(v: unknown): string {\n  if (v === undefined) return \"undefined\";\n  if (typeof v === \"number\" && Number.isNaN(v)) return \"NaN\";\n  if (typeof v === \"bigint\") return `${v}n`;\n  if (typeof v === \"string\") return JSON.stringify(v);\n  if (typeof v === \"function\" || typeof v === \"symbol\") return String(v);\n  try {\n    return JSON.stringify(v) ?? String(v);\n  } catch {\n    // Circular / non-serializable — fall back to a coarse tag.\n    return String(v);\n  }\n}\n\n/**\n * Pretty multi-line text for a {@link diffState} result. One `±`-prefixed line\n * per change, in the array's (pre-order, deterministic) order:\n *\n *   - `~ state.total: 121.5 → 135`   (changed: old → new)\n *   - `- state.coupon: \"X\"`          (removed: only the old value)\n *   - `+ state.tax: 8`               (added: only the new value)\n *\n * Deterministic given a deterministic `changes` array. An empty array yields\n * the empty string.\n */\nexport function formatDiff(changes: StateChange[]): string {\n  return changes.map(formatChange).join(\"\\n\");\n}\n\n/** One `±`-prefixed line for a single change. Split out so the `map` callback\n * is total (Biome's useIterableCallbackReturn) without a dead default branch. */\nfunction formatChange(c: StateChange): string {\n  switch (c.kind) {\n    case \"changed\":\n      return `~ ${c.path}: ${fmtValue(c.expected)} → ${fmtValue(c.actual)}`;\n    case \"removed\":\n      return `- ${c.path}: ${fmtValue(c.expected)}`;\n    case \"added\":\n      return `+ ${c.path}: ${fmtValue(c.actual)}`;\n  }\n}\n","import { diffState, formatDiff, type StateChange } from \"./state-diff\";\n\nexport interface StateDiffProps {\n  /**\n   * The baseline / \"before\" state — what you expected. In a regression view\n   * this is a trace's recorded `finalState`; in a time-travel view it's the\n   * previous model.\n   */\n  expected: unknown;\n  /**\n   * The \"after\" state to compare against `expected` — the recomputed or\n   * current model.\n   */\n  actual: unknown;\n  /** Optional className appended to the container. Use to override layout. */\n  className?: string;\n}\n\n/** Per-kind row glyph + value rendering. Lives here (not CSS ::before like the\n * MsgLog rows) because the diff prints the path AND the value(s), so the glyph\n * is part of structured content the screen reader should read in order. */\nfunction changeRow(c: StateChange) {\n  // `path` is unique within one diff (each cell appears at most once), so it is\n  // a stable React key without needing the array index.\n  switch (c.kind) {\n    case \"changed\":\n      return (\n        <div key={c.path} className=\"tea-dt-diff-row tea-dt-diff-changed\">\n          <span className=\"tea-dt-diff-mark\">~</span>\n          <span className=\"tea-dt-diff-path\">{c.path}</span>\n          <span className=\"tea-dt-diff-old\">{fmt(c.expected)}</span>\n          <span className=\"tea-dt-diff-arrow\">→</span>\n          <span className=\"tea-dt-diff-new\">{fmt(c.actual)}</span>\n        </div>\n      );\n    case \"removed\":\n      return (\n        <div key={c.path} className=\"tea-dt-diff-row tea-dt-diff-removed\">\n          <span className=\"tea-dt-diff-mark\">-</span>\n          <span className=\"tea-dt-diff-path\">{c.path}</span>\n          <span className=\"tea-dt-diff-old\">{fmt(c.expected)}</span>\n        </div>\n      );\n    case \"added\":\n      return (\n        <div key={c.path} className=\"tea-dt-diff-row tea-dt-diff-added\">\n          <span className=\"tea-dt-diff-mark\">+</span>\n          <span className=\"tea-dt-diff-path\">{c.path}</span>\n          <span className=\"tea-dt-diff-new\">{fmt(c.actual)}</span>\n        </div>\n      );\n  }\n}\n\n/** Compact value render for a row cell. Strings get quotes; objects/arrays a\n * JSON-ish one-liner — the diff already names the leaf path, so a deep render\n * isn't needed here. */\nfunction fmt(v: unknown): string {\n  if (v === undefined) return \"undefined\";\n  if (typeof v === \"number\" && Number.isNaN(v)) return \"NaN\";\n  if (typeof v === \"bigint\") return `${v}n`;\n  if (typeof v === \"string\") return JSON.stringify(v);\n  if (typeof v === \"function\" || typeof v === \"symbol\") return String(v);\n  try {\n    return JSON.stringify(v) ?? String(v);\n  } catch {\n    return String(v);\n  }\n}\n\n/**\n * Presentational diff of two states. Renders {@link diffState}'s output as a\n * color-coded list (added / removed / changed), reusing the devtools `tea-dt-*`\n * class convention so it inherits the same design tokens as `<StateInspector>`\n * and `<MsgLog>` (see ./styles.css). No state, no subscription — pass the two\n * states as props, exactly like the rest of /devtools.\n *\n * When the states are deeply equal the list is empty; a tiny \"no changes\" hint\n * renders so an operator can tell \"equal\" from \"not yet computed\".\n */\nexport function StateDiff({ expected, actual, className }: StateDiffProps) {\n  const changes = diffState(expected, actual);\n  return (\n    <div\n      className={`tea-dt-diff${className ? ` ${className}` : \"\"}`}\n      // The plain-text diff is the accessible/copyable fallback for the\n      // color-coded rows — same content `formatDiff` produces in Node/tests.\n      title={changes.length === 0 ? \"no changes\" : formatDiff(changes)}\n    >\n      {changes.length === 0 ? (\n        <div className=\"tea-dt-diff-empty\">no changes</div>\n      ) : (\n        changes.map(changeRow)\n      )}\n    </div>\n  );\n}\n","import { useEffect, useRef } from \"react\";\n\nfunction escapeHtml(s: string): string {\n  return s.replace(\n    /[&<>\"]/g,\n    (c) =>\n      ({ \"&\": \"&amp;\", \"<\": \"&lt;\", \">\": \"&gt;\", '\"': \"&quot;\" })[c] as string,\n  );\n}\n\nfunction fmtJson(obj: unknown, indent = 0): string {\n  if (obj === null) return '<span class=\"tea-dt-b\">null</span>';\n  if (typeof obj === \"number\") return `<span class=\"tea-dt-n\">${obj}</span>`;\n  if (typeof obj === \"boolean\") return `<span class=\"tea-dt-b\">${obj}</span>`;\n  if (typeof obj === \"string\")\n    return `<span class=\"tea-dt-s\">\"${escapeHtml(obj)}\"</span>`;\n  if (Array.isArray(obj)) {\n    if (obj.length === 0) return '<span class=\"tea-dt-br\">[]</span>';\n    return (\n      '<span class=\"tea-dt-br\">[</span>' +\n      obj\n        .map((v) => fmtJson(v, indent + 1))\n        .join('<span class=\"tea-dt-br\">, </span>') +\n      '<span class=\"tea-dt-br\">]</span>'\n    );\n  }\n  if (typeof obj === \"object\") {\n    const keys = Object.keys(obj as object);\n    if (keys.length === 0) return '<span class=\"tea-dt-br\">{}</span>';\n    const pad = \"&nbsp;&nbsp;\".repeat(indent + 1);\n    const lines = keys.map((k, i) => {\n      const v = (obj as Record<string, unknown>)[k];\n      const comma =\n        i < keys.length - 1 ? '<span class=\"tea-dt-br\">,</span>' : \"\";\n      return `${pad}<span class=\"tea-dt-k\">${escapeHtml(k)}</span><span class=\"tea-dt-br\">:</span> ${fmtJson(v, indent + 1)}${comma}`;\n    });\n    return [\n      '<span class=\"tea-dt-br\">{</span>',\n      ...lines,\n      `${\"&nbsp;&nbsp;\".repeat(indent)}<span class=\"tea-dt-br\">}</span>`,\n    ].join(\"<br/>\");\n  }\n  return escapeHtml(String(obj));\n}\n\nexport interface StateInspectorProps {\n  /**\n   * The machine state to display. Render-derived shape — pass whatever you\n   * want surfaced to the inspector (often a hand-picked subset of the model).\n   */\n  state: unknown;\n  /**\n   * When this number changes, the inspector flashes. Pass `model.msgCount` or\n   * any other monotonic counter you already have. Omit to disable flashing.\n   */\n  flashKey?: number;\n  /**\n   * Optional className appended to the container. Use to override layout.\n   */\n  className?: string;\n}\n\nexport function StateInspector({\n  state,\n  flashKey,\n  className,\n}: StateInspectorProps) {\n  const boxRef = useRef<HTMLDivElement>(null);\n  useEffect(() => {\n    if (flashKey === undefined || !boxRef.current) return;\n    boxRef.current.classList.remove(\"tea-dt-flash\");\n    void boxRef.current.offsetWidth;\n    boxRef.current.classList.add(\"tea-dt-flash\");\n  }, [flashKey]);\n\n  return (\n    <div\n      ref={boxRef}\n      className={`tea-dt-state${className ? ` ${className}` : \"\"}`}\n    >\n      <div\n        className=\"tea-dt-json\"\n        // biome-ignore lint/security/noDangerouslySetInnerHtml: formatter output\n        dangerouslySetInnerHTML={{ __html: fmtJson(state) }}\n      />\n    </div>\n  );\n}\n","import { useCallback, useRef, useState } from \"react\";\nimport type { MsgLogEntry } from \"./msg-log\";\n\nfunction nowTs(): string {\n  return new Date().toLocaleTimeString(\"en-GB\", { hour12: false }).slice(3);\n}\n\n/**\n * Wrap a `dispatch` so every Msg it sees lands in a bounded history buffer.\n *\n * `derive` lets you map a Msg to a richer entry (e.g. assign `kind: \"sub\"` to\n * subscription-triggered messages). Default: every msg becomes a `\"msg\"` row\n * tagged with `msg.type` (or `String(msg)` if it has no `type`). The substrate\n * uses `type` as the Msg discriminant — using `_tag` here would render every\n * Msg as `[object Object]` in the inspector.\n *\n * `max` caps the buffer — oldest entries fall off (LIFO, newest first).\n *\n * `now` is the timestamp source for the default `derive`. Defaults to\n * `nowTs` (real wall-clock). Tests inject a deterministic shim so\n * snapshots don't drift; production code never sets it.\n */\nexport function useMsgHistory<M>(\n  dispatch: (msg: M) => void | Promise<void>,\n  opts: {\n    max?: number;\n    derive?: (msg: M) => MsgLogEntry;\n    now?: () => string;\n  } = {},\n): readonly [readonly MsgLogEntry[], (msg: M) => void, () => void] {\n  const max = opts.max ?? 60;\n  const now = opts.now ?? nowTs;\n  const derive =\n    opts.derive ??\n    ((msg: M): MsgLogEntry => {\n      const tag =\n        msg && typeof msg === \"object\" && \"type\" in msg\n          ? String((msg as { type: unknown }).type)\n          : String(msg);\n      return { ts: now(), kind: \"msg\", text: tag };\n    });\n\n  const [history, setHistory] = useState<readonly MsgLogEntry[]>([]);\n  // Stable ref to `dispatch` so the wrapper identity stays stable across\n  // renders — important when this is passed to keyboard handlers and the like.\n  const dispatchRef = useRef(dispatch);\n  dispatchRef.current = dispatch;\n  const deriveRef = useRef(derive);\n  deriveRef.current = derive;\n\n  const wrapped = useCallback(\n    (msg: M) => {\n      const entry = deriveRef.current(msg);\n      setHistory((prev) => [entry, ...prev].slice(0, max));\n      // Fire-and-forget — `dispatch` may return a Promise; we don't await it\n      // here because callers historically treat dispatch as void.\n      void dispatchRef.current(msg);\n    },\n    [max],\n  );\n\n  const clear = useCallback(() => setHistory([]), []);\n\n  return [history, wrapped, clear] as const;\n}\n"]}
+{"version":3,"sources":["../../src/devtools/msg-log.tsx","../../src/devtools/state-diff.ts","../../src/devtools/state-diff-view.tsx","../../src/devtools/state-inspector.tsx","../../src/devtools/use-msg-history.ts"],"names":["jsxs","jsx","useRef"],"mappings":";;;;AAcO,SAAS,MAAA,CAAO,EAAE,OAAA,EAAS,SAAA,EAAU,EAAgB;AAC1D,EAAA,uBACE,GAAA,CAAC,KAAA,EAAA,EAAI,SAAA,EAAW,CAAA,UAAA,EAAa,YAAY,CAAA,CAAA,EAAI,SAAS,CAAA,CAAA,GAAK,EAAE,CAAA,CAAA,EAC1D,QAAA,EAAA,OAAA,CAAQ,GAAA,CAAI,CAAC,GAAG,CAAA,qBACf,IAAA;AAAA,IAAC,KAAA;AAAA,IAAA;AAAA,MAEC,SAAA,EAAW,CAAA,kBAAA,EAAqB,CAAA,CAAE,IAAA,IAAQ,KAAK,CAAA,CAAA;AAAA,MAE/C,QAAA,EAAA;AAAA,wBAAA,GAAA,CAAC,MAAA,EAAA,EAAK,SAAA,EAAU,UAAA,EAAY,QAAA,EAAA,CAAA,CAAE,EAAA,EAAG,CAAA;AAAA,wBACjC,GAAA,CAAC,MAAA,EAAA,EAAK,SAAA,EAAU,UAAA,EAAY,YAAE,IAAA,EAAK;AAAA;AAAA,KAAA;AAAA,IAJ9B,CAAA,EAAG,CAAA,CAAE,EAAE,CAAA,CAAA,EAAI,CAAC,CAAA;AAAA,GAMpB,CAAA,EACH,CAAA;AAEJ;;;ACsCO,SAAS,SAAA,CAAU,UAAmB,MAAA,EAAgC;AAC3E,EAAA,MAAM,MAAqB,EAAC;AAC5B,EAAA,IAAA,CAAK,QAAA,EAAU,MAAA,EAAQ,OAAA,EAAS,GAAG,CAAA;AACnC,EAAA,OAAO,GAAA;AACT;AAEA,SAAS,IAAA,CACP,QAAA,EACA,MAAA,EACA,IAAA,EACA,GAAA,EACM;AAGN,EAAA,IAAI,MAAA,CAAO,EAAA,CAAG,QAAA,EAAU,MAAM,CAAA,EAAG;AAEjC,EAAA,MAAM,EAAA,GAAK,OAAO,QAAQ,CAAA;AAC1B,EAAA,MAAM,EAAA,GAAK,OAAO,MAAM,CAAA;AAIxB,EAAA,IAAI,OAAO,WAAA,EAAa;AACtB,IAAA,GAAA,CAAI,KAAK,EAAE,IAAA,EAAM,MAAM,OAAA,EAAS,QAAA,EAAU,QAAQ,CAAA;AAClD,IAAA;AAAA,EACF;AACA,EAAA,IAAI,OAAO,WAAA,EAAa;AACtB,IAAA,GAAA,CAAI,KAAK,EAAE,IAAA,EAAM,MAAM,SAAA,EAAW,QAAA,EAAU,QAAQ,CAAA;AACpD,IAAA;AAAA,EACF;AAKA,EAAA,IAAI,OAAO,EAAA,EAAI;AACb,IAAA,GAAA,CAAI,KAAK,EAAE,IAAA,EAAM,MAAM,SAAA,EAAW,QAAA,EAAU,QAAQ,CAAA;AACpD,IAAA;AAAA,EACF;AAEA,EAAA,IAAI,OAAO,OAAA,EAAS;AAClB,IAAA,MAAM,EAAA,GAAK,QAAA;AACX,IAAA,MAAM,EAAA,GAAK,MAAA;AAKX,IAAA,MAAM,MAAM,IAAA,CAAK,GAAA,CAAI,EAAA,CAAG,MAAA,EAAQ,GAAG,MAAM,CAAA;AACzC,IAAA,KAAA,IAAS,CAAA,GAAI,CAAA,EAAG,CAAA,GAAI,GAAA,EAAK,CAAA,EAAA,EAAK;AAC5B,MAAA,IAAA,CAAK,EAAA,CAAG,CAAC,CAAA,EAAG,EAAA,CAAG,CAAC,GAAG,SAAA,CAAU,IAAA,EAAM,CAAC,CAAA,EAAG,GAAG,CAAA;AAAA,IAC5C;AACA,IAAA;AAAA,EACF;AAEA,EAAA,IAAI,OAAO,QAAA,EAAU;AACnB,IAAA,MAAM,EAAA,GAAK,QAAA;AACX,IAAA,MAAM,EAAA,GAAK,MAAA;AAIX,IAAA,KAAA,MAAW,GAAA,IAAO,SAAA,CAAU,EAAA,EAAI,EAAE,CAAA,EAAG;AACnC,MAAA,IAAA,CAAK,EAAA,CAAG,GAAG,CAAA,EAAG,EAAA,CAAG,GAAG,GAAG,OAAA,CAAQ,IAAA,EAAM,GAAG,CAAA,EAAG,GAAG,CAAA;AAAA,IAChD;AACA,IAAA;AAAA,EACF;AAIA,EAAA,GAAA,CAAI,KAAK,EAAE,IAAA,EAAM,MAAM,SAAA,EAAW,QAAA,EAAU,QAAQ,CAAA;AACtD;AAOO,SAAS,SAAS,CAAA,EAAoB;AAC3C,EAAA,IAAI,CAAA,KAAM,QAAW,OAAO,WAAA;AAC5B,EAAA,IAAI,OAAO,CAAA,KAAM,QAAA,IAAY,OAAO,KAAA,CAAM,CAAC,GAAG,OAAO,KAAA;AACrD,EAAA,IAAI,OAAO,CAAA,KAAM,QAAA,EAAU,OAAO,GAAG,CAAC,CAAA,CAAA,CAAA;AACtC,EAAA,IAAI,OAAO,CAAA,KAAM,QAAA,EAAU,OAAO,IAAA,CAAK,UAAU,CAAC,CAAA;AAClD,EAAA,IAAI,OAAO,MAAM,UAAA,IAAc,OAAO,MAAM,QAAA,EAAU,OAAO,OAAO,CAAC,CAAA;AACrE,EAAA,IAAI;AACF,IAAA,OAAO,IAAA,CAAK,SAAA,CAAU,CAAC,CAAA,IAAK,OAAO,CAAC,CAAA;AAAA,EACtC,CAAA,CAAA,MAAQ;AAEN,IAAA,OAAO,OAAO,CAAC,CAAA;AAAA,EACjB;AACF;AAaO,SAAS,WAAW,OAAA,EAAgC;AACzD,EAAA,OAAO,OAAA,CAAQ,GAAA,CAAI,YAAY,CAAA,CAAE,KAAK,IAAI,CAAA;AAC5C;AAIA,SAAS,aAAa,CAAA,EAAwB;AAC5C,EAAA,QAAQ,EAAE,IAAA;AAAM,IACd,KAAK,SAAA;AACH,MAAA,OAAO,CAAA,EAAA,EAAK,CAAA,CAAE,IAAI,CAAA,EAAA,EAAK,QAAA,CAAS,CAAA,CAAE,QAAQ,CAAC,CAAA,QAAA,EAAM,QAAA,CAAS,CAAA,CAAE,MAAM,CAAC,CAAA,CAAA;AAAA,IACrE,KAAK,SAAA;AACH,MAAA,OAAO,KAAK,CAAA,CAAE,IAAI,KAAK,QAAA,CAAS,CAAA,CAAE,QAAQ,CAAC,CAAA,CAAA;AAAA,IAC7C,KAAK,OAAA;AACH,MAAA,OAAO,KAAK,CAAA,CAAE,IAAI,KAAK,QAAA,CAAS,CAAA,CAAE,MAAM,CAAC,CAAA,CAAA;AAAA;AAE/C;AC1JA,SAAS,UAAU,CAAA,EAAgB;AAGjC,EAAA,QAAQ,EAAE,IAAA;AAAM,IACd,KAAK,SAAA;AACH,MAAA,uBACEA,IAAAA,CAAC,KAAA,EAAA,EAAiB,SAAA,EAAU,qCAAA,EAC1B,QAAA,EAAA;AAAA,wBAAAC,GAAAA,CAAC,MAAA,EAAA,EAAK,SAAA,EAAU,kBAAA,EAAmB,QAAA,EAAA,GAAA,EAAC,CAAA;AAAA,wBACpCA,GAAAA,CAAC,MAAA,EAAA,EAAK,SAAA,EAAU,kBAAA,EAAoB,YAAE,IAAA,EAAK,CAAA;AAAA,wBAC3CA,IAAC,MAAA,EAAA,EAAK,SAAA,EAAU,mBAAmB,QAAA,EAAA,QAAA,CAAS,CAAA,CAAE,QAAQ,CAAA,EAAE,CAAA;AAAA,wBACxDA,GAAAA,CAAC,MAAA,EAAA,EAAK,SAAA,EAAU,qBAAoB,QAAA,EAAA,QAAA,EAAC,CAAA;AAAA,wBACrCA,IAAC,MAAA,EAAA,EAAK,SAAA,EAAU,mBAAmB,QAAA,EAAA,QAAA,CAAS,CAAA,CAAE,MAAM,CAAA,EAAE;AAAA,OAAA,EAAA,EAL9C,EAAE,IAMZ,CAAA;AAAA,IAEJ,KAAK,SAAA;AACH,MAAA,uBACED,IAAAA,CAAC,KAAA,EAAA,EAAiB,SAAA,EAAU,qCAAA,EAC1B,QAAA,EAAA;AAAA,wBAAAC,GAAAA,CAAC,MAAA,EAAA,EAAK,SAAA,EAAU,kBAAA,EAAmB,QAAA,EAAA,GAAA,EAAC,CAAA;AAAA,wBACpCA,GAAAA,CAAC,MAAA,EAAA,EAAK,SAAA,EAAU,kBAAA,EAAoB,YAAE,IAAA,EAAK,CAAA;AAAA,wBAC3CA,IAAC,MAAA,EAAA,EAAK,SAAA,EAAU,mBAAmB,QAAA,EAAA,QAAA,CAAS,CAAA,CAAE,QAAQ,CAAA,EAAE;AAAA,OAAA,EAAA,EAHhD,EAAE,IAIZ,CAAA;AAAA,IAEJ,KAAK,OAAA;AACH,MAAA,uBACED,IAAAA,CAAC,KAAA,EAAA,EAAiB,SAAA,EAAU,mCAAA,EAC1B,QAAA,EAAA;AAAA,wBAAAC,GAAAA,CAAC,MAAA,EAAA,EAAK,SAAA,EAAU,kBAAA,EAAmB,QAAA,EAAA,GAAA,EAAC,CAAA;AAAA,wBACpCA,GAAAA,CAAC,MAAA,EAAA,EAAK,SAAA,EAAU,kBAAA,EAAoB,YAAE,IAAA,EAAK,CAAA;AAAA,wBAC3CA,IAAC,MAAA,EAAA,EAAK,SAAA,EAAU,mBAAmB,QAAA,EAAA,QAAA,CAAS,CAAA,CAAE,MAAM,CAAA,EAAE;AAAA,OAAA,EAAA,EAH9C,EAAE,IAIZ,CAAA;AAAA;AAGR;AAYO,SAAS,SAAA,CAAU,EAAE,QAAA,EAAU,MAAA,EAAQ,WAAU,EAAmB;AACzE,EAAA,MAAM,OAAA,GAAU,SAAA,CAAU,QAAA,EAAU,MAAM,CAAA;AAC1C,EAAA,uBACEA,GAAAA;AAAA,IAAC,KAAA;AAAA,IAAA;AAAA,MACC,WAAW,CAAA,WAAA,EAAc,SAAA,GAAY,CAAA,CAAA,EAAI,SAAS,KAAK,EAAE,CAAA,CAAA;AAAA,MAGzD,OAAO,OAAA,CAAQ,MAAA,KAAW,CAAA,GAAI,YAAA,GAAe,WAAW,OAAO,CAAA;AAAA,MAE9D,QAAA,EAAA,OAAA,CAAQ,MAAA,KAAW,CAAA,mBAClBA,GAAAA,CAAC,KAAA,EAAA,EAAI,SAAA,EAAU,mBAAA,EAAoB,QAAA,EAAA,YAAA,EAAU,CAAA,GAE7C,OAAA,CAAQ,GAAA,CAAI,SAAS;AAAA;AAAA,GAEzB;AAEJ;ACnFA,SAAS,WAAW,CAAA,EAAmB;AACrC,EAAA,OAAO,CAAA,CAAE,OAAA;AAAA,IACP,SAAA;AAAA,IACA,CAAC,CAAA,KAAA,CACE,EAAE,GAAA,EAAK,OAAA,EAAS,GAAA,EAAK,MAAA,EAAQ,GAAA,EAAK,MAAA,EAAQ,GAAA,EAAK,QAAA,EAAS,EAAG,CAAC;AAAA,GACjE;AACF;AAEA,SAAS,OAAA,CAAQ,GAAA,EAAc,MAAA,GAAS,CAAA,EAAW;AACjD,EAAA,IAAI,GAAA,KAAQ,MAAM,OAAO,oCAAA;AACzB,EAAA,IAAI,OAAO,GAAA,KAAQ,QAAA,EAAU,OAAO,0BAA0B,GAAG,CAAA,OAAA,CAAA;AACjE,EAAA,IAAI,OAAO,GAAA,KAAQ,SAAA,EAAW,OAAO,0BAA0B,GAAG,CAAA,OAAA,CAAA;AAClE,EAAA,IAAI,OAAO,GAAA,KAAQ,QAAA;AACjB,IAAA,OAAO,CAAA,wBAAA,EAA2B,UAAA,CAAW,GAAG,CAAC,CAAA,QAAA,CAAA;AACnD,EAAA,IAAI,KAAA,CAAM,OAAA,CAAQ,GAAG,CAAA,EAAG;AACtB,IAAA,IAAI,GAAA,CAAI,MAAA,KAAW,CAAA,EAAG,OAAO,mCAAA;AAC7B,IAAA,OACE,kCAAA,GACA,GAAA,CACG,GAAA,CAAI,CAAC,CAAA,KAAM,OAAA,CAAQ,CAAA,EAAG,MAAA,GAAS,CAAC,CAAC,CAAA,CACjC,IAAA,CAAK,mCAAmC,CAAA,GAC3C,kCAAA;AAAA,EAEJ;AACA,EAAA,IAAI,OAAO,QAAQ,QAAA,EAAU;AAC3B,IAAA,MAAM,IAAA,GAAO,MAAA,CAAO,IAAA,CAAK,GAAa,CAAA;AACtC,IAAA,IAAI,IAAA,CAAK,MAAA,KAAW,CAAA,EAAG,OAAO,mCAAA;AAC9B,IAAA,MAAM,GAAA,GAAM,cAAA,CAAe,MAAA,CAAO,MAAA,GAAS,CAAC,CAAA;AAC5C,IAAA,MAAM,KAAA,GAAQ,IAAA,CAAK,GAAA,CAAI,CAAC,GAAG,CAAA,KAAM;AAC/B,MAAA,MAAM,CAAA,GAAK,IAAgC,CAAC,CAAA;AAC5C,MAAA,MAAM,KAAA,GACJ,CAAA,GAAI,IAAA,CAAK,MAAA,GAAS,IAAI,kCAAA,GAAqC,EAAA;AAC7D,MAAA,OAAO,CAAA,EAAG,GAAG,CAAA,uBAAA,EAA0B,UAAA,CAAW,CAAC,CAAC,CAAA,wCAAA,EAA2C,OAAA,CAAQ,CAAA,EAAG,MAAA,GAAS,CAAC,CAAC,GAAG,KAAK,CAAA,CAAA;AAAA,IAC/H,CAAC,CAAA;AACD,IAAA,OAAO;AAAA,MACL,kCAAA;AAAA,MACA,GAAG,KAAA;AAAA,MACH,CAAA,EAAG,cAAA,CAAe,MAAA,CAAO,MAAM,CAAC,CAAA,gCAAA;AAAA,KAClC,CAAE,KAAK,OAAO,CAAA;AAAA,EAChB;AACA,EAAA,OAAO,UAAA,CAAW,MAAA,CAAO,GAAG,CAAC,CAAA;AAC/B;AAmBO,SAAS,cAAA,CAAe;AAAA,EAC7B,KAAA;AAAA,EACA,QAAA;AAAA,EACA;AACF,CAAA,EAAwB;AACtB,EAAA,MAAM,MAAA,GAAS,OAAuB,IAAI,CAAA;AAC1C,EAAA,SAAA,CAAU,MAAM;AACd,IAAA,IAAI,QAAA,KAAa,MAAA,IAAa,CAAC,MAAA,CAAO,OAAA,EAAS;AAC/C,IAAA,MAAA,CAAO,OAAA,CAAQ,SAAA,CAAU,MAAA,CAAO,cAAc,CAAA;AAC9C,IAAA,KAAK,OAAO,OAAA,CAAQ,WAAA;AACpB,IAAA,MAAA,CAAO,OAAA,CAAQ,SAAA,CAAU,GAAA,CAAI,cAAc,CAAA;AAAA,EAC7C,CAAA,EAAG,CAAC,QAAQ,CAAC,CAAA;AAEb,EAAA,uBACEA,GAAAA;AAAA,IAAC,KAAA;AAAA,IAAA;AAAA,MACC,GAAA,EAAK,MAAA;AAAA,MACL,WAAW,CAAA,YAAA,EAAe,SAAA,GAAY,CAAA,CAAA,EAAI,SAAS,KAAK,EAAE,CAAA,CAAA;AAAA,MAE1D,QAAA,kBAAAA,GAAAA;AAAA,QAAC,KAAA;AAAA,QAAA;AAAA,UACC,SAAA,EAAU,aAAA;AAAA,UAEV,uBAAA,EAAyB,EAAE,MAAA,EAAQ,OAAA,CAAQ,KAAK,CAAA;AAAE;AAAA;AACpD;AAAA,GACF;AAEJ;ACpFA,SAAS,KAAA,GAAgB;AACvB,EAAA,OAAA,iBAAO,IAAI,IAAA,EAAK,EAAE,kBAAA,CAAmB,OAAA,EAAS,EAAE,MAAA,EAAQ,KAAA,EAAO,CAAA,CAAE,KAAA,CAAM,CAAC,CAAA;AAC1E;AAiBO,SAAS,aAAA,CACd,QAAA,EACA,IAAA,GAII,EAAC,EAC4D;AACjE,EAAA,MAAM,GAAA,GAAM,KAAK,GAAA,IAAO,EAAA;AACxB,EAAA,MAAM,GAAA,GAAM,KAAK,GAAA,IAAO,KAAA;AACxB,EAAA,MAAM,MAAA,GACJ,IAAA,CAAK,MAAA,KACJ,CAAC,GAAA,KAAwB;AACxB,IAAA,MAAM,GAAA,GACJ,GAAA,IAAO,OAAO,GAAA,KAAQ,QAAA,IAAY,MAAA,IAAU,GAAA,GACxC,MAAA,CAAQ,GAAA,CAA0B,IAAI,CAAA,GACtC,MAAA,CAAO,GAAG,CAAA;AAChB,IAAA,OAAO,EAAE,EAAA,EAAI,GAAA,IAAO,IAAA,EAAM,KAAA,EAAO,MAAM,GAAA,EAAI;AAAA,EAC7C,CAAA,CAAA;AAEF,EAAA,MAAM,CAAC,OAAA,EAAS,UAAU,CAAA,GAAI,QAAA,CAAiC,EAAE,CAAA;AAGjE,EAAA,MAAM,WAAA,GAAcC,OAAO,QAAQ,CAAA;AACnC,EAAA,WAAA,CAAY,OAAA,GAAU,QAAA;AACtB,EAAA,MAAM,SAAA,GAAYA,OAAO,MAAM,CAAA;AAC/B,EAAA,SAAA,CAAU,OAAA,GAAU,MAAA;AAEpB,EAAA,MAAM,OAAA,GAAU,WAAA;AAAA,IACd,CAAC,GAAA,KAAW;AACV,MAAA,MAAM,KAAA,GAAQ,SAAA,CAAU,OAAA,CAAQ,GAAG,CAAA;AACnC,MAAA,UAAA,CAAW,CAAC,IAAA,KAAS,CAAC,KAAA,EAAO,GAAG,IAAI,CAAA,CAAE,KAAA,CAAM,CAAA,EAAG,GAAG,CAAC,CAAA;AAGnD,MAAA,KAAK,WAAA,CAAY,QAAQ,GAAG,CAAA;AAAA,IAC9B,CAAA;AAAA,IACA,CAAC,GAAG;AAAA,GACN;AAEA,EAAA,MAAM,KAAA,GAAQ,YAAY,MAAM,UAAA,CAAW,EAAE,CAAA,EAAG,EAAE,CAAA;AAElD,EAAA,OAAO,CAAC,OAAA,EAAS,OAAA,EAAS,KAAK,CAAA;AACjC","file":"index.js","sourcesContent":["export type MsgLogEntry = {\n  /** Display timestamp (whatever format you produced). */\n  ts: string;\n  /** Visual category — drives the row icon. Defaults to \"msg\" via CSS. */\n  kind?: \"msg\" | \"sub\" | \"cmd\" | \"ok\" | \"fail\";\n  /** Row text — usually the Msg tag plus a short detail. */\n  text: string;\n};\n\nexport interface MsgLogProps {\n  history: readonly MsgLogEntry[];\n  className?: string;\n}\n\nexport function MsgLog({ history, className }: MsgLogProps) {\n  return (\n    <div className={`tea-dt-log${className ? ` ${className}` : \"\"}`}>\n      {history.map((r, i) => (\n        <div\n          key={`${r.ts}-${i}`}\n          className={`tea-dt-row tea-dt-${r.kind ?? \"msg\"}`}\n        >\n          <span className=\"tea-dt-t\">{r.ts}</span>\n          <span className=\"tea-dt-m\">{r.text}</span>\n        </div>\n      ))}\n    </div>\n  );\n}\n","// ---------------------------------------------------------------------------\n// state-diff — the RICHER cousin of trace-replay's first-divergence walk.\n//\n// `../trace-replay` answers \"did the state drift, and where FIRST?\" — it stops\n// at the first differing cell because a regression check only needs to point at\n// one. This module answers the fuller devtools question: \"show me EVERY cell\n// that differs,\" classified as added / removed / changed, ready to render.\n//\n// Same substrate, same path grammar (root `state`, `foo[2]` for arrays,\n// `foo.bar` for objects, sorted-union key order, `Object.is` leaf equality) so\n// a path printed here is the SAME string trace-replay would print for that\n// cell. The two tools are deliberately consistent: a `divergence.path` from a\n// replay result indexes straight into this module's `StateChange[]`.\n//\n// Pure + zero-dep on purpose — runs in Node, in tests, in a Worker. The React\n// view (`./state-diff.tsx`) is the only React-touching layer.\n// ---------------------------------------------------------------------------\n\nimport {\n  indexPath,\n  keyPath,\n  typeOf,\n  unionKeys,\n} from \"../trace-replay/state-walk\";\n\n/**\n * A single differing cell between two states.\n *\n *   - `kind: \"added\"`   — the path exists in `actual` but not `expected`\n *                         (`expected` is `undefined`).\n *   - `kind: \"removed\"` — the path exists in `expected` but not `actual`\n *                         (`actual` is `undefined`).\n *   - `kind: \"changed\"` — the path exists on both sides with differing leaf\n *                         values (or differing kinds, e.g. object vs array).\n */\nexport interface StateChange {\n  /** Access path from the state root, e.g. `state.items[1].status`. */\n  path: string;\n  /** How the cell differs between the two states. */\n  kind: \"added\" | \"removed\" | \"changed\";\n  /** The value on the `expected` side (`undefined` when `added`). */\n  expected: unknown;\n  /** The value on the `actual` side (`undefined` when `removed`). */\n  actual: unknown;\n}\n\n/**\n * Deep-walk two states and return EVERY differing cell, in deterministic\n * pre-order (the node before its children; children in array-index order, then\n * sorted-union key order for objects). The empty array means the two states are\n * deeply equal.\n *\n * Equality + path grammar match `../trace-replay`'s `firstDivergence` exactly:\n *   - `Object.is` leaf equality, so `NaN` equals `NaN` and `+0` ≠ `-0`.\n *   - arrays index by `[i]`; a length mismatch is NOT reported at the array\n *     node — instead each surplus/missing element surfaces as its own\n *     added/removed child, which is what a devtools list wants to show.\n *   - objects walk the sorted union of both sides' keys; a key on only one\n *     side becomes an `added`/`removed` child.\n *   - the root path is `\"state\"`.\n *\n * Scope is JSON-shaped state (the same substrate trace-replay targets):\n * primitives, null/undefined, arrays, plain objects. A differing kind at a node\n * (object vs array, number vs string) is reported as a single `changed` at that\n * node — the walk does not descend into mismatched kinds.\n */\nexport function diffState(expected: unknown, actual: unknown): StateChange[] {\n  const out: StateChange[] = [];\n  walk(expected, actual, \"state\", out);\n  return out;\n}\n\nfunction walk(\n  expected: unknown,\n  actual: unknown,\n  path: string,\n  out: StateChange[],\n): void {\n  // Identity / primitive fast path. Equal cells contribute nothing. `Object.is`\n  // so NaN equals NaN and +0 ≠ -0 — same intent as trace-replay's leaf check.\n  if (Object.is(expected, actual)) return;\n\n  const te = typeOf(expected);\n  const ta = typeOf(actual);\n\n  // A present/absent pair at this node is an add or a remove — the structural\n  // signal a viewer color-codes differently from a value change.\n  if (te === \"undefined\") {\n    out.push({ path, kind: \"added\", expected, actual });\n    return;\n  }\n  if (ta === \"undefined\") {\n    out.push({ path, kind: \"removed\", expected, actual });\n    return;\n  }\n\n  // Different kinds at a present node (object vs array, number vs string,\n  // value vs null) — one `changed` at the node; do not descend into mismatched\n  // shapes, mirroring trace-replay's \"this node IS the divergence\".\n  if (te !== ta) {\n    out.push({ path, kind: \"changed\", expected, actual });\n    return;\n  }\n\n  if (te === \"array\") {\n    const ae = expected as unknown[];\n    const aa = actual as unknown[];\n    // Walk the union of indices so surplus elements on EITHER side surface as\n    // their own added/removed children (vs trace-replay, which reports a length\n    // mismatch at the array node and stops). A viewer wants the per-element\n    // detail.\n    const len = Math.max(ae.length, aa.length);\n    for (let i = 0; i < len; i++) {\n      walk(ae[i], aa[i], indexPath(path, i), out);\n    }\n    return;\n  }\n\n  if (te === \"object\") {\n    const oe = expected as Record<string, unknown>;\n    const oa = actual as Record<string, unknown>;\n    // Sorted union of keys — deterministic regardless of insertion order, so\n    // two states with the same data in different key order produce no changes,\n    // and the reported order is reproducible run-to-run.\n    for (const key of unionKeys(oe, oa)) {\n      walk(oe[key], oa[key], keyPath(path, key), out);\n    }\n    return;\n  }\n\n  // Two present primitives (string/number/boolean/bigint/symbol) or two\n  // differing nulls that failed the Object.is fast path — a leaf change.\n  out.push({ path, kind: \"changed\", expected, actual });\n}\n\n/** Render a single value compactly for a diff cell. Strings get quotes so\n * `\"3\"` is visibly distinct from `3`; everything else is JSON-ish, with the\n * `undefined`/`NaN`/`BigInt` cases JSON.stringify mishandles spelled out.\n * Exported (though not re-exported from `./index`) so the React `<StateDiff>`\n * view renders each cell with this exact formatter rather than a copy. */\nexport function fmtValue(v: unknown): string {\n  if (v === undefined) return \"undefined\";\n  if (typeof v === \"number\" && Number.isNaN(v)) return \"NaN\";\n  if (typeof v === \"bigint\") return `${v}n`;\n  if (typeof v === \"string\") return JSON.stringify(v);\n  if (typeof v === \"function\" || typeof v === \"symbol\") return String(v);\n  try {\n    return JSON.stringify(v) ?? String(v);\n  } catch {\n    // Circular / non-serializable — fall back to a coarse tag.\n    return String(v);\n  }\n}\n\n/**\n * Pretty multi-line text for a {@link diffState} result. One `±`-prefixed line\n * per change, in the array's (pre-order, deterministic) order:\n *\n *   - `~ state.total: 121.5 → 135`   (changed: old → new)\n *   - `- state.coupon: \"X\"`          (removed: only the old value)\n *   - `+ state.tax: 8`               (added: only the new value)\n *\n * Deterministic given a deterministic `changes` array. An empty array yields\n * the empty string.\n */\nexport function formatDiff(changes: StateChange[]): string {\n  return changes.map(formatChange).join(\"\\n\");\n}\n\n/** One `±`-prefixed line for a single change. Split out so the `map` callback\n * is total (Biome's useIterableCallbackReturn) without a dead default branch. */\nfunction formatChange(c: StateChange): string {\n  switch (c.kind) {\n    case \"changed\":\n      return `~ ${c.path}: ${fmtValue(c.expected)} → ${fmtValue(c.actual)}`;\n    case \"removed\":\n      return `- ${c.path}: ${fmtValue(c.expected)}`;\n    case \"added\":\n      return `+ ${c.path}: ${fmtValue(c.actual)}`;\n  }\n}\n","import {\n  diffState,\n  fmtValue,\n  formatDiff,\n  type StateChange,\n} from \"./state-diff\";\n\nexport interface StateDiffProps {\n  /**\n   * The baseline / \"before\" state — what you expected. In a regression view\n   * this is a trace's recorded `finalState`; in a time-travel view it's the\n   * previous model.\n   */\n  expected: unknown;\n  /**\n   * The \"after\" state to compare against `expected` — the recomputed or\n   * current model.\n   */\n  actual: unknown;\n  /** Optional className appended to the container. Use to override layout. */\n  className?: string;\n}\n\n/** Per-kind row glyph + value rendering. Lives here (not CSS ::before like the\n * MsgLog rows) because the diff prints the path AND the value(s), so the glyph\n * is part of structured content the screen reader should read in order. */\nfunction changeRow(c: StateChange) {\n  // `path` is unique within one diff (each cell appears at most once), so it is\n  // a stable React key without needing the array index.\n  switch (c.kind) {\n    case \"changed\":\n      return (\n        <div key={c.path} className=\"tea-dt-diff-row tea-dt-diff-changed\">\n          <span className=\"tea-dt-diff-mark\">~</span>\n          <span className=\"tea-dt-diff-path\">{c.path}</span>\n          <span className=\"tea-dt-diff-old\">{fmtValue(c.expected)}</span>\n          <span className=\"tea-dt-diff-arrow\">→</span>\n          <span className=\"tea-dt-diff-new\">{fmtValue(c.actual)}</span>\n        </div>\n      );\n    case \"removed\":\n      return (\n        <div key={c.path} className=\"tea-dt-diff-row tea-dt-diff-removed\">\n          <span className=\"tea-dt-diff-mark\">-</span>\n          <span className=\"tea-dt-diff-path\">{c.path}</span>\n          <span className=\"tea-dt-diff-old\">{fmtValue(c.expected)}</span>\n        </div>\n      );\n    case \"added\":\n      return (\n        <div key={c.path} className=\"tea-dt-diff-row tea-dt-diff-added\">\n          <span className=\"tea-dt-diff-mark\">+</span>\n          <span className=\"tea-dt-diff-path\">{c.path}</span>\n          <span className=\"tea-dt-diff-new\">{fmtValue(c.actual)}</span>\n        </div>\n      );\n  }\n}\n\n/**\n * Presentational diff of two states. Renders {@link diffState}'s output as a\n * color-coded list (added / removed / changed), reusing the devtools `tea-dt-*`\n * class convention so it inherits the same design tokens as `<StateInspector>`\n * and `<MsgLog>` (see ./styles.css). No state, no subscription — pass the two\n * states as props, exactly like the rest of /devtools.\n *\n * When the states are deeply equal the list is empty; a tiny \"no changes\" hint\n * renders so an operator can tell \"equal\" from \"not yet computed\".\n */\nexport function StateDiff({ expected, actual, className }: StateDiffProps) {\n  const changes = diffState(expected, actual);\n  return (\n    <div\n      className={`tea-dt-diff${className ? ` ${className}` : \"\"}`}\n      // The plain-text diff is the accessible/copyable fallback for the\n      // color-coded rows — same content `formatDiff` produces in Node/tests.\n      title={changes.length === 0 ? \"no changes\" : formatDiff(changes)}\n    >\n      {changes.length === 0 ? (\n        <div className=\"tea-dt-diff-empty\">no changes</div>\n      ) : (\n        changes.map(changeRow)\n      )}\n    </div>\n  );\n}\n","import { useEffect, useRef } from \"react\";\n\nfunction escapeHtml(s: string): string {\n  return s.replace(\n    /[&<>\"]/g,\n    (c) =>\n      ({ \"&\": \"&amp;\", \"<\": \"&lt;\", \">\": \"&gt;\", '\"': \"&quot;\" })[c] as string,\n  );\n}\n\nfunction fmtJson(obj: unknown, indent = 0): string {\n  if (obj === null) return '<span class=\"tea-dt-b\">null</span>';\n  if (typeof obj === \"number\") return `<span class=\"tea-dt-n\">${obj}</span>`;\n  if (typeof obj === \"boolean\") return `<span class=\"tea-dt-b\">${obj}</span>`;\n  if (typeof obj === \"string\")\n    return `<span class=\"tea-dt-s\">\"${escapeHtml(obj)}\"</span>`;\n  if (Array.isArray(obj)) {\n    if (obj.length === 0) return '<span class=\"tea-dt-br\">[]</span>';\n    return (\n      '<span class=\"tea-dt-br\">[</span>' +\n      obj\n        .map((v) => fmtJson(v, indent + 1))\n        .join('<span class=\"tea-dt-br\">, </span>') +\n      '<span class=\"tea-dt-br\">]</span>'\n    );\n  }\n  if (typeof obj === \"object\") {\n    const keys = Object.keys(obj as object);\n    if (keys.length === 0) return '<span class=\"tea-dt-br\">{}</span>';\n    const pad = \"&nbsp;&nbsp;\".repeat(indent + 1);\n    const lines = keys.map((k, i) => {\n      const v = (obj as Record<string, unknown>)[k];\n      const comma =\n        i < keys.length - 1 ? '<span class=\"tea-dt-br\">,</span>' : \"\";\n      return `${pad}<span class=\"tea-dt-k\">${escapeHtml(k)}</span><span class=\"tea-dt-br\">:</span> ${fmtJson(v, indent + 1)}${comma}`;\n    });\n    return [\n      '<span class=\"tea-dt-br\">{</span>',\n      ...lines,\n      `${\"&nbsp;&nbsp;\".repeat(indent)}<span class=\"tea-dt-br\">}</span>`,\n    ].join(\"<br/>\");\n  }\n  return escapeHtml(String(obj));\n}\n\nexport interface StateInspectorProps {\n  /**\n   * The machine state to display. Render-derived shape — pass whatever you\n   * want surfaced to the inspector (often a hand-picked subset of the model).\n   */\n  state: unknown;\n  /**\n   * When this number changes, the inspector flashes. Pass `model.msgCount` or\n   * any other monotonic counter you already have. Omit to disable flashing.\n   */\n  flashKey?: number;\n  /**\n   * Optional className appended to the container. Use to override layout.\n   */\n  className?: string;\n}\n\nexport function StateInspector({\n  state,\n  flashKey,\n  className,\n}: StateInspectorProps) {\n  const boxRef = useRef<HTMLDivElement>(null);\n  useEffect(() => {\n    if (flashKey === undefined || !boxRef.current) return;\n    boxRef.current.classList.remove(\"tea-dt-flash\");\n    void boxRef.current.offsetWidth;\n    boxRef.current.classList.add(\"tea-dt-flash\");\n  }, [flashKey]);\n\n  return (\n    <div\n      ref={boxRef}\n      className={`tea-dt-state${className ? ` ${className}` : \"\"}`}\n    >\n      <div\n        className=\"tea-dt-json\"\n        // biome-ignore lint/security/noDangerouslySetInnerHtml: formatter output\n        dangerouslySetInnerHTML={{ __html: fmtJson(state) }}\n      />\n    </div>\n  );\n}\n","import { useCallback, useRef, useState } from \"react\";\nimport type { MsgLogEntry } from \"./msg-log\";\n\nfunction nowTs(): string {\n  return new Date().toLocaleTimeString(\"en-GB\", { hour12: false }).slice(3);\n}\n\n/**\n * Wrap a `dispatch` so every Msg it sees lands in a bounded history buffer.\n *\n * `derive` lets you map a Msg to a richer entry (e.g. assign `kind: \"sub\"` to\n * subscription-triggered messages). Default: every msg becomes a `\"msg\"` row\n * tagged with `msg.type` (or `String(msg)` if it has no `type`). The substrate\n * uses `type` as the Msg discriminant — using `_tag` here would render every\n * Msg as `[object Object]` in the inspector.\n *\n * `max` caps the buffer — oldest entries fall off (LIFO, newest first).\n *\n * `now` is the timestamp source for the default `derive`. Defaults to\n * `nowTs` (real wall-clock). Tests inject a deterministic shim so\n * snapshots don't drift; production code never sets it.\n */\nexport function useMsgHistory<M>(\n  dispatch: (msg: M) => void | Promise<void>,\n  opts: {\n    max?: number;\n    derive?: (msg: M) => MsgLogEntry;\n    now?: () => string;\n  } = {},\n): readonly [readonly MsgLogEntry[], (msg: M) => void, () => void] {\n  const max = opts.max ?? 60;\n  const now = opts.now ?? nowTs;\n  const derive =\n    opts.derive ??\n    ((msg: M): MsgLogEntry => {\n      const tag =\n        msg && typeof msg === \"object\" && \"type\" in msg\n          ? String((msg as { type: unknown }).type)\n          : String(msg);\n      return { ts: now(), kind: \"msg\", text: tag };\n    });\n\n  const [history, setHistory] = useState<readonly MsgLogEntry[]>([]);\n  // Stable ref to `dispatch` so the wrapper identity stays stable across\n  // renders — important when this is passed to keyboard handlers and the like.\n  const dispatchRef = useRef(dispatch);\n  dispatchRef.current = dispatch;\n  const deriveRef = useRef(derive);\n  deriveRef.current = derive;\n\n  const wrapped = useCallback(\n    (msg: M) => {\n      const entry = deriveRef.current(msg);\n      setHistory((prev) => [entry, ...prev].slice(0, max));\n      // Fire-and-forget — `dispatch` may return a Promise; we don't await it\n      // here because callers historically treat dispatch as void.\n      void dispatchRef.current(msg);\n    },\n    [max],\n  );\n\n  const clear = useCallback(() => setHistory([]), []);\n\n  return [history, wrapped, clear] as const;\n}\n"]}