@cueloop/client 0.1.0-alpha.7 → 0.1.0-alpha.71

package/src/walk.ts

@@ -0,0 +1,74 @@
+/**
+ * Guided-walk projections: pure helpers over the diff row model - no
+ * IO, no React. The walk steps through the changed files in patch order;
+ * which files were seen lives on the session record (viewedPaths), which
+ * file is on screen is view state in the session controller.
+ */
+
+import type { Annotation } from "@cueloop/schema";
+import type { DiffRow } from "./view-diff";
+
+/** One wizard step: a changed file with its stats and a short diff preview. */
+export interface WalkFile {
+  path: string;
+  added: number;
+  removed: number;
+  /** The first changed lines, signed (+/-), for the card's diff preview. */
+  preview: { sign: "+" | "-"; text: string }[];
+}
+
+/** Preview lines per card: enough to recognize the change, never a full diff. */
+export const WALK_PREVIEW_ROWS = 5;
+
+/** Collapse the diff rows into one walk step per changed file, in patch order. */
+export function walkFiles(rows: DiffRow[]): WalkFile[] {
+  const files: WalkFile[] = [];
+  const byPath = new Map<string, WalkFile>();
+
+  for (const row of rows) {
+    let file = byPath.get(row.file);
+
+    if (!file) {
+      file = { path: row.file, added: 0, removed: 0, preview: [] };
+      byPath.set(row.file, file);
+      files.push(file);
+    }
+    if (row.kind !== "add" && row.kind !== "del") continue;
+    if (row.kind === "add") file.added += 1;
+    else file.removed += 1;
+    if (file.preview.length < WALK_PREVIEW_ROWS) {
+      file.preview.push({
+        sign: row.kind === "add" ? "+" : "-",
+        text: row.text.replace(/\n$/, ""),
+      });
+    }
+  }
+
+  return files;
+}
+
+/**
+ * Where the walk resumes: the first file not yet marked viewed. All files
+ * viewed = the end card (index === files.length), so a finished walk reopens
+ * on its summary instead of restarting.
+ */
+export function firstUnviewedIndex(files: WalkFile[], viewedPaths: ReadonlySet<string>): number {
+  const index = files.findIndex((file) => !viewedPaths.has(file.path));
+
+  return index === -1 ? files.length : index;
+}
+
+/** Viewed count against the CURRENT file set - stale paths never inflate it. */
+export function viewedCount(files: WalkFile[], viewedPaths: ReadonlySet<string>): number {
+  return files.filter((file) => viewedPaths.has(file.path)).length;
+}
+
+/**
+ * The agent's note for a file: an annotation with kind "note" whose anchor
+ * quote is the file path (the note contract in the shared review core).
+ */
+export function noteForFile(annotations: Annotation[], path: string): string | undefined {
+  return annotations.find(
+    (annotation) => annotation.kind === "note" && annotation.anchor.quote === path,
+  )?.body;
+}

package/src/syntax.test.ts

@@ -1,41 +0,0 @@
-import { describe, expect, test } from "bun:test";
-import { filetypeFor, highlightCode } from "./syntax";
-
-const TS = `export function gate(full: number) {
-  // threshold
-  return full < 0.6 ? "blocked" : "clear";
-}`;
-
-describe("highlightCode", () => {
-  test("token text concatenates back to the exact source (verbatim rendering)", async () => {
-    const lines = await highlightCode(TS, "ts");
-    expect(lines).not.toBeNull();
-    const rebuilt = lines!.map((l) => l.map((t) => t.content).join("")).join("\n");
-    expect(rebuilt).toBe(TS);
-  });
-
-  test("keywords, strings, and comments get distinct colors", async () => {
-    const lines = await highlightCode(TS, "ts");
-    const colorOf = (needle: string) => {
-      for (const line of lines!) for (const t of line) if (t.content.includes(needle)) return t.color;
-      return undefined;
-    };
-    const kw = colorOf("export");
-    const str = colorOf("blocked");
-    const comment = colorOf("threshold");
-    expect(kw).toBeDefined();
-    expect(str).toBeDefined();
-    expect(comment).toBeDefined();
-    expect(new Set([kw, str, comment]).size).toBe(3);
-  });
-
-  test("unknown languages return null and render unstyled", async () => {
-    expect(await highlightCode("whatever", "brainfog")).toBeNull();
-    expect(await highlightCode("plain", undefined)).toBeNull();
-  });
-
-  test("fence aliases map to real grammars", async () => {
-    expect(await highlightCode("x = 1", "py")).not.toBeNull();
-    expect(await highlightCode('echo "hi"', "sh")).not.toBeNull();
-  });
-});

