@clapecho233/pi-smart-fold 0.1.0 → 0.2.0

package/lib/config.ts

@@ -8,18 +8,45 @@
 import { existsSync, readFileSync, writeFileSync } from "node:fs";
 import { join } from "node:path";
 
+export type ThinkingMode = "smart" | "tail" | "full" | "off";
+export type WriteCollapsedStyle = "header" | "preview";
+
 export interface SmartFoldConfig {
   /** Collapse tool output at every session start. Default: true */
   toolsFold: boolean;
-  /** Fold each thinking block down to its (live) last line. Default: true */
-  thinkingFold: boolean;
+  /**
+   * Thinking display strategy:
+   * - "smart": while the model thinks, show one live line with the elapsed
+   *   time and the scrolling tail of the thinking text; once the message is
+   *   finished, collapse to a single `Thinking… (Xs)` line. Clicking the line
+   *   twice (through pi's native hidden state) reveals the full text.
+   * - "tail":  always fold thinking to a single tail line (plus duration).
+   * - "full":  leave finished thinking unfolded (full markdown).
+   * - "off":   no thinking transformation at all.
+   * Default: "smart"
+   */
+  thinking: ThinkingMode;
+  /** Append `+N -M` line-diff stats to the write tool header. Default: true */
+  writeStat: boolean;
+  /**
+   * Collapsed write tool rows:
+   * - "header": only the `write <path> +N -M` line (fully collapsed).
+   * - "preview": keep pi's default content preview (10 lines).
+   * Default: "header"
+   */
+  writeCollapsed: WriteCollapsedStyle;
 }
 
 export const defaultConfig: SmartFoldConfig = {
   toolsFold: true,
-  thinkingFold: true,
+  thinking: "smart",
+  writeStat: true,
+  writeCollapsed: "header",
 };
 
+const THINKING_MODES: readonly ThinkingMode[] = ["smart", "tail", "full", "off"];
+const WRITE_STYLES: readonly WriteCollapsedStyle[] = ["header", "preview"];
+
 export function configFilePath(extensionDir: string): string {
   return join(extensionDir, "smart-fold.config.json");
 }
@@ -29,17 +56,38 @@ export function loadConfig(extensionDir: string): SmartFoldConfig {
   try {
     const file = configFilePath(extensionDir);
     if (!existsSync(file)) return { ...defaultConfig };
-    const parsed = JSON.parse(readFileSync(file, "utf8")) as Partial<SmartFoldConfig>;
+    const parsed = JSON.parse(readFileSync(file, "utf8")) as Record<string, unknown>;
     return {
-      toolsFold: typeof parsed.toolsFold === "boolean" ? parsed.toolsFold : defaultConfig.toolsFold,
-      thinkingFold:
-        typeof parsed.thinkingFold === "boolean" ? parsed.thinkingFold : defaultConfig.thinkingFold,
+      toolsFold:
+        typeof parsed.toolsFold === "boolean" ? parsed.toolsFold : defaultConfig.toolsFold,
+      thinking: migrateThinking(parsed),
+      writeStat:
+        typeof parsed.writeStat === "boolean" ? parsed.writeStat : defaultConfig.writeStat,
+      writeCollapsed:
+        typeof parsed.writeCollapsed === "string" &&
+        WRITE_STYLES.includes(parsed.writeCollapsed as WriteCollapsedStyle)
+          ? (parsed.writeCollapsed as WriteCollapsedStyle)
+          : defaultConfig.writeCollapsed,
     };
   } catch {
     return { ...defaultConfig };
   }
 }
 
