@demlik/tea 0.13.0 → 0.14.0

package/dist/{core-Co0LWkIA.d.ts → core-CTzMJ82M.d.ts}

@@ -11,8 +11,8 @@ import { z } from 'zod';
  * **Dependency direction (the actual decoupling):** this module imports
  * NOTHING from the runtime — no `better-result`, no `run`/host/`Store`. The
  * runtime (`run`, the host, interpret, `Store`, subscribe — all in
- * `../index.ts`) imports *from* here; never the reverse. The
- * `@demlik/tea/pure` subpath re-exports this surface, and
+ * `../index.ts`) imports *from* here; never the reverse. The root door
+ * re-exports this surface through `./index.ts`, and
  * `pure/import-graph.test.ts` is the regression fence asserting the pure
  * entrypoint's import graph never reaches `run`.
  *
@@ -21,7 +21,7 @@ import { z } from 'zod';
  * against them happens at the interpret edge in `../run.ts`, never here.
  */
 
-type NeedsOf<C> = C extends {
+type RequirementsOf<C> = C extends {
     readonly __r?: infer R;
 } ? R : unknown;
 /** The `E` union one Cmd can settle with; `unknown` for an untyped Cmd. */
@@ -29,12 +29,20 @@ type ErrorsOf<C> = C extends {
     readonly __e?: infer E;
 } ? E : unknown;
 type UnionToIntersection<U> = (U extends unknown ? (u: U) => void : never) extends (u: infer I) => void ? I : never;
+type RequirementsBoxed<C> = C extends unknown ? [RequirementsOf<C>] : never;
+type KnownRequirements<B> = B extends [infer R] ? unknown extends R ? never : R : never;
 /**
  * The `ctx` a machine's whole Cmd union requires: every Cmd's `R`, intersected.
  * `run` types its `ctx` as `Ctx & RequiredCtx<C>`, so handing a machine whose
- * Cmds need `{ http }` to a `run` whose ctx lacks it is a compile error.
+ * Cmds need `{ http }` to a `run` whose ctx lacks it is a compile error. A Cmd
+ * that requires nothing — untyped, or `Cmd.define`d without `requirements` — leaves
+ * the demand of its siblings intact (#56).
+ *
+ * This is the requirement. `provide` is what satisfies it: hand `run` a
+ * `provide({ … })` graph in place of the object and the same `Ctx` is built once
+ * at boot, in dependency order, and released in reverse when the run ends.
  */
-type RequiredCtx<C> = UnionToIntersection<NeedsOf<C>>;
+type RequiredCtx<C> = UnionToIntersection<KnownRequirements<RequirementsBoxed<C>>>;
 /** The shape every settled failure has (ADR 0011): a plain `_tag` record. */
 type Tagged = {
     readonly _tag: string;
@@ -68,11 +76,11 @@ type CmdInput = {
     readonly type?: never;
 } & Record<string, unknown>;
 /**
- * Phantom carrier for a Cmd's `R`. `Cmd.needs<{ http: Http }>()` is how a
+ * Phantom carrier for a Cmd's `R`. `Cmd.requirements<{ http: Http }>()` is how a
  * declaration names the `Ctx` slice its handler reads — a type, not a value, so
  * nothing is constructed and nothing is checked at runtime.
  */
-type Needs<R> = {
+type Requirements<R> = {
     readonly __r?: R;
 };
 /** The value `Cmd.define("fetch", …)` builds: `{ type: "fetch", ...input }`. */
@@ -144,7 +152,7 @@ declare function defineCmd<const Name extends string, Input extends CmdInput, Ok
     readonly input: z.ZodType<Input>;
     readonly ok: z.ZodType<Ok>;
     readonly err: Tags;
-    readonly needs?: Needs<R>;
+    readonly requirements?: Requirements<R>;
 }): CmdDef<Name, Input, Ok, TaggedError<Tags[number]>, R>;
 type SyncReturn<S, C extends Cmd> = readonly [S, readonly C[]] & {
     readonly then?: never;
@@ -158,10 +166,26 @@ declare function formOf(machine: {
 declare class NoCellError extends Error {
     readonly msgType: string;
     readonly stateName: string;
+    /** The Msg types the refusing state has cells for; empty when it has none. */
+    readonly acceptedTypes: readonly string[];
     readonly name = "NoCellError";
     readonly _tag: "NoCellError";
-    constructor(msgType: string, stateName: string);
+    constructor(msgType: string, stateName: string, 
+    /** The Msg types the refusing state has cells for; empty when it has none. */
+    acceptedTypes: readonly string[]);
 }
+/**
+ * The Msg types this machine would accept in this state — the same set a
+ * `NoCellError` reports, asked before anything is dispatched. Returns the
+ * state's own row keys in transitions form and the flat table's keys in
+ * reducer form, counting only keys whose cell is a function, and an empty
+ * array (never `undefined`, never a throw) for a state with no cells, no row
+ * at all, or no state value at all.
+ */
+declare function acceptedTypes<S>(machine: {
+    update: object;
+    __form?: UpdateForm;
+}, state: S): readonly string[];
 declare function applyCell<S, M extends {
     type: string;
 }, C extends Cmd>(machine: {
@@ -206,10 +230,29 @@ type Reducer<S, M extends {
         type: K;
     }>) => SyncReturn<S, C>;
 };
+/**
+ * The state × message table form of `update`. Every state of `S` needs a row;
+ * a cell inside a row is optional, and leaving one out DECLARES that the state
+ * does not accept that message — the runtime refuses it with `NoCellError`
+ * naming `acceptedTypes`. `ExhaustiveTransitions` requires every cell instead.
+ */
 type Transitions<S extends {
     type: string;
 }, M extends {
     type: string;
+}, C extends Cmd> = {
+    [P in S["type"]]: Partial<ExhaustiveTransitions<S, M, C>[P]>;
+};
+/**
+ * `Transitions<S, M, C>` with every cell REQUIRED — the opt-in floor for a
+ * machine that wants the compiler to force a decision on every (state,
+ * message) pair. An annotation on your own table, not a third update form:
+ * `defineMachine` takes the annotated table unchanged.
+ */
+type ExhaustiveTransitions<S extends {
+    type: string;
+}, M extends {
+    type: string;
 }, C extends Cmd> = {
     [P in S["type"]]: {
         [K in M["type"]]: (state: Extract<S, {
@@ -219,6 +262,19 @@ type Transitions<S extends {
         }>) => SyncReturn<S, C>;
     };
 };
+/**
+ * A tagged-union, one-shot effect — JSON-plain, hashable, replayable.
+ *
+ * `T` is the tag. `E` and `R` are Effect's Error and **Requirements** channels,
+ * carried as phantom type parameters (ADR 0014): `E` is the `_tag` union this
+ * Cmd can settle with, and `R` is the slice of `Ctx` its interpret handler
+ * reads. `R` is a requirement, not a wiring — what SATISFIES it is the `ctx`
+ * handed to `run`, built by hand or by a `provide` graph that acquires each
+ * dependency once and releases it when the run ends.
+ *
+ * @see {@link RequiredCtx} — every Cmd's `R`, intersected: what `run` demands.
+ * @see `provide` — the host-side graph that builds a `ctx` satisfying `R`.
+ */
 type Cmd<T extends string = string, E = unknown, R = unknown> = {
     readonly type: T;
     /** Phantom — the `_tag` union this Cmd can settle with. Never assigned. */
@@ -239,19 +295,21 @@ declare const Cmd: {
      *     input: z.object({ url: z.string() }),
      *     ok: z.object({ status: z.number(), body: z.string() }),
      *     err: ["not_found", "timeout"],
-     *     needs: Cmd.needs<{ http: Http }>(),
+     *     requirements: Cmd.requirements<{ http: Http }>(),
      *   });
      *
      * `err` is the `_tag` list the handler may settle with; the runtime adds
-     * `malformed_result` for an `_ok` value the `ok` schema rejects. `needs`
+     * `malformed_result` for an `_ok` value the `ok` schema rejects. `requirements`
      * names the `Ctx` slice the handler reads — `run` refuses a ctx without it.
+     *
+     * A Cmd must not wait; see `DepKeyedSub` for anything that watches.
      */
     readonly define: typeof defineCmd;
     /**
      * Name a Cmd's `R` — the `Ctx` slice its handler reads. A phantom: nothing
      * is built, nothing is checked at runtime; the type is what `run` reads.
      */
-    readonly needs: <R>() => Needs<R>;
+    readonly requirements: <R>() => Requirements<R>;
     /**
      * The empty Cmd array. Typed `readonly never[]` so it's assignable to any
      * `readonly C[]` for any `C extends Cmd`. Use in `init` returns and
@@ -378,21 +436,12 @@ interface PortEmitter {
     emit<T>(port: Port<T>, value: T): void;
 }
 type NoCtx = Readonly<Record<never, never>>;
-/**
- * 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 & NeedsOf<Extract<C, {
+    }>, ctx: Ctx & RequirementsOf<Extract<C, {
         type: K;
     }>> & PortEmitter, dispatch?: (msg: M) => void) => Promise<M | void>;
 };
@@ -510,4 +559,4 @@ 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 { type AnyCmdDef as A, applyCellChecked as B, Cmd as C, type DepKeyedSub as D, type ErrOf as E, describeMachine as F, detectUpdateForm as G, foldMsgs as H, type Interpret as I, foldUpdates as J, formOf as K, msgKeysOf as L, type Machine as M, NoCellError as N, type OkOf as O, type PortEmitter as P, structuralHash as Q, type RequiredCtx as R, type Sub as S, type Transitions as T, type UpdateForm as U, subId as V, type Port as a, type SubId as b, type Reducer as c, type Settled as d, type CmdOf as e, type NeedsOf as f, type InterpretDetached as g, type CmdDef as h, type CmdInput as i, type CmdValue as j, type ContextFree as k, type Dispose as l, type ErrorsOf as m, type Identity as n, type MachineShape as o, type MalformedResult as p, type Needs as q, type NoCtx as r, type SettledErr as s, type SettledOk as t, type Subscribe as u, type SyncReturn as v, type Tagged as w, type TaggedError as x, acceptsOf as y, applyCell as z };
+export { type AnyCmdDef as A, applyCell as B, Cmd as C, type Dispose as D, type ErrOf as E, applyCellChecked as F, describeMachine as G, detectUpdateForm as H, type Interpret as I, foldMsgs as J, foldUpdates as K, formOf as L, type Machine as M, NoCellError as N, type OkOf as O, type Port as P, msgKeysOf as Q, type RequiredCtx as R, type Sub as S, type Transitions as T, type UpdateForm as U, structuralHash as V, subId as W, type CmdOf as a, type CmdDef as b, type SubId as c, type Reducer as d, type Settled as e, type RequirementsOf as f, type PortEmitter as g, type InterpretDetached as h, type CmdValue as i, type Tagged as j, type NoCtx as k, type MalformedResult as l, type Requirements as m, type TaggedError as n, type DepKeyedSub as o, type CmdInput as p, type ErrorsOf as q, type ExhaustiveTransitions as r, type Identity as s, type MachineShape as t, type SettledErr as u, type SettledOk as v, type Subscribe as w, type SyncReturn as x, acceptedTypes as y, acceptsOf as z };

package/dist/devtools/index.d.ts

@@ -15,7 +15,7 @@ interface MsgLogProps {
 declare function MsgLog({ history, className }: MsgLogProps): react_jsx_runtime.JSX.Element;
 
 /**
- * A single differing cell between two states.
+ * A single differing leaf value between two states.
  *
  *   - `kind: "added"`   — the path exists in `actual` but not `expected`
  *                         (`expected` is `undefined`).
@@ -35,7 +35,7 @@ interface StateChange {
     actual: unknown;
 }
 /**
- * Deep-walk two states and return EVERY differing cell, in deterministic
+ * Deep-walk two states and return EVERY differing leaf value, in deterministic
  * pre-order (the node before its children; children in array-index order, then
  * sorted-union key order for objects). The empty array means the two states are
  * deeply equal.

package/dist/devtools/index.js

@@ -1,4 +1,209 @@
-export { MsgLog, StateDiff, StateInspector, diffState, formatDiff, useMsgHistory } from '../chunk-WRAA7GVZ.js';
-import '../chunk-EWJP3YYP.js';
+import { typeOf, indexPath, unionKeys, keyPath } from '../chunk-HWVW4AXC.js';
+import { jsx, jsxs } from 'react/jsx-runtime';
+import { useRef, useEffect, useState, useCallback } from 'react';
+
+function MsgLog({ history, className }) {
+  return /* @__PURE__ */ jsx("div", { className: `tea-dt-log${className ? ` ${className}` : ""}`, children: history.map((r, i) => /* @__PURE__ */ jsxs(
+    "div",
+    {
+      className: `tea-dt-row tea-dt-${r.kind ?? "msg"}`,
+      children: [
+        /* @__PURE__ */ jsx("span", { className: "tea-dt-t", children: r.ts }),
+        /* @__PURE__ */ jsx("span", { className: "tea-dt-m", children: r.text })
+      ]
+    },
+    `${r.ts}-${i}`
+  )) });
+}
+
+// src/devtools/state-diff.ts
+function diffState(expected, actual) {
+  const out = [];
+  walk(expected, actual, "state", out);
+  return out;
+}
+function walk(expected, actual, path, out) {
+  if (Object.is(expected, actual)) return;
+  const te = typeOf(expected);
+  const ta = typeOf(actual);
+  if (te === "undefined") {
+    out.push({ path, kind: "added", expected, actual });
+    return;
+  }
+  if (ta === "undefined") {
+    out.push({ path, kind: "removed", expected, actual });
+    return;
+  }
+  if (te !== ta) {
+    out.push({ path, kind: "changed", expected, actual });
+    return;
+  }
+  if (te === "array") {
+    const ae = expected;
+    const aa = actual;
+    const len = Math.max(ae.length, aa.length);
+    for (let i = 0; i < len; i++) {
+      walk(ae[i], aa[i], indexPath(path, i), out);
+    }
+    return;
+  }
+  if (te === "object") {
+    const oe = expected;
+    const oa = actual;
+    for (const key of unionKeys(oe, oa)) {
+      walk(oe[key], oa[key], keyPath(path, key), out);
+    }
+    return;
+  }
+  out.push({ path, kind: "changed", expected, actual });
+}
+function fmtValue(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 formatDiff(changes) {
+  return changes.map(formatChange).join("\n");
+}
+function formatChange(c) {
+  switch (c.kind) {
+    case "changed":
+      return `~ ${c.path}: ${fmtValue(c.expected)} \u2192 ${fmtValue(c.actual)}`;
+    case "removed":
+      return `- ${c.path}: ${fmtValue(c.expected)}`;
+    case "added":
+      return `+ ${c.path}: ${fmtValue(c.actual)}`;
+  }
+}
+function changeRow(c) {
+  switch (c.kind) {
+    case "changed":
+      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: fmtValue(c.expected) }),
+        /* @__PURE__ */ jsx("span", { className: "tea-dt-diff-arrow", children: "\u2192" }),
+        /* @__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: 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: fmtValue(c.actual) })
+      ] }, c.path);
+  }
+}
+function StateDiff({ expected, actual, className }) {
+  const changes = diffState(expected, actual);
+  return /* @__PURE__ */ jsx(
+    "div",
+    {
+      className: `tea-dt-diff${className ? ` ${className}` : ""}`,
+      title: changes.length === 0 ? "no changes" : formatDiff(changes),
+      children: changes.length === 0 ? /* @__PURE__ */ jsx("div", { className: "tea-dt-diff-empty", children: "no changes" }) : changes.map(changeRow)
+    }
+  );
+}
+function escapeHtml(s) {
+  return s.replace(
+    /[&<>"]/g,
+    (c) => ({ "&": "&amp;", "<": "&lt;", ">": "&gt;", '"': "&quot;" })[c]
+  );
+}
+function fmtJson(obj, indent = 0) {
+  if (obj === null) return '<span class="tea-dt-b">null</span>';
+  if (typeof obj === "number") return `<span class="tea-dt-n">${obj}</span>`;
+  if (typeof obj === "boolean") return `<span class="tea-dt-b">${obj}</span>`;
+  if (typeof obj === "string")
+    return `<span class="tea-dt-s">"${escapeHtml(obj)}"</span>`;
+  if (Array.isArray(obj)) {
+    if (obj.length === 0) return '<span class="tea-dt-br">[]</span>';
+    return '<span class="tea-dt-br">[</span>' + obj.map((v) => fmtJson(v, indent + 1)).join('<span class="tea-dt-br">, </span>') + '<span class="tea-dt-br">]</span>';
+  }
+  if (typeof obj === "object") {
+    const keys = Object.keys(obj);
+    if (keys.length === 0) return '<span class="tea-dt-br">{}</span>';
+    const pad = "&nbsp;&nbsp;".repeat(indent + 1);
+    const lines = keys.map((k, i) => {
+      const v = obj[k];
+      const comma = i < keys.length - 1 ? '<span class="tea-dt-br">,</span>' : "";
+      return `${pad}<span class="tea-dt-k">${escapeHtml(k)}</span><span class="tea-dt-br">:</span> ${fmtJson(v, indent + 1)}${comma}`;
+    });
+    return [
+      '<span class="tea-dt-br">{</span>',
+      ...lines,
+      `${"&nbsp;&nbsp;".repeat(indent)}<span class="tea-dt-br">}</span>`
+    ].join("<br/>");
+  }
+  return escapeHtml(String(obj));
+}
+function StateInspector({
+  state,
+  flashKey,
+  className
+}) {
+  const boxRef = useRef(null);
+  useEffect(() => {
+    if (flashKey === void 0 || !boxRef.current) return;
+    boxRef.current.classList.remove("tea-dt-flash");
+    void boxRef.current.offsetWidth;
+    boxRef.current.classList.add("tea-dt-flash");
+  }, [flashKey]);
+  return /* @__PURE__ */ jsx(
+    "div",
+    {
+      ref: boxRef,
+      className: `tea-dt-state${className ? ` ${className}` : ""}`,
+      children: /* @__PURE__ */ jsx(
+        "div",
+        {
+          className: "tea-dt-json",
+          dangerouslySetInnerHTML: { __html: fmtJson(state) }
+        }
+      )
+    }
+  );
+}
+function nowTs() {
+  return (/* @__PURE__ */ new Date()).toLocaleTimeString("en-GB", { hour12: false }).slice(3);
+}
+function useMsgHistory(dispatch, opts = {}) {
+  const max = opts.max ?? 60;
+  const now = opts.now ?? nowTs;
+  const derive = opts.derive ?? ((msg) => {
+    const tag = msg && typeof msg === "object" && "type" in msg ? String(msg.type) : String(msg);
+    return { ts: now(), kind: "msg", text: tag };
+  });
+  const [history, setHistory] = useState([]);
+  const dispatchRef = useRef(dispatch);
+  dispatchRef.current = dispatch;
+  const deriveRef = useRef(derive);
+  deriveRef.current = derive;
+  const wrapped = useCallback(
+    (msg) => {
+      const entry = deriveRef.current(msg);
+      setHistory((prev) => [entry, ...prev].slice(0, max));
+      void dispatchRef.current(msg);
+    },
+    [max]
+  );
+  const clear = useCallback(() => setHistory([]), []);
+  return [history, wrapped, clear];
+}
+
+export { MsgLog, StateDiff, StateInspector, diffState, formatDiff, useMsgHistory };
 //# sourceMappingURL=index.js.map
 //# sourceMappingURL=index.js.map

package/dist/devtools/index.js.map

@@ -1 +1 @@
-{"version":3,"sources":[],"names":[],"mappings":"","file":"index.js"}
+{"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\nimport {\n  indexPath,\n  keyPath,\n  typeOf,\n  unionKeys,\n} from \"../internal/persistence/trace-replay/state-walk\";\n\n/**\n * A single differing leaf value 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 leaf value, 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"]}