package/src/syntax.ts

@@ -1,88 +0,0 @@
-/**
- * Code-block syntax highlighting via Shiki (#67): TextMate-grammar tokens
- * colored by a theme built from cueloop's tokens. The highlighter loads
- * lazily on the first code block; unknown languages render unstyled.
- */
-
-import { DARK as T } from "./theme";
-
-export interface CodeToken {
-  content: string;
-  color?: string;
-}
-
-type Highlighter = {
-  codeToTokensBase(code: string, opts: { lang: string; theme: string }): { content: string; color?: string }[][];
-  getLoadedLanguages(): string[];
-};
-
-const LANGS = ["typescript", "tsx", "javascript", "jsx", "json", "bash", "python", "rust", "go", "yaml", "diff", "markdown", "toml", "sql", "html", "css"];
-
-/** Markdown fence info → Shiki language id. */
-export function filetypeFor(lang?: string): string {
-  const l = (lang ?? "").toLowerCase();
-  const map: Record<string, string> = {
-    ts: "typescript",
-    js: "javascript",
-    py: "python",
-    rb: "ruby",
-    rs: "rust",
-    sh: "bash",
-    shell: "bash",
-    zsh: "bash",
-    yml: "yaml",
-  };
-  return map[l] ?? l;
-}
-
-function cueloopTheme() {
-  const scope = (scopes: string, foreground: string, fontStyle?: string) => ({
-    scope: scopes.split(", "),
-    settings: fontStyle ? { foreground, fontStyle } : { foreground },
-  });
-  return {
-    name: "cueloop",
-    type: "dark" as const,
-    colors: { "editor.background": T.elevated, "editor.foreground": T.textMuted },
-    settings: [
-      { settings: { foreground: T.textMuted } },
-      scope("comment, punctuation.definition.comment", T.textDim, "italic"),
-      scope("string, string.quoted, punctuation.definition.string", T.green),
-      scope("constant.numeric, constant.language, constant.character", T.blue),
-      scope("keyword, storage, storage.type, storage.modifier, keyword.control", T.accent),
-      scope("entity.name.function, support.function, meta.function-call", T.text),
-      scope("entity.name.type, entity.name.class, support.type, support.class", T.blue),
-      scope("variable, variable.other, variable.parameter", T.textMuted),
-      scope("entity.name.tag", T.accent),
-      scope("entity.other.attribute-name", T.blue),
-      scope("punctuation, meta.brace", T.textDim),
-      scope("keyword.operator", T.textDim),
-    ],
-  };
-}
-
-let highlighterPromise: Promise<Highlighter | null> | null = null;
-
-function getHighlighter(): Promise<Highlighter | null> {
-  highlighterPromise ??= import("shiki")
-    .then((shiki) => shiki.createHighlighter({ themes: [cueloopTheme()], langs: LANGS }) as Promise<Highlighter>)
-    .catch(() => null); // highlighting is an enhancement, never a blocker
-  return highlighterPromise;
-}
-
-/**
- * Tokenize code into styled lines. Token text concatenates back to the exact
- * source line, so verbatim rendering (indentation, no wrap) is preserved.
- * Returns null when the language is unknown or the highlighter is unavailable.
- */
-export async function highlightCode(content: string, lang?: string): Promise<CodeToken[][] | null> {
-  const language = filetypeFor(lang);
-  if (!language) return null;
-  const highlighter = await getHighlighter();
-  if (!highlighter || !highlighter.getLoadedLanguages().includes(language)) return null;
-  try {
-    return highlighter.codeToTokensBase(content, { lang: language, theme: "cueloop" });
-  } catch {
-    return null;
-  }
-}

package/src/view.test.ts

@@ -1,157 +0,0 @@
-import { describe, expect, test } from "bun:test";
-import {
-  blockRuns,
-  buildDisplay,
-  displayText,
-  marksByDisplay,
-  nextWorkBlock,
-  overlayMarks,
-  spanKey,
-  startSpan,
-  wrapRuns,
-} from "./view";
-import { cutBlock, parseBlocks, restoreBlock, restoreLine, type Annotation } from "@cueloop/schema";
-
-const BASE = `# Plan
-
-## Context
-
-The daemon persists sessions to disk atomically.
-
-- first item
-- second item
-`;
-
-describe("buildDisplay reconciliation", () => {
-  test("no working copy: everything is same", () => {
-    const d = buildDisplay(BASE);
-    expect(d.every((x) => x.type === "same")).toBe(true);
-  });
-
-  test("reworded block pairs as mod (similar)", () => {
-    const working = BASE.replace("persists sessions to disk", "writes sessions to disk");
-    const d = buildDisplay(BASE, working);
-    const mod = d.find((x) => x.type === "mod")!;
-    expect(mod.base!.text).toContain("persists");
-    expect(mod.work!.text).toContain("writes");
-  });
-
-  test("unrelated cut + insert do NOT merge into a mod", () => {
-    const working = BASE.replace("- second item\n", "") + "\nA totally new closing note.\n";
-    const d = buildDisplay(BASE, working);
-    expect(d.some((x) => x.type === "del" && x.base!.text === "second item")).toBe(true);
-    expect(d.some((x) => x.type === "add" && x.work!.text.includes("closing note"))).toBe(true);
-    expect(d.some((x) => x.type === "mod")).toBe(false);
-  });
-
-  test("ordered list items get running numbers", () => {
-    const d = buildDisplay("1. one\n2. two\n3. three\n");
-    expect(d.map((x) => x.oliNum)).toEqual([1, 2, 3]);
-  });
-});
-
-describe("blockRuns + overlayMarks", () => {
-  test("mod blocks emit word-diff runs that reconstruct both sides", () => {
-    const d = buildDisplay("plain old text here\n", "plain new text here\n")[0]!;
-    const runs = blockRuns(d, true);
-    const oldSide = runs.filter((r) => r.role !== "ins").map((r) => r.text).join("");
-    const newSide = runs.filter((r) => r.role !== "del").map((r) => r.text).join("");
-    expect(oldSide).toBe("plain old text here");
-    expect(newSide).toBe("plain new text here");
-  });
-
-  test("marks bind to working-text offsets and skip del runs", () => {
-    const d = buildDisplay("old words linger\n", "new words linger\n")[0]!;
-    const runs = blockRuns(d, true);
-    const marked = overlayMarks(runs, [{ start: 4, end: 9, role: "mark-comment" }]); // "words"
-    const markedText = marked.filter((r) => r.role === "mark-comment").map((r) => r.text).join("");
-    expect(markedText).toBe("words");
-    // del run text untouched
-    expect(marked.some((r) => r.role === "del" && r.text === "old")).toBe(true);
-  });
-
-  test("marks never override ins emphasis", () => {
-    const d = buildDisplay("keep\n", "keep added\n")[0]!;
-    const runs = overlayMarks(blockRuns(d, true), [{ start: 0, end: 10, role: "mark-comment" }]);
-    expect(runs.some((r) => r.role === "ins")).toBe(true);
-  });
-});
-
-describe("marksByDisplay", () => {
-  test("annotations resolve into display coordinates", () => {
-    const working = BASE.replace("first item", "first item edited beyond recognition of it");
-    const display = buildDisplay(BASE, working);
-    const ann: Annotation = {
-      id: "a1",
-      kind: "comment",
-      anchor: { quote: "atomically", prefix: "to disk ", suffix: "." },
-      body: "define atomically",
-      createdAt: "",
-    };
-    const map = marksByDisplay([ann], display);
-    const [dispIdx, marks] = [...map.entries()][0]!;
-    expect(displayText(display[dispIdx]!)).toContain("atomically");
-    expect(marks[0]!.annotationId).toBe("a1");
-  });
-
-  test("orphaned annotations produce no marks", () => {
-    const display = buildDisplay(BASE);
-    const ann: Annotation = {
-      id: "a1",
-      kind: "comment",
-      anchor: { quote: "text that is gone", prefix: "", suffix: "" },
-      body: "",
-      createdAt: "",
-    };
-    expect(marksByDisplay([ann], display).size).toBe(0);
-  });
-});
-
-describe("wrapRuns", () => {
-  test("wraps at word boundaries within width", () => {
-    const lines = wrapRuns([{ text: "alpha beta gamma delta", role: "plain", start: 0 }], 11);
-    const rendered = lines.map((l) => l.map((r) => r.text).join(""));
-    expect(rendered.every((l) => l.length <= 11)).toBe(true);
-    expect(rendered.join(" ").replace(/\s+/g, " ").trim()).toBe("alpha beta gamma delta");
-  });
-
-  test("hard-splits words longer than the width", () => {
-    const lines = wrapRuns([{ text: "abcdefghij", role: "plain", start: 0 }], 4);
-    expect(lines.length).toBeGreaterThan(1);
-  });
-
-  test("newlines force line breaks (code blocks)", () => {
-    const lines = wrapRuns([{ text: "line1\nline2", role: "plain", start: 0 }], 80);
-    expect(lines.length).toBe(2);
-  });
-});
-
-describe("span mode", () => {
-  const text = "one two three four";
-  test("v selects the first word; l grows; w slides; $ to end", () => {
-    let s = startSpan(0, text)!;
-    expect(text.slice(s.start, s.end)).toBe("one");
-    s = spanKey(s, "l", text);
-    expect(text.slice(s.start, s.end)).toBe("one two");
-    s = spanKey(s, "w", text);
-    expect(text.slice(s.start, s.end)).toBe("two three");
-    s = spanKey(s, "$", text);
-    expect(text.slice(s.start, s.end)).toBe("two three four");
-  });
-});
-
-describe("cut / restore round-trip", () => {
-  test("cut removes the block lines; restore puts them back", () => {
-    const blocks = parseBlocks(BASE);
-    const li = blocks.find((b) => b.text === "second item")!;
-    const cut = cutBlock(BASE, li);
-    expect(cut).not.toContain("second item");
-    const display = buildDisplay(BASE, cut);
-    const delIdx = display.findIndex((d) => d.type === "del");
-    const line = restoreLine(nextWorkBlock(display, delIdx), cut.split("\n").length);
-    // undefined = the working copy round-tripped back to the submitted revision
-    const restored = restoreBlock(BASE, cut, li, line);
-    expect(restored).toBeUndefined();
-    expect(buildDisplay(BASE, restored).every((d) => d.type === "same")).toBe(true);
-  });
-});