+/** Accepts the new string form plus the legacy `thinkingFold: boolean`. */
+function migrateThinking(parsed: Record<string, unknown>): ThinkingMode {
+  if (
+    typeof parsed.thinking === "string" &&
+    THINKING_MODES.includes(parsed.thinking as ThinkingMode)
+  ) {
+    return parsed.thinking as ThinkingMode;
+  }
+  if (typeof parsed.thinkingFold === "boolean") {
+    return parsed.thinkingFold ? "smart" : "off";
+  }
+  return defaultConfig.thinking;
+}
+
 /** Persist config best-effort. Returns true on success. */
 export function saveConfig(extensionDir: string, config: SmartFoldConfig): boolean {
   try {

package/lib/fold.ts

@@ -1,5 +1,5 @@
 /**
- * pi-smart-fold — pure folding helpers.
+ * pi-smart-fold — pure folding / formatting helpers.
  *
  * No pi imports here: this module stays dependency-free and unit-testable
  * with plain `node` (Node >= 23 type stripping; no build step needed).
@@ -26,6 +26,10 @@ export function codePointWidth(cp: number): number {
   ) {
     return 0;
   }
+  // Wide: keycap-base misc-technical emoji (⏱ ⏳ ⏰ …) with emoji presentation
+  if (cp >= 0x23e9 && cp <= 0x23f3) {
+    return 2;
+  }
   // Wide: Hangul Jamo, CJK radicals/symbols, kana, Yi, Hangul syllables,
   // CJK ideographs (incl. ext A/B+), compat ideographs/forms, fullwidth forms,
   // common emoji planes
@@ -85,6 +89,13 @@ export function tailFit(input: string, maxWidth: number): string {
   return "…" + chars.slice(start).join("");
 }
 
+/** Clamp a renderer-provided width to something sane for one-line folding. */
+export function sanitizeWidth(availableWidth: number, fallback = 80): number {
+  return Number.isFinite(availableWidth) && availableWidth >= 8
+    ? Math.floor(availableWidth)
+    : fallback;
+}
+
 /** Last line of a markdown string whose trimmed content is non-empty. */
 export function lastNonEmptyLine(markdown: string): string {
   const lines = markdown.split(/\r?\n/);
@@ -94,6 +105,28 @@ export function lastNonEmptyLine(markdown: string): string {
   return "";
 }
 
+/** A markdown code-fence line: up to 3 spaces indent, then ``` or ~~~. */
+const FENCE_LINE = /^\s{0,3}(?:`{3,}|~{3,})/;
+
+/**
+ * Last line of a markdown string worth showing as a one-line tail: blank
+ * lines and structural code-fence lines are skipped, and lines that strip
+ * down to nothing (bare block markers) are skipped too. Returns "" when
+ * there is no such line — e.g. while the model is right at a code fence
+ * being streamed.
+ */
+export function lastMeaningfulLine(markdown: string): string {
+  const lines = markdown.split(/\r?\n/);
+  for (let i = lines.length - 1; i >= 0; i--) {
+    const raw = lines[i];
+    if (raw.trim() === "") continue;
+    if (FENCE_LINE.test(raw)) continue; // opening/closing fence — structural
+    const stripped = stripBlockMarkers(raw);
+    if (stripped !== "") return stripped;
+  }
+  return "";
+}
+
 /**
  * Strip common block-level markdown markers (`#`, `>`, `-`, `*`, `1.`)
  * so the collapsed line reads like prose. Runs a few passes for nesting
@@ -117,17 +150,266 @@ export function stripBlockMarkers(raw: string): string {
 
 /**
  * Collapse a thinking markdown block into a single line:
- * take its last non-empty line, strip block markers, and tail-truncate
+ * take its last meaningful line, strip block markers, and tail-truncate
  * to `availableWidth` display columns. Falls back to the original
  * markdown when there is nothing to show.
  */
 export function collapseThinking(markdown: string, availableWidth: number): string {
-  const line = stripBlockMarkers(lastNonEmptyLine(markdown));
+  if (lastNonEmptyLine(markdown) === "") return markdown; // nothing visible
+  const line = lastMeaningfulLine(markdown);
   if (!line) return markdown;
-  // Sanitize the width: renderers should always pass a positive number, but a
-  // missing/NaN value must degrade to a sane default instead of leaking NaN.
-  const width = Number.isFinite(availableWidth) && availableWidth >= 8
-    ? Math.floor(availableWidth)
-    : 80;
-  return tailFit(line, width);
+  return tailFit(line, sanitizeWidth(availableWidth));
+}
+
+// ---------------------------------------------------------------------------
+// Durations
+// ---------------------------------------------------------------------------
+
+const pad2 = (n: number): string => String(n).padStart(2, "0");
+
+/**
+ * Human-readable duration.
+ * - "live": whole seconds, for the ticking badge while the model thinks.
+ * - "final": one decimal below a minute, then `XmYYs` / `XhYYm`.
+ */
+export function formatDuration(ms: number, style: "live" | "final" = "final"): string {
+  if (!Number.isFinite(ms) || ms < 0) ms = 0;
+  const totalSeconds = Math.floor(ms / 1000);
+  if (style === "live") {
+    if (totalSeconds < 60) return `${totalSeconds}s`;
+    if (totalSeconds < 3600) return `${Math.floor(totalSeconds / 60)}m${pad2(totalSeconds % 60)}s`;
+    return `${Math.floor(totalSeconds / 3600)}h${pad2(Math.floor((totalSeconds % 3600) / 60))}m`;
+  }
+  if (ms < 60_000) return `${(ms / 1000).toFixed(1)}s`;
+  if (totalSeconds < 3600) return `${Math.floor(totalSeconds / 60)}m${pad2(totalSeconds % 60)}s`;
+  return `${Math.floor(totalSeconds / 3600)}h${pad2(Math.floor((totalSeconds % 3600) / 60))}m`;
+}
+
+// ---------------------------------------------------------------------------
+// Content hashing (stable identity for a thinking block across renders)
+// ---------------------------------------------------------------------------
+
+/** 32-bit FNV-1a of a string (UTF-16 code units). */
+function fnv1a(text: string): number {
+  let hash = 0x811c9dc5;
+  for (let i = 0; i < text.length; i++) {
+    hash ^= text.charCodeAt(i);
+    hash = Math.imul(hash, 0x01000193) >>> 0;
+  }
+  return hash >>> 0;
 }
+
+/**
+ * Cheap, stable content hash: `<length>:<fnv1a-hex>`.
+ * Used to match a rendered thinking block back to its recorded duration.
+ */
+export function hashText(text: string): string {
+  return `${text.length.toString(36)}:${fnv1a(text).toString(16)}`;
+}
+
+// ---------------------------------------------------------------------------
+// Line diff (for the write tool's `+N -M` stat)
+// ---------------------------------------------------------------------------
+
+export interface LineDiffStat {
+  added: number;
+  removed: number;
+}
+
+function splitLines(text: string): string[] {
+  return text.replace(/\n$/, "").split("\n");
+}
+
+/**
+ * Line-level added/removed counts between two file contents, git-diff style.
+ *
+ * Common prefix/suffix lines are trimmed first (cheap), then the middle is
+ * measured with an LCS table. When the middle is too large for the LCS
+ * budget (`maxCells`), it is treated as a full replacement.
+ * `oldText === undefined` means the file did not exist yet (everything added).
+ */
+export function countLineDiff(
+  oldText: string | undefined,
+  newText: string,
+  maxCells = 1_500_000,
+): LineDiffStat {
+  const next = splitLines(newText);
+  if (oldText === undefined) return { added: next.length, removed: 0 };
+  const prev = splitLines(oldText);
+  if (prev.join("\n") === next.join("\n")) return { added: 0, removed: 0 };
+
+  // Trim common prefix/suffix (without letting them overlap).
+  let prefix = 0;
+  while (prefix < prev.length && prefix < next.length && prev[prefix] === next[prefix]) prefix++;
+  let suffix = 0;
+  while (
+    suffix < prev.length - prefix &&
+    suffix < next.length - prefix &&
+    prev[prev.length - 1 - suffix] === next[next.length - 1 - suffix]
+  ) {
+    suffix++;
+  }
+  const a = prev.slice(prefix, prev.length - suffix);
+  const b = next.slice(prefix, next.length - suffix);
+  if (a.length === 0) return { added: b.length, removed: 0 };
+  if (b.length === 0) return { added: 0, removed: a.length };
+  if (a.length * b.length > maxCells) return { added: b.length, removed: a.length };
+
+  // LCS length over the middle sections (classic DP, row-major Uint32 table).
+  const n = a.length;
+  const m = b.length;
+  const stride = m + 1;
+  const dp = new Uint32Array((n + 1) * stride);
+  for (let i = n - 1; i >= 0; i--) {
+    const row = i * stride;
+    const nextRow = (i + 1) * stride;
+    for (let j = m - 1; j >= 0; j--) {
+      dp[row + j] =
+        a[i] === b[j]
+          ? dp[nextRow + j + 1] + 1
+          : Math.max(dp[nextRow + j], dp[row + j + 1]);
+    }
+  }
+  const common = dp[0];
+  return { added: b.length - common, removed: a.length - common };
+}
+
+/**
+ * Line-level added/removed counts summed over an edit tool's edits array
+ * (supports the legacy single oldText/newText shape). Returns undefined when
+ * there is nothing renderable.
+ */
+export function countEditsLineDiff(input: unknown): LineDiffStat | undefined {
+  if (!input || typeof input !== "object") return undefined;
+  const { edits, oldText, newText } = input as {
+    edits?: unknown;
+    oldText?: unknown;
+    newText?: unknown;
+  };
+  const editList = Array.isArray(edits)
+    ? edits
+    : typeof oldText === "string" && typeof newText === "string"
+      ? [{ oldText, newText }]
+      : [];
+  let added = 0;
+  let removed = 0;
+  let seen = false;
+  for (const edit of editList as Array<{ oldText?: unknown; newText?: unknown }>) {
+    if (!edit || typeof edit !== "object") continue;
+    const oldText = typeof edit.oldText === "string" ? edit.oldText : undefined;
+    const newText = typeof edit.newText === "string" ? edit.newText : undefined;
+    if (oldText === undefined && newText === undefined) continue;
+    const stat = countLineDiff(oldText, newText ?? "");
+    added += stat.added;
+    removed += stat.removed;
+    seen = true;
+  }
+  return seen ? { added, removed } : undefined;
+}
+
+// ---------------------------------------------------------------------------
+// Thinking line renderers (display-only, used by the markdown transformer)
+// ---------------------------------------------------------------------------
+
+/**
+ * The live two-line view shown while the model is thinking:
+ * ```
+ * Thinking… (8s)      ← bold label line
+ * <scrolling tail>     ← newest thinking text, tail-truncated
+ * ```
+ * Without a known elapsed time only the tail line is shown.
+ */
+export function liveThinkingLine(
+  markdown: string,
+  elapsedMs: number | undefined,
+  width: number,
+): string {
+  if (lastNonEmptyLine(markdown) === "") return markdown; // nothing visible
+  const tail = lastMeaningfulLine(markdown);
+  if (!tail) {
+    // Only structural lines so far (e.g. a bare code fence being streamed):
+    // show the label alone — falling back to the full text would flash the
+    // whole block open for a frame (the fold "flicker").
+    return elapsedMs === undefined
+      ? ""
+      : `**Thinking… (${formatDuration(elapsedMs, "live")})**`;
+  }
+  const fitted = tailFit(tail, sanitizeWidth(width));
+  if (elapsedMs === undefined) return fitted;
+  return `**Thinking… (${formatDuration(elapsedMs, "live")})**\n\n${fitted}`;
+}
+
+/**
+ * The single collapsed line shown once a thinking run has finished.
+ * - "smart": `Thought for 12.4s` (bold) — pi's native hidden-label look plus time.
+ * - "tail":  bold duration prefix + the last line (legacy one-line tail fold).
+ */
+export function foldedThinkingLine(
+  markdown: string,
+  ms: number | undefined,
+  width: number,
+  style: "smart" | "tail",
+): string {
+  const w = sanitizeWidth(width);
+  if (style === "tail") {
+    if (lastNonEmptyLine(markdown) === "") return markdown; // nothing visible
+    const tail = lastMeaningfulLine(markdown);
+    if (!tail) {
+      // Nothing textual (e.g. thinking ends right at a code fence): the
+      // duration line alone — never fall back to the full markdown.
+      return ms === undefined
+        ? "**Thought…**"
+        : `**Thought for ${formatDuration(ms, "final")}**`;
+    }
+    const prefix = ms === undefined ? "" : `**${formatDuration(ms, "final")}** · `;
+    return tailFit(prefix + tail, w);
+  }
+  return tailFit(
+    ms === undefined ? "**Thought…**" : `**Thought for ${formatDuration(ms, "final")}**`,
+    w,
+  );
+}
+
+/**
+ * Bold live-timing footer appended below fully-expanded thinking text while
+ * the run is still streaming (`\n\n**Thinking… (8s)**`), or an empty string
+ * when the elapsed time is unknown. Keeps updating at the bottom of the
+ * block while the full text grows.
+ */
+export function liveExpandedSuffix(ms: number | undefined): string {
+  return ms === undefined ? "" : `\n\n**Thinking… (${formatDuration(ms, "live")})**`;
+}
+
+/**
+ * Bold duration footer appended below fully-expanded thinking text
+ * (`\n\n**Thought for 12.4s**`), or an empty string when unknown.
+ */
+export function expandedThinkingSuffix(ms: number | undefined): string {
+  return ms === undefined ? "" : `\n\n**Thought for ${formatDuration(ms, "final")}**`;
+}
+
+/**
+ * Close a trailing unclosed fenced code block (``` or ~~~) so text appended
+ * after `markdown` — e.g. the expanded-view footer — renders BELOW the code
+ * block instead of inside it as literal characters (visible `**` asterisks).
+ * A closing fence must match the opening fence's character, be at least as
+ * long, and carry no info string. Balanced input passes through unchanged.
+ */
+export function closeOpenFences(markdown: string): string {
+  let fence: string | null = null;
+  for (const line of markdown.split(/\r?\n/)) {
+    const match = /^\s{0,3}(`{3,}|~{3,})(.*)$/.exec(line);
+    if (!match) continue;
+    if (fence === null) {
+      fence = match[1];
+    } else if (
+      match[1][0] === fence[0] &&
+      match[1].length >= fence.length &&
+      match[2].trim() === ""
+    ) {
+      fence = null;
+    }
+  }
+  return fence === null ? markdown : `${markdown}\n${fence}`;
+}
+

package/lib/thinking.ts

@@ -0,0 +1,194 @@
+/**
+ * pi-smart-fold — thinking-run timing.
+ *
+ * Tracks when each "thinking run" (a maximal group of consecutive thinking
+ * blocks inside one assistant message) starts and ends, so the UI can show a
+ * live elapsed time while the model thinks and a total duration afterwards.
+ * Durations are exposed by content hash and can be persisted/restored by the
+ * extension via session entries.
+ *
+ * Pure logic, no pi imports: unit-testable with plain `node`.
+ */
+import { hashText } from "./fold.ts";
+
+export interface ClosedThinkingRun {
+  hash: string;
+  ms: number;
+}
+
+/** Minimal structural types so tests can feed plain objects. */
+interface ContentLike {
+  type: string;
+  thinking?: string;
+}
+interface MessageLike {
+  content?: ContentLike[];
+}
+export interface AssistantMessageEventLike {
+  type: string;
+  contentIndex?: number;
+  delta?: string;
+  partial?: MessageLike;
+}
+
+interface OpenGroup {
+  start: number;
+  lastDelta: number;
+  /** Delta-accumulated fallback text. */
+  text: string;
+  /** Exact joined text once a thinking_end event has been observed. */
+  exact?: string;
+  /** True once a thinking_end event was seen for this group. */
+  ended?: boolean;
+}
+
+const MAX_TRACKED = 2000;
+
+export class ThinkingTracker {
+  private readonly now: () => number;
+  private current: OpenGroup | null = null;
+  private readonly finalized = new Map<string, number>();
+  private pending: ClosedThinkingRun[] = [];
+
+  constructor(nowFn: () => number = () => Date.now()) {
+    this.now = nowFn;
+  }
+
+  /** Feed `message_update`'s assistantMessageEvent (assistant messages only). */
+  handleUpdate(event: AssistantMessageEventLike): void {
+    const now = this.now();
+    switch (event.type) {
+      case "thinking_start": {
+        // The group continues when the content block right before this one is
+        // also thinking; anything else starts a fresh group (and closes the
+        // previous one).
+        const prevType = lastTypeBefore(event.partial, event.contentIndex);
+        if (!(this.current && prevType === "thinking")) {
+          this.closeCurrent();
+          this.current = { start: now, lastDelta: now, text: "" };
+        }
+        return;
+      }
+      case "thinking_delta": {
+        if (!this.current) this.current = { start: now, lastDelta: now, text: "" };
+        this.current.lastDelta = now;
+        if (typeof event.delta === "string") this.current.text += event.delta;
+        return;
+      }
+      case "thinking_end": {
+        if (this.current) {
+          const exact = trailingThinkingText(event.partial);
+          if (exact !== null) this.current.exact = exact;
+          this.current.lastDelta = now;
+          this.current.ended = true;
+        }
+        return;
+      }
+      default: {
+        // Any other content block starting (text, tool call, …) ends the run.
+        this.closeCurrent();
+      }
+    }
+  }
+
+  /**
+   * Close any open group for a finished assistant message and return the runs
+   * recorded since the last drain (for session persistence).
+   */
+  handleMessageEnd(message: MessageLike | undefined): ClosedThinkingRun[] {
+    if (this.current) {
+      const exact = trailingThinkingText(message);
+      if (exact !== null) this.current.exact = exact;
+      // A run that never saw thinking_end was cut off mid-stream or missed
+      // events: count up to the message end.
+      if (!this.current.ended) this.current.lastDelta = this.now();
+    }
+    this.closeCurrent();
+    return this.drainPending();
+  }
+
+  /** Live elapsed ms of the currently streaming thinking group, if any. */
+  liveElapsedMs(): number | undefined {
+    return this.current ? this.now() - this.current.start : undefined;
+  }
+
+  /** Duration of a finished group, keyed by its joined markdown hash. */
+  finalizedMs(hash: string): number | undefined {
+    return this.finalized.get(hash);
+  }
+
+  /**
+   * Render-time safety net: the TUI may re-render a message as finalized
+   * before our message_end handler runs. If the open group's text matches the
+   * rendered markdown, close it now and return its duration.
+   */
+  finalizeIfMatches(markdown: string): number | undefined {
+    if (!this.current) return undefined;
+    const hash = hashText(markdown);
+    if (hashText(this.current.exact ?? this.current.text) !== hash) return undefined;
+    this.closeCurrent();
+    return this.finalized.get(hash);
+  }
+
+  /** Merge durations restored from session entries. */
+  restore(runs: ClosedThinkingRun[]): void {
+    for (const run of runs) {
+      if (run && typeof run.hash === "string" && Number.isFinite(run.ms)) {
+        this.finalized.set(run.hash, Math.max(0, run.ms));
+      }
+    }
+  }
+
+  drainPending(): ClosedThinkingRun[] {
+    const out = this.pending;
+    this.pending = [];
+    return out;
+  }
+
+  private closeCurrent(): void {
+    const group = this.current;
+    if (!group) return;
+    this.current = null;
+    const text = group.exact ?? group.text;
+    if (!text.trim()) return;
+    const ms = Math.max(0, group.lastDelta - group.start);
+    const hash = hashText(text);
+    this.finalized.delete(hash); // re-insert to refresh insertion order
+    this.finalized.set(hash, ms);
+    if (this.finalized.size > MAX_TRACKED) {
+      let excess = this.finalized.size - MAX_TRACKED;
+      for (const key of this.finalized.keys()) {
+        if (excess-- <= 0) break;
+        this.finalized.delete(key);
+      }
+    }
+    this.pending.push({ hash, ms });
+  }
+}
+
+function lastTypeBefore(
+  message: MessageLike | undefined,
+  contentIndex: number | undefined,
+): string | undefined {
+  const content = message?.content;
+  if (!Array.isArray(content) || contentIndex === undefined) return undefined;
+  return content[Math.max(0, contentIndex - 1)]?.type;
+}
+
+/**
+ * Joined text of the trailing run of consecutive non-empty thinking blocks —
+ * exactly what pi's AssistantMessageComponent renders as one Markdown group
+ * (blocks are trimmed and joined with a blank line).
+ */
+export function trailingThinkingText(message: MessageLike | undefined): string | null {
+  const content = message?.content;
+  if (!Array.isArray(content)) return null;
+  const parts: string[] = [];
+  for (let i = content.length - 1; i >= 0; i--) {
+    const block = content[i];
+    if (block?.type !== "thinking") break;
+    const text = typeof block.thinking === "string" ? block.thinking.trim() : "";
+    if (text) parts.unshift(text);
+  }
+  return parts.length > 0 ? parts.join("\n\n") : null;
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@clapecho233/pi-smart-fold",
-  "version": "0.1.0",
+  "version": "0.2.0",
   "description": "pi coding-agent extension: collapse tool output at startup and fold thinking blocks to a live last line",
   "type": "module",
   "license": "MIT",
@@ -16,9 +16,18 @@
     ]
   },
   "scripts": {
-    "test": "node test/fold.test.mjs"
+    "postinstall": "node scripts/link-pi.mjs",
+    "link:pi": "node scripts/link-pi.mjs --required",
+    "typecheck": "tsc -p tsconfig.json",
+    "check": "node scripts/link-pi.mjs && tsc -p tsconfig.json && node scripts/load-check.mjs && node test/fold.test.mjs && node test/click-sim.mjs",
+    "test": "node test/fold.test.mjs",
+    "test:sim": "node test/click-sim.mjs"
   },
   "engines": {
     "node": ">=22.18"
+  },
+  "devDependencies": {
+    "@types/node": "^24.13.6",
+    "typescript": "5.9"
   }
 }