tuiboard 0.8.3 → 0.9.0

package/src/ui/Modal.tsx

@@ -55,6 +55,7 @@ function ModalRouter(props: { store: TuiStore; modal: NonNullable<TuiStore["stat
     case "event-edit": return <EventEditModal store={props.store} />;
     case "confirm-delete-event": return <ConfirmDeleteEventModal store={props.store} />;
     case "search":   return <SearchModal store={props.store} />;
+    case "board-new": return <BoardNewModal store={props.store} />;
     case "help":     return <HelpModal store={props.store} />;
   }
 }
@@ -68,6 +69,131 @@ interface DialogShellProps {
   width?: number;
 }
 
+// ─── New board ───────────────────────────────────────────────────────────────
+
+/**
+ * Onboarding and the `+` button are the same screen, differing only in title
+ * and in whether Escape works: on first run there is nothing behind it.
+ *
+ * Deliberately thin. Every step that touches the disk calls into
+ * `src/boards/`, which is also what `tuiboard board add` calls, so the two
+ * entry points cannot drift apart.
+ */
+function BoardNewModal(props: { store: TuiStore }) {
+  const w = createMemo(() => props.store.state.ui.boardNew);
+
+  const title = createMemo(() =>
+    w()?.mandatory ? "Welcome to tuiboard" : "New board",
+  );
+
+  const hint = createMemo(() => {
+    const b = w();
+    if (!b) return "";
+    if (b.step === "mode") return "j/k choose · Enter confirm" + (b.mandatory ? "" : " · Esc cancel");
+    if (b.step === "pick") return "j/k move · Space tick · Enter adopt · Esc back";
+    return "Enter confirm" + (b.mandatory ? "" : " · Esc cancel");
+  });
+
+  return (
+    <DialogShell title={title()} hint={hint()} width={MODAL_WIDTH}>
+      <Show when={w()}>
+        {(b: () => NonNullable<ReturnType<typeof w>>) => (
+          <box style={{ flexDirection: "column" }}>
+            <Show when={b().mandatory && b().step === "mode"}>
+              <text>
+                <span style={{ fg: T.textDim }}>
+                  No boards configured yet. Boards are plain markdown files.
+                </span>
+              </text>
+              <text> </text>
+            </Show>
+
+            {/* Step 1 — which way through */}
+            <Show when={b().step === "mode"}>
+              <For each={[
+                { key: "create", label: "Create a new board", desc: "a new markdown file" },
+                { key: "adopt", label: "Use files I already have", desc: "scan a folder" },
+              ]}>
+                {(opt, i) => (
+                  <text>
+                    <span style={{ fg: b().sel === i() ? T.accent : T.text }}>
+                      {b().sel === i() ? "▶ " : "  "}{opt.label}
+                    </span>
+                    <span style={{ fg: T.textDim }}>{"  — " + opt.desc}</span>
+                  </text>
+                )}
+              </For>
+            </Show>
+
+            {/* Step 2a — name, then columns */}
+            <Show when={b().step === "name"}>
+              <text><span style={{ fg: T.textDim }}>Board name</span></text>
+              <input
+                focused
+                value=""
+                onSubmit={((v: string) => props.store.boardNewSubmitText(v)) as any}
+              />
+              <text>
+                <span style={{ fg: T.textDim }}>{"It will live in " + b().dir}</span>
+              </text>
+            </Show>
+
+            <Show when={b().step === "columns"}>
+              <text><span style={{ fg: T.textDim }}>Columns, comma separated</span></text>
+              <input
+                focused
+                value={b().columns}
+                onSubmit={((v: string) => props.store.boardNewSubmitText(v)) as any}
+              />
+              <text>
+                <span style={{ fg: T.textDim }}>{"Creating " + b().name + ".md"}</span>
+              </text>
+            </Show>
+
+            {/* Step 2b — a folder, then what was found in it */}
+            <Show when={b().step === "dir"}>
+              <text><span style={{ fg: T.textDim }}>Folder to scan</span></text>
+              <input
+                focused
+                value={b().dir}
+                onSubmit={((v: string) => props.store.boardNewSubmitText(v)) as any}
+              />
+            </Show>
+
+            <Show when={b().step === "pick"}>
+              <text>
+                <span style={{ fg: T.textDim }}>
+                  {b().candidates.length + " board file(s) in " + b().dir}
+                </span>
+              </text>
+              <For each={b().candidates}>
+                {(c, i) => (
+                  <text>
+                    <span style={{ fg: b().sel === i() ? T.accent : T.text }}>
+                      {b().sel === i() ? "▶ " : "  "}
+                      {c.alreadyInConfig ? "· " : b().ticked.includes(i()) ? "✓ " : "  "}
+                      {c.suggestedName}
+                    </span>
+                    <span style={{ fg: T.textDim }}>
+                      {"  " + c.taskCount + (c.taskCount === 1 ? " task" : " tasks")
+                        + (c.alreadyInConfig ? " · already open" : "")}
+                    </span>
+                  </text>
+                )}
+              </For>
+            </Show>
+
+            <Show when={b().error}>
+              <text> </text>
+              <text><span style={{ fg: T.overdue }}>{b().error}</span></text>
+            </Show>
+          </box>
+        )}
+      </Show>
+    </DialogShell>
+  );
+}
+
 function DialogShell(props: DialogShellProps) {
   void props.width;
   return (
@@ -772,12 +898,14 @@ function AgentDetailModal(props: { store: TuiStore; modal: Extract<NonNullable<T
             <box style={{ height: 1 }} />
             <text>
               <span style={{ fg: T.textDim }}>
-                resume — press Enter in the agents list to open this in WezTerm:
+                resume — Enter opens this in WezTerm; c copies this command to paste anywhere:
               </span>
             </text>
             <text wrapMode="word">
               <span style={{ fg: T.scheduled }}>
-                claude --resume {s().sessionId}
+                {props.store.config.copyResumeCommand
+                  .replaceAll("{cwd}", s().cwd)
+                  .replaceAll("{sessionId}", s().sessionId)}
               </span>
             </text>
           </box>
@@ -803,6 +931,8 @@ function HelpModal(props: { store: TuiStore }) {
         <span style={{ fg: T.textDim }}>{"Navigation\n"}</span>
         <span style={{ fg: T.text }}>{"  h j k l  ←↑↓→     Move cursor inside the active zone\n"}</span>
         <span style={{ fg: T.text }}>{"  Tab               Next board (kanban zone)\n"}</span>
+        <span style={{ fg: T.text }}>{"  +                 New board — create one, or adopt files you have\n"}</span>
+        <span style={{ fg: T.text }}>{"  z                 Focus one pane (automatic below 100 columns)\n"}</span>
         <span style={{ fg: T.text }}>{"  1..9              Jump to board N\n"}</span>
         <span style={{ fg: T.text }}>{"  v                 Toggle Today/Tomorrow planner panel focus\n"}</span>
         <span style={{ fg: T.text }}>{"  Shift-Tab         Cycle active zone (planner → board → timeline → agents)\n"}</span>
@@ -845,6 +975,7 @@ function HelpModal(props: { store: TuiStore }) {
         <span style={{ fg: T.text }}>{"  /                 Search task titles — jumps cursor to first match\n"}</span>
         <span style={{ fg: T.textDim }}>{"\nAgents zone\n"}</span>
         <span style={{ fg: T.text }}>{"  Enter             Open (resume) the selected session in a new WezTerm tab\n"}</span>
+        <span style={{ fg: T.text }}>{"  c                 Copy a 'cd + claude --resume' command for the session\n"}</span>
         <span style={{ fg: T.text }}>{"  o                 Session detail (cwd, branch, last prompts, resume cmd)\n"}</span>
         <span style={{ fg: T.textDim }}>{"\nMulti-select\n"}</span>
         <span style={{ fg: T.text }}>{"  Space             Mark / unmark task (cursor stays — mark in any order)\n"}</span>

package/src/ui/PlannerPanel.tsx

@@ -40,7 +40,7 @@ export function PlannerPanel(props: { store: TuiStore }) {
   const groups = createMemo(() => groupPlannerItems(items()));
   const isActive = createMemo(() => props.store.state.ui.activeZone === "planner");
   const isZoomed = createMemo(
-    () => props.store.state.ui.zoomed && props.store.state.ui.activeZone === "planner",
+    () => props.store.singlePane() && props.store.state.ui.activeZone === "planner",
   );
   const cursorRow = createMemo(() => props.store.state.ui.row);
   let scrollBoxRef: ScrollBoxLike | undefined;

package/src/ui/pane-ring.ts

@@ -0,0 +1,73 @@
+/**
+ * The single-pane ring.
+ *
+ * When only one pane fits on screen, the zones stop being a layout — left and
+ * right no longer mean anything geometric — and become a sequence. This module
+ * builds that sequence and steps through it.
+ *
+ * The board is not one stop but many: in single-pane it renders a single
+ * column at full width, so each drawn column is its own pane. The result reads
+ * planner → column → column → … → agenda → agents, and closes into a ring.
+ *
+ * Pure: no store, no renderer, no terminal. The caller decides which zones are
+ * enabled and which columns are drawn — this only decides what comes next.
+ */
+
+export type RingZone = "planner" | "timeline" | "agents";
+
+export type Pane =
+  | { kind: "zone"; zone: RingZone }
+  | { kind: "column"; index: number };
+
+export interface RingInput {
+  /** Which zones the config enables. `board` is implied by renderedColumns. */
+  enabledZones: Record<"planner" | "board" | "timeline" | "agents", boolean>;
+  /**
+   * Board column indexes actually drawn, in order. Hidden columns (Done,
+   * Archive) must already be filtered out by the caller: a pane you cannot
+   * see is a dead end to step onto.
+   */
+  renderedColumns: readonly number[];
+}
+
+export function buildRing({ enabledZones, renderedColumns }: RingInput): Pane[] {
+  const ring: Pane[] = [];
+  if (enabledZones.planner) ring.push({ kind: "zone", zone: "planner" });
+  if (enabledZones.board) {
+    for (const index of renderedColumns) ring.push({ kind: "column", index });
+  }
+  if (enabledZones.timeline) ring.push({ kind: "zone", zone: "timeline" });
+  if (enabledZones.agents) ring.push({ kind: "zone", zone: "agents" });
+  return ring;
+}
+
+/**
+ * The next pane in `delta`'s direction, wrapping at both ends.
+ *
+ * A ring of one returns itself: stepping should feel like nothing happened,
+ * not like a wrap. If `current` is no longer in the ring — a column removed by
+ * a filter change or an external edit — the first pane is returned rather than
+ * something unrenderable.
+ */
+export function stepRing(ring: readonly Pane[], current: Pane, delta: 1 | -1): Pane {
+  if (ring.length === 0) return current;
+  if (ring.length === 1) return ring[0]!;
+
+  const at = ring.findIndex((p) => samePane(p, current));
+  if (at < 0) return ring[0]!;
+
+  const next = (at + delta + ring.length) % ring.length;
+  return ring[next]!;
+}
+
+export function samePane(a: Pane, b: Pane): boolean {
+  if (a.kind === "zone" && b.kind === "zone") return a.zone === b.zone;
+  if (a.kind === "column" && b.kind === "column") return a.index === b.index;
+  return false;
+}
+
+/** Where the current pane sits in the ring, for the position indicator. */
+export function ringPosition(ring: readonly Pane[], current: Pane): { at: number; of: number } {
+  const at = ring.findIndex((p) => samePane(p, current));
+  return { at: at < 0 ? 0 : at, of: ring.length };
+}

package/src/views/BoardOnly.tsx

@@ -18,16 +18,17 @@ import type { TuiStore } from "~/store/index";
 
 export function BoardOnly(props: { store: TuiStore }) {
   const ui = () => props.store.state.ui;
+  const singlePane = () => props.store.singlePane();
   const activeBoard = createMemo(
     () => props.store.state.boards[ui().activeBoardIndex]?.board,
   );
 
   return (
     <box style={{ flexDirection: "row", flexGrow: 1 }}>
-      <Show when={!ui().zoomed || ui().activeZone === "planner"}>
+      <Show when={!singlePane() || ui().activeZone === "planner"}>
         <PlannerPanel store={props.store} />
       </Show>
-      <Show when={(!ui().zoomed || ui().activeZone !== "planner") && activeBoard()}>
+      <Show when={(!singlePane() || ui().activeZone !== "planner") && activeBoard()}>
         <BoardView store={props.store} board={activeBoard()!} />
       </Show>
     </box>

package/src/views/Dashboard.tsx

@@ -38,7 +38,7 @@ export function Dashboard(props: { store: TuiStore }) {
 
   return (
     <Show
-      when={ui().zoomed}
+      when={props.store.singlePane()}
       fallback={<FourZoneLayout store={props.store} />}
     >
       <ZoomedLayout store={props.store} />
@@ -54,18 +54,46 @@ export function Dashboard(props: { store: TuiStore }) {
  * Board + planner share BoardOnly because both live in the top-left
  * zone of the normal layout and BoardOnly already respects ui.zoomed
  * to render only the active panel between them.
+ *
+ * Modals: the normal layout drops them into the Agenda's slot, which doesn't
+ * exist while zoomed — so here the modal floats as a centered absolute overlay
+ * on top of the zoomed view. The user stays zoomed; close the modal and the
+ * zoomed view is exactly as they left it (no exit-zoom / re-zoom flip).
  */
 function ZoomedLayout(props: { store: TuiStore }) {
-  const zone = () => props.store.state.ui.activeZone;
+  const ui = () => props.store.state.ui;
+  const zone = () => ui().activeZone;
 
   return (
-    <Show when={zone() === "timeline"} fallback={
-      <Show when={zone() === "agents"} fallback={<BoardOnly store={props.store} />}>
-        <AgentsOnly store={props.store} />
+    <>
+      <Show when={zone() === "timeline"} fallback={
+        <Show when={zone() === "agents"} fallback={<BoardOnly store={props.store} />}>
+          <AgentsOnly store={props.store} />
+        </Show>
+      }>
+        <TimelineOnly store={props.store} />
       </Show>
-    }>
-      <TimelineOnly store={props.store} />
-    </Show>
+      {/* Modal overlay — only while zoomed AND a modal is open. Absolute + high
+          zIndex so it paints over the zoomed view; centered; transparent
+          backdrop so the board stays visible behind the (opaque) modal panel. */}
+      <Show when={ui().modal}>
+        <box
+          style={{
+            position: "absolute",
+            top: 0,
+            left: 0,
+            right: 0,
+            bottom: 0,
+            zIndex: 100,
+            flexDirection: "column",
+            alignItems: "center",
+            justifyContent: "center",
+          }}
+        >
+          <ModalLayer store={props.store} />
+        </box>
+      </Show>
+    </>
   );
 }
 

package/tsconfig.json

@@ -0,0 +1,27 @@
+{
+  "compilerOptions": {
+    "target": "ESNext",
+    "module": "ESNext",
+    "moduleResolution": "bundler",
+    "lib": ["ESNext"],
+    "types": ["bun-types"],
+
+    "jsx": "preserve",
+    "jsxImportSource": "@opentui/solid",
+
+    "strict": true,
+    "noUncheckedIndexedAccess": true,
+    "noImplicitOverride": true,
+    "allowImportingTsExtensions": true,
+    "noEmit": true,
+    "skipLibCheck": true,
+    "esModuleInterop": true,
+    "resolveJsonModule": true,
+
+    "baseUrl": ".",
+    "paths": {
+      "~/*": ["src/*"]
+    }
+  },
+  "include": ["src/**/*"]
+}

package/src/cli/args.test.ts

@@ -1,40 +0,0 @@
-import { describe, expect, it } from "bun:test";
-import { parseArgs, type ViewKind } from "./args";
-
-describe("parseArgs", () => {
-  it("returns view=undefined when no flag is present", () => {
-    expect(parseArgs([])).toEqual({ view: undefined });
-    expect(parseArgs(["bun", "src/app.tsx"])).toEqual({ view: undefined });
-  });
-
-  it("parses --view=board", () => {
-    expect(parseArgs(["--view=board"])).toEqual({ view: "board" });
-  });
-
-  it("parses --view=timeline", () => {
-    expect(parseArgs(["--view=timeline"])).toEqual({ view: "timeline" });
-  });
-
-  it("parses --view=agents", () => {
-    expect(parseArgs(["--view=agents"])).toEqual({ view: "agents" });
-  });
-
-  it("parses --view <value> with space separator", () => {
-    expect(parseArgs(["--view", "board"])).toEqual({ view: "board" });
-  });
-
-  it("returns view=undefined for unknown view value (with warning to stderr)", () => {
-    const result = parseArgs(["--view=garbage"]);
-    expect(result.view).toBeUndefined();
-  });
-
-  it("ignores other flags", () => {
-    expect(parseArgs(["--debug", "--view=board", "--something-else"])).toEqual({
-      view: "board",
-    });
-  });
-});
-
-// Type-level assertion: ensure ViewKind covers exactly the four expected values.
-const _viewKinds: ViewKind[] = ["board", "timeline", "agents"];
-void _viewKinds;

package/src/scripts/agents-check.ts

@@ -1,24 +0,0 @@
-/**
- * Smoke check for the agents store. Lists the first 10 sessions
- * discovered on this machine with status, display name, and short cwd.
- *
- * Usage: bun run agents:check
- */
-
-import { createAgentsStore } from "~/store/agents";
-
-const store = createAgentsStore();
-const all = store.sessions();
-const live = all.filter(
-  (s) => s.status === "live-busy" || s.status === "live-idle",
-);
-
-console.log(`Found ${all.length} sessions, ${live.length} live`);
-console.log("");
-for (const s of all.slice(0, 10)) {
-  console.log(
-    `  ${s.status.padEnd(10)}  ${s.displayName.padEnd(40)}  ${s.cwdShort}`,
-  );
-}
-
-await store.dispose();

package/src/scripts/parse-check.ts

@@ -1,124 +0,0 @@
-/**
- * CLI smoke-test for the markdown parser.
- *
- * Usage:
- *   bun run src/scripts/parse-check.ts                # uses config-discovered boards
- *   bun run src/scripts/parse-check.ts <file.md>...   # parses specific files
- *
- * Prints per-board summary: columns, task counts, metadata coverage,
- * diagnostics, and a sample of parsed tasks so we can eyeball correctness.
- */
-
-import { readFileSync } from "node:fs";
-import { loadConfig } from "~/config/loader";
-import { isTask, parseBoard } from "~/parser/markdown";
-import type { Task } from "~/types";
-
-const args = process.argv.slice(2);
-const files: string[] = [];
-
-if (args.length > 0) {
-  files.push(...args);
-} else {
-  const cfg = loadConfig();
-  if (!cfg.loaded) {
-    console.error(
-      `No .tuiboard/config.yaml found from ${cfg.root}. Using fallback scan of cwd.`,
-    );
-  }
-  if (cfg.boards.length === 0) {
-    console.error("No boards configured and none found via fallback scan.");
-    process.exit(1);
-  }
-  files.push(...cfg.boards.map((b) => b.path));
-}
-
-let totalTasks = 0;
-let totalDone = 0;
-let totalWithSched = 0;
-let totalWithTimeBlock = 0;
-let totalLegacyTimeBlock = 0;
-let totalWithPriority = 0;
-let totalDiagnostics = 0;
-
-for (const file of files) {
-  let content: string;
-  try {
-    content = readFileSync(file, "utf-8");
-  } catch (e) {
-    console.error(`✗ Cannot read ${file}: ${(e as Error).message}`);
-    continue;
-  }
-
-  const { board, diagnostics } = parseBoard(content, { filepath: file });
-  const tasks: Task[] = [];
-  for (const col of board.columns) {
-    for (const child of col.children) {
-      if (isTask(child)) tasks.push(child);
-    }
-  }
-  const done = tasks.filter((t) => t.done).length;
-  const withSched = tasks.filter((t) => t.scheduled).length;
-  const withTime = tasks.filter((t) => t.timeBlock).length;
-  const legacyTime = tasks.filter((t) => t.timeBlockSource === "legacy-prefix").length;
-  const withPrio = tasks.filter((t) => t.priority !== "none").length;
-
-  totalTasks += tasks.length;
-  totalDone += done;
-  totalWithSched += withSched;
-  totalWithTimeBlock += withTime;
-  totalLegacyTimeBlock += legacyTime;
-  totalWithPriority += withPrio;
-  totalDiagnostics += diagnostics.length;
-
-  console.log(`\n━━━ ${board.name} ━━━`);
-  console.log(`  file:         ${file}`);
-  console.log(`  frontmatter:  ${board.frontmatter ? "yes" : "no"}`);
-  console.log(`  trailer:      ${board.trailer ? "yes" : "no"}`);
-  console.log(`  columns:      ${board.columns.length} — ${board.columns.map((c) => c.name).join(" │ ")}`);
-  console.log(`  tasks total:  ${tasks.length}  (${done} done, ${tasks.length - done} open)`);
-  console.log(`  scheduled:    ${withSched}`);
-  console.log(`  time blocks:  ${withTime}  (${legacyTime} legacy prefix, ${withTime - legacyTime} ⌚)`);
-  console.log(`  priority:     ${withPrio}`);
-  console.log(`  diagnostics:  ${diagnostics.length}`);
-
-  // Show first 3 diagnostics
-  for (const d of diagnostics.slice(0, 3)) {
-    console.log(`    [L${d.line}] ${d.level}: ${d.message}`);
-  }
-  if (diagnostics.length > 3) console.log(`    … and ${diagnostics.length - 3} more`);
-
-  // Show first 5 parsed open tasks for eyeballing
-  const sample = tasks.filter((t) => !t.done).slice(0, 5);
-  if (sample.length > 0) {
-    console.log("\n  sample tasks:");
-    for (const t of sample) {
-      const tb = t.timeBlock
-        ? ` ⌚${fmtMin(t.timeBlock.startMin)}-${fmtMin(t.timeBlock.endMin)}`
-        : "";
-      const sched = t.scheduled ? ` ⏳${t.scheduled}` : "";
-      const prio = t.priority !== "none" ? ` [${t.priority}]` : "";
-      const assignee = t.assignee ? ` @${t.assignee}` : "";
-      const tags = t.tags.length ? ` ${t.tags.map((x) => "#" + x).join(" ")}` : "";
-      console.log(`    • ${truncate(t.displayTitle, 60)}${prio}${assignee}${sched}${tb}${tags}`);
-    }
-  }
-}
-
-console.log("\n━━━ TOTALS ━━━");
-console.log(`  files:        ${files.length}`);
-console.log(`  tasks:        ${totalTasks}  (${totalDone} done)`);
-console.log(`  scheduled:    ${totalWithSched}`);
-console.log(`  time blocks:  ${totalWithTimeBlock}  (${totalLegacyTimeBlock} legacy, ${totalWithTimeBlock - totalLegacyTimeBlock} ⌚)`);
-console.log(`  priority:     ${totalWithPriority}`);
-console.log(`  diagnostics:  ${totalDiagnostics}`);
-
-function fmtMin(m: number): string {
-  const h = Math.floor(m / 60).toString().padStart(2, "0");
-  const mm = (m % 60).toString().padStart(2, "0");
-  return `${h}:${mm}`;
-}
-
-function truncate(s: string, n: number): string {
-  return s.length <= n ? s : s.slice(0, n - 1) + "…";
-}

package/src/scripts/roundtrip-check.ts

@@ -1,79 +0,0 @@
-/**
- * Roundtrip integrity check.
- *
- * Parses each board, serializes it back, and verifies bit-for-bit equality
- * with the original (no tasks are dirty since we haven't mutated anything,
- * so `serializeTask` falls through to `rawLine`). Any diff indicates a bug
- * in the parser or serializer's handling of structural elements (frontmatter,
- * headings, section breaks, trailer).
- *
- * Usage:
- *   bun run src/scripts/roundtrip-check.ts [file.md ...]
- *
- * Exit code 0 on success, 1 on any mismatch.
- */
-
-import { readFileSync } from "node:fs";
-import { loadConfig } from "~/config/loader";
-import { parseBoard } from "~/parser/markdown";
-import { serializeBoard } from "~/parser/serialize";
-
-const args = process.argv.slice(2);
-const files = args.length > 0 ? args : loadConfig().boards.map((b) => b.path);
-
-if (files.length === 0) {
-  console.error("No boards to check.");
-  process.exit(1);
-}
-
-let failures = 0;
-
-for (const file of files) {
-  let original: string;
-  try {
-    original = readFileSync(file, "utf-8");
-  } catch (e) {
-    console.error(`✗ ${file}: ${(e as Error).message}`);
-    failures++;
-    continue;
-  }
-
-  const { board } = parseBoard(original, { filepath: file });
-  const serialized = serializeBoard(board);
-
-  if (serialized === original) {
-    console.log(`✓ ${file}  (${original.length} bytes, ${board.columns.length} cols)`);
-    continue;
-  }
-
-  // Find the first difference for diagnostics.
-  const minLen = Math.min(serialized.length, original.length);
-  let diffAt = -1;
-  for (let i = 0; i < minLen; i++) {
-    if (serialized[i] !== original[i]) {
-      diffAt = i;
-      break;
-    }
-  }
-  if (diffAt === -1) diffAt = minLen;
-
-  const ctx = (s: string, at: number) => {
-    const from = Math.max(0, at - 40);
-    const to = Math.min(s.length, at + 40);
-    return JSON.stringify(s.slice(from, to));
-  };
-
-  console.error(`✗ ${file}: roundtrip differs at offset ${diffAt}`);
-  console.error(`  original size:    ${original.length}`);
-  console.error(`  serialized size:  ${serialized.length}`);
-  console.error(`  original    @ ${diffAt}: ${ctx(original, diffAt)}`);
-  console.error(`  serialized  @ ${diffAt}: ${ctx(serialized, diffAt)}`);
-  failures++;
-}
-
-if (failures > 0) {
-  console.error(`\n${failures} file(s) failed roundtrip.`);
-  process.exit(1);
-}
-
-console.log(`\nAll ${files.length} board(s) passed roundtrip.`);