package/src/view.ts

@@ -1,312 +0,0 @@
-/**
- * The projection pipeline (#22): parse → display blocks (base vs working
- * copy reconciled) → styled runs → wrapped lines. Pure functions - the TUI
- * renders the output, tests assert on it directly. One planning layer:
- * rendering, navigation, and selection all derive from this module.
- */
-
-import {
-  lcsDiff,
-  parseBlocks,
-  resolveAnchor,
-  wordDiff,
-  type Annotation,
-  type Block,
-} from "@cueloop/schema";
-
-// ── display model ─────────────────────────────
-
-export type DisplayType = "same" | "mod" | "del" | "add";
-
-export interface DisplayBlock {
-  type: DisplayType;
-  kind: Block["kind"];
-  /** Block in the working copy (absent for del). */
-  work?: Block;
-  /** Block in the submitted revision (absent for add). */
-  base?: Block;
-  oliNum?: number;
-}
-
-export function displayText(d: DisplayBlock): string {
-  return (d.work ?? d.base)!.text;
-}
-
-/** Word-overlap similarity gate: an unrelated cut + insert must not merge. */
-function similar(a: Block, b: Block): boolean {
-  if (a.kind !== b.kind) return false;
-  const words = (t: string) => new Set(t.toLowerCase().split(/\s+/).filter(Boolean));
-  const wa = words(a.text);
-  const wb = words(b.text);
-  let inter = 0;
-  for (const w of wa) if (wb.has(w)) inter++;
-  const union = wa.size + wb.size - inter;
-  return union === 0 ? true : inter / union >= 0.3;
-}
-
-/** Reconcile base blocks vs working blocks into the display list. */
-export function buildDisplay(baseContent: string, workingContent?: string): DisplayBlock[] {
-  const baseBlocks = parseBlocks(baseContent);
-  if (workingContent === undefined) {
-    const out: DisplayBlock[] = baseBlocks.map((b) => ({ type: "same", kind: b.kind, work: b, base: b }));
-    numberOlis(out);
-    return out;
-  }
-  const workBlocks = parseBlocks(workingContent);
-  const sig = (b: Block) => b.kind + "\0" + b.text;
-  const ops = lcsDiff(baseBlocks, workBlocks, (x, y) => sig(x) === sig(y));
-  const out: DisplayBlock[] = [];
-  let k = 0;
-  while (k < ops.length) {
-    const op = ops[k]!;
-    if (op.t === "ctx") {
-      out.push({ type: "same", kind: op.b!.kind, work: op.b, base: op.a });
-      k++;
-      continue;
-    }
-    const dels: Block[] = [];
-    const adds: Block[] = [];
-    while (k < ops.length && ops[k]!.t !== "ctx") {
-      const o = ops[k]!;
-      if (o.t === "del") dels.push(o.a!);
-      else adds.push(o.b!);
-      k++;
-    }
-    let di = 0;
-    let ai = 0;
-    while (di < dels.length && ai < adds.length) {
-      if (similar(dels[di]!, adds[ai]!)) {
-        out.push({ type: "mod", kind: adds[ai]!.kind, base: dels[di]!, work: adds[ai]! });
-        di++;
-        ai++;
-      } else if (dels.length - di >= adds.length - ai) {
-        out.push({ type: "del", kind: dels[di]!.kind, base: dels[di]! });
-        di++;
-      } else {
-        out.push({ type: "add", kind: adds[ai]!.kind, work: adds[ai]! });
-        ai++;
-      }
-    }
-    while (di < dels.length) out.push({ type: "del", kind: dels[di]!.kind, base: dels[di++]! });
-    while (ai < adds.length) out.push({ type: "add", kind: adds[ai]!.kind, work: adds[ai++]! });
-  }
-  numberOlis(out);
-  return out;
-}
-
-function numberOlis(disp: DisplayBlock[]): void {
-  let run = 0;
-  for (const d of disp) {
-    if (d.kind === "oli") d.oliNum = ++run;
-    else run = 0;
-  }
-}
-
-// ── marks (annotation highlights + keyboard span) ──
-
-export type RunRole =
-  | "plain"
-  | "ins"
-  | "del"
-  | "mark-comment"
-  | "mark-suggestion"
-  | "kspan"
-  | "mark-focus";
-
-export interface StyleRun {
-  text: string;
-  role: RunRole;
-  /** Offset of this run in the block's working text; null for del runs. */
-  start: number | null;
-  annotationId?: string;
-}
-
-export interface Mark {
-  start: number;
-  end: number;
-  role: RunRole;
-  annotationId?: string;
-}
-
-/**
- * Resolve annotations against the working blocks and group marks per display
- * index. Working blocks are the blocks of (workingCopy ?? artifact) - the
- * same list buildDisplay derived work entries from.
- */
-export function marksByDisplay(
-  annotations: Annotation[],
-  display: DisplayBlock[],
-  focusedId?: string,
-): Map<number, Mark[]> {
-  // block list in "work space": display entries that carry a work block, in order
-  const workEntries = display
-    .map((d, dispIdx) => ({ d, dispIdx }))
-    .filter((e) => e.d.work !== undefined);
-  const workBlocks = workEntries.map((e) => e.d.work!);
-  const map = new Map<number, Mark[]>();
-  for (const a of annotations) {
-    const res = resolveAnchor(a.anchor, workBlocks);
-    if (!res) continue;
-    const entry = workEntries[res.blockIndex];
-    if (!entry) continue;
-    const marks = map.get(entry.dispIdx) ?? [];
-    marks.push({
-      start: res.start,
-      end: res.end,
-      role: a.id === focusedId ? "mark-focus" : a.kind === "suggestion" ? "mark-suggestion" : "mark-comment",
-      annotationId: a.id,
-    });
-    map.set(entry.dispIdx, marks);
-  }
-  return map;
-}
-
-/** Base runs for a display block: plain text, or word-diff for mod blocks. */
-export function blockRuns(d: DisplayBlock, markup: boolean): StyleRun[] {
-  if (d.type === "mod" && markup) {
-    const ops = wordDiff(d.base!.text, d.work!.text);
-    const runs: StyleRun[] = [];
-    let off = 0;
-    for (const op of ops) {
-      if (op.t === "del") {
-        runs.push({ text: op.a!, role: "del", start: null });
-      } else {
-        runs.push({ text: op.b!, role: op.t === "add" ? "ins" : "plain", start: off });
-        off += op.b!.length;
-      }
-    }
-    return runs;
-  }
-  return [{ text: displayText(d), role: "plain", start: 0 }];
-}
-
-/** Split runs at mark boundaries; marks only bind to runs with offsets. */
-export function overlayMarks(runs: StyleRun[], marks: Mark[]): StyleRun[] {
-  if (!marks.length) return runs;
-  const out: StyleRun[] = [];
-  for (const run of runs) {
-    if (run.start === null) {
-      out.push(run);
-      continue;
-    }
-    const bounds = new Set<number>([0, run.text.length]);
-    for (const m of marks) {
-      const s = Math.max(0, m.start - run.start);
-      const e = Math.min(run.text.length, m.end - run.start);
-      if (s < e) {
-        bounds.add(s);
-        bounds.add(e);
-      }
-    }
-    const runStart = run.start;
-    const pts = [...bounds].sort((a, b) => a - b);
-    for (let i = 0; i < pts.length - 1; i++) {
-      const s = pts[i]!;
-      const e = pts[i + 1]!;
-      if (s >= e) continue;
-      const abs = runStart + s;
-      const mark = marks.find((m) => m.start <= abs && runStart + e <= m.end);
-      out.push({
-        text: run.text.slice(s, e),
-        // a mark never overrides ins/del emphasis; it rides on plain text
-        role: mark && run.role === "plain" ? mark.role : run.role,
-        start: abs,
-        annotationId: mark?.annotationId ?? run.annotationId,
-      });
-    }
-  }
-  return out;
-}
-
-/** Wrap styled runs into lines of at most `width` display cells. */
-export function wrapRuns(runs: StyleRun[], width: number): StyleRun[][] {
-  const lines: StyleRun[][] = [];
-  let line: StyleRun[] = [];
-  let used = 0;
-  const pushLine = () => {
-    lines.push(line);
-    line = [];
-    used = 0;
-  };
-  for (const run of runs) {
-    // split run into word/space tokens; newlines force breaks
-    const tokens = run.text.split(/(\n|\s+)/).filter((t) => t !== "");
-    for (const tok of tokens) {
-      if (tok === "\n") {
-        pushLine();
-        continue;
-      }
-      if (used + tok.length > width && used > 0 && tok.trim() !== "") pushLine();
-      if (tok.trim() === "" && used === 0 && lines.length > 0) continue; // no leading spaces after wrap
-      let slice = tok;
-      while (slice.length > width) {
-        line.push({ ...run, text: slice.slice(0, width - used) });
-        slice = slice.slice(width - used);
-        pushLine();
-      }
-      line.push({ ...run, text: slice });
-      used += slice.length;
-    }
-  }
-  if (line.length || !lines.length) lines.push(line);
-  return lines;
-}
-
-// ── keyboard span mode ────────────────────────
-
-export interface SpanState {
-  dispIdx: number;
-  wordIdx: number;
-  wordEnd: number;
-  start: number;
-  end: number;
-}
-
-export function wordRanges(text: string): [number, number][] {
-  const out: [number, number][] = [];
-  const re = /\S+/g;
-  let m: RegExpExecArray | null;
-  while ((m = re.exec(text))) out.push([m.index, m.index + m[0]!.length]);
-  return out;
-}
-
-export function startSpan(dispIdx: number, text: string): SpanState | null {
-  const words = wordRanges(text);
-  if (!words.length) return null;
-  return { dispIdx, wordIdx: 0, wordEnd: 0, start: words[0]![0], end: words[0]![1] };
-}
-
-export function spanKey(span: SpanState, key: string, text: string): SpanState {
-  const words = wordRanges(text);
-  const s = { ...span };
-  const width = s.wordEnd - s.wordIdx;
-  if (key === "l") s.wordEnd = Math.min(words.length - 1, s.wordEnd + 1);
-  else if (key === "h") s.wordEnd = Math.max(s.wordIdx, s.wordEnd - 1);
-  else if (key === "w") {
-    const n = Math.min(words.length - 1 - width, s.wordIdx + 1);
-    s.wordIdx = n;
-    s.wordEnd = n + width;
-  } else if (key === "b") {
-    const n = Math.max(0, s.wordIdx - 1);
-    s.wordIdx = n;
-    s.wordEnd = n + width;
-  } else if (key === "$") s.wordEnd = words.length - 1;
-  else if (key === "0") {
-    s.wordEnd = width;
-    s.wordIdx = 0;
-  } else return span;
-  s.start = words[s.wordIdx]![0];
-  s.end = words[s.wordEnd]![1];
-  return s;
-}
-
-// ── working-copy block operations ─────────────
-
-/** The next work block after a display index (a del block re-enters before it). */
-export function nextWorkBlock(display: DisplayBlock[], dispIdx: number): Block | undefined {
-  for (let i = dispIdx + 1; i < display.length; i++) {
-    const w = display[i]!.work;
-    if (w) return w;
-  }
-  return undefined;
-}