@cueloop/client 0.1.0-alpha.9 → 0.1.0-alpha.90

package/src/session-controller.ts

@@ -1,398 +0,0 @@
-/**
- * The review-session controller (#70): every daemon round-trip and mutation
- * verb behind one React-free object. It owns connect/autostart/subscribe,
- * the session/inbox/status/error snapshot, optimistic apply, the mutation
- * verbs (cut/edit/annotate/submit/...), and the post-submit completion
- * lifecycle including the notes-vault export and the herdr return-focus.
- * App subscribes to snapshots and keeps only view state.
- */
-
-import { DaemonClient } from "@cueloop/daemon/client";
-import {
-  cutBlock,
-  makeAnchor,
-  newAnnotationId,
-  parseBlocks,
-  resolveAnchor,
-  restoreBlock,
-  restoreLine,
-  type ReviewSession,
-  type VerdictKind,
-} from "@cueloop/schema";
-import { Registry, type Exporter } from "@cueloop/extension-api";
-import { createObsidianExtension, shouldExport, type ObsidianConfig } from "@cueloop/integration-obsidian";
-import { buildDisplay, nextWorkBlock, type DisplayBlock } from "./view";
-import { diffRowAnchor, diffRows, type DiffRow } from "./view-diff";
-import { editInEditor } from "./editor";
-import { focusHerdrPane, returnPaneFor } from "./herdr";
-import { persistAutoClose, type AutoClose, type CueloopConfig } from "./config";
-
-/**
- * Post-submit lifecycle (a review pane should hand you back to the agent,
- * not linger): idle → prompt (auto-close off: offer the choice) or
- * counting (configured delay) → exit. esc dismisses to the resolved view.
- */
-export type Completion =
-  | { phase: "idle" }
-  | { phase: "prompt" }
-  | { phase: "counting"; remaining: number }
-  | { phase: "dismissed" };
-
-export interface ControllerSnapshot {
-  session: ReviewSession | null;
-  inbox: ReviewSession[] | null;
-  status: string;
-  error: string | null;
-  completion: Completion;
-  /**
-   * Annotations whose anchor stopped resolving after the last editor
-   * hand-off - the reconciliation banner count. 0 = no banner.
-   */
-  editOrphanCount: number;
-}
-
-export interface ReviewControllerOptions {
-  home?: string;
-  sessionId?: string;
-  /** Observer mode: stored for the key reducer's read-only gate. */
-  readOnly?: boolean;
-  onExit?: (code: number) => void;
-}
-
-export interface ReviewController {
-  readonly readOnly: boolean;
-  /** Snapshot listeners (stable identity - safe for useSyncExternalStore). */
-  subscribe(listener: () => void): () => void;
-  getSnapshot(): ControllerSnapshot;
-  /** Dial the daemon (autostart), subscribe to events, fetch session or inbox. */
-  connect(): void;
-  close(): void;
-  /** Loaded config parts the controller acts on: auto-close and exporters. */
-  applyConfig(cfg: CueloopConfig): void;
-  setStatus(msg: string): void;
-  /** Derived projections, cached per session identity. */
-  display(): DisplayBlock[];
-  rows(): DiffRow[];
-  working(): string;
-  /** Open a session from the inbox. */
-  open(id: string): void;
-  /** Cut the block under the cursor, or restore a cut one. */
-  cut(dispIdx: number): void;
-  /** The $EDITOR hand-off on the working copy. */
-  edit(): void;
-  /**
-   * Anchor and store an annotation; both plan and diff anchor constructions.
-   * Returns the minted annotation id so the view can select the new card.
-   */
-  annotate(kind: "comment" | "suggestion", dispIdx: number, start: number, end: number, body: string): string | undefined;
-  /** Rewrite a stored annotation's body in place (the rail-card edit). */
-  updateAnnotation(id: string, body: string): void;
-  removeAnnotation(id: string): void;
-  setWorkingCopy(content: string | undefined): void;
-  /** Resolve the review, run the export, start the completion hand-back. */
-  submit(verdict: VerdictKind, summary: string): void;
-  /** Close the review and, inside herdr, bounce focus back to the agent. */
-  finishReview(): void;
-  dismissCompletion(): void;
-  /** From the completion prompt: persist auto-close and start the countdown. */
-  optInAutoClose(): void;
-}
-
-export function createReviewController(opts: ReviewControllerOptions): ReviewController {
-  return new Controller(opts);
-}
-
-class Controller implements ReviewController {
-  readonly readOnly: boolean;
-  private client: DaemonClient | null = null;
-  private closed = false;
-  private snap: ControllerSnapshot = {
-    session: null,
-    inbox: null,
-    status: "",
-    error: null,
-    completion: { phase: "idle" },
-    editOrphanCount: 0,
-  };
-  private listeners = new Set<() => void>();
-  private autoClose: AutoClose = "off";
-  private obsidian: ObsidianConfig | null = null;
-  private exporters = new Map<string, Exporter>();
-  private countdown: ReturnType<typeof setTimeout> | undefined;
-  /** Projections keyed by session identity so renders reuse one computation. */
-  private derivedFor: ReviewSession | null = null;
-  private derived: { display: DisplayBlock[]; rows: DiffRow[] } = { display: [], rows: [] };
-
-  constructor(private readonly opts: ReviewControllerOptions) {
-    this.readOnly = opts.readOnly ?? false;
-  }
-
-  subscribe = (listener: () => void): (() => void) => {
-    this.listeners.add(listener);
-    return () => this.listeners.delete(listener);
-  };
-
-  getSnapshot = (): ControllerSnapshot => this.snap;
-
-  private update(patch: Partial<ControllerSnapshot>): void {
-    this.snap = { ...this.snap, ...patch };
-    for (const l of this.listeners) l();
-  }
-
-  connect(): void {
-    void (async () => {
-      try {
-        const client = await DaemonClient.connect({ home: this.opts.home, autostart: true });
-        if (this.closed) return void client.close();
-        this.client = client;
-        client.onEvent((e) => {
-          // another controller/observer changed state: re-fetch
-          const s = this.snap.session;
-          if (s && e.sessionId === s.id) void this.refreshSession(s.id);
-          if (!this.opts.sessionId) void this.refreshInbox();
-        });
-        await client.subscribe();
-        if (this.opts.sessionId) {
-          this.update({ session: await client.sessionGet(this.opts.sessionId) });
-        } else {
-          this.update({ inbox: await client.sessionList({ status: "pending" }) });
-        }
-      } catch (err) {
-        this.update({ error: err instanceof Error ? err.message : String(err) });
-      }
-    })();
-  }
-
-  close(): void {
-    this.closed = true;
-    clearTimeout(this.countdown);
-    this.client?.close();
-  }
-
-  applyConfig(cfg: CueloopConfig): void {
-    this.autoClose = cfg.ui.autoClose;
-    this.obsidian = cfg.integrations.obsidian;
-    // bundled integrations register through the public extension API
-    const registry = new Registry();
-    void registry.load("obsidian", createObsidianExtension(cfg.integrations.obsidian)).then((rec) => {
-      this.exporters = rec.exporters;
-    });
-  }
-
-  setStatus(msg: string): void {
-    this.update({ status: msg });
-  }
-
-  // ── derived projections ─────────────────────
-  private ensureDerived(): void {
-    const s = this.snap.session;
-    if (this.derivedFor === s) return;
-    this.derivedFor = s;
-    this.derived = {
-      display: s ? buildDisplay(s.artifact.content, s.workingCopy) : [],
-      rows: s && s.artifact.type === "diff" ? diffRows(s.artifact.content) : [],
-    };
-  }
-
-  display(): DisplayBlock[] {
-    this.ensureDerived();
-    return this.derived.display;
-  }
-
-  rows(): DiffRow[] {
-    this.ensureDerived();
-    return this.derived.rows;
-  }
-
-  working(): string {
-    const s = this.snap.session;
-    return s ? (s.workingCopy ?? s.artifact.content) : "";
-  }
-
-  private async refreshSession(id: string): Promise<void> {
-    if (this.client) this.update({ session: await this.client.sessionGet(id) });
-  }
-
-  private async refreshInbox(): Promise<void> {
-    if (this.client) this.update({ inbox: await this.client.sessionList({ status: "pending" }) });
-  }
-
-  /** Optimistic apply: the daemon response is the next session snapshot. */
-  private apply(p: Promise<ReviewSession>): void {
-    p.then((session) => this.update({ session })).catch((e: unknown) =>
-      this.setStatus(String(e instanceof Error ? e.message : e)),
-    );
-  }
-
-  // ── verbs ───────────────────────────────────
-  open(id: string): void {
-    const cached = this.snap.inbox?.find((s) => s.id === id);
-    if (cached) this.update({ session: cached });
-    else void this.refreshSession(id);
-  }
-
-  cut(dispIdx: number): void {
-    const session = this.snap.session;
-    if (!session || session.status === "resolved") return;
-    const d = this.display()[dispIdx];
-    if (!d) return;
-    const working = this.working();
-    if (d.type === "del") {
-      const line = restoreLine(nextWorkBlock(this.display(), dispIdx), working.split("\n").length);
-      // restoreBlock returns undefined when the block structure round-trips
-      // to the submitted revision - the working copy is gone
-      const restored = restoreBlock(session.artifact.content, working, d.base!, line);
-      this.setWorkingCopy(restored);
-      this.setStatus("cut restored");
-    } else if (d.work) {
-      this.setWorkingCopy(cutBlock(working, d.work));
-      this.setStatus("block cut - it serializes into the diff");
-    }
-  }
-
-  edit(): void {
-    const session = this.snap.session;
-    if (!session || session.status === "resolved") return;
-    try {
-      const result = editInEditor(this.working(), "plan.md");
-      if (result.changed) {
-        this.setWorkingCopy(result.content);
-        this.reconcileAnnotations(session, result.content);
-        this.setStatus("edits tracked - one diff");
-      } else this.setStatus("no changes");
-    } catch (err) {
-      this.setStatus(err instanceof Error ? err.message : String(err));
-    }
-  }
-
-  /**
-   * Edit-exit reconciliation: re-resolve every annotation against the edited
-   * working copy with the quote-primary cascade. Annotations that stop
-   * resolving stay stored (the feedback serializer flags orphaned anchors);
-   * the count feeds the one-line banner above the sheet.
-   */
-  private reconcileAnnotations(session: ReviewSession, editedContent: string): void {
-    const editedBlocks = parseBlocks(editedContent);
-    const orphanCount = session.annotations.filter(
-      (annotation) => resolveAnchor(annotation.anchor, editedBlocks) === null,
-    ).length;
-    this.update({ editOrphanCount: orphanCount });
-  }
-
-  annotate(
-    kind: "comment" | "suggestion",
-    dispIdx: number,
-    start: number,
-    end: number,
-    body: string,
-  ): string | undefined {
-    const session = this.snap.session;
-    if (!session) return undefined;
-    let anchor;
-    if (session.artifact.type === "diff") {
-      anchor = { ...diffRowAnchor(this.rows(), dispIdx), blockIndex: dispIdx };
-    } else {
-      const display = this.display();
-      const workBlocks = display.filter((d) => d.work).map((d) => d.work!);
-      const workIdx = display.slice(0, dispIdx + 1).filter((d) => d.work).length - 1;
-      anchor = makeAnchor(workBlocks, workIdx, start, end);
-    }
-    const annotationId = newAnnotationId();
-    this.apply(
-      this.client!.sessionAnnotate(session.id, {
-        id: annotationId,
-        kind,
-        anchor,
-        body,
-      }),
-    );
-    this.setStatus(kind === "suggestion" ? "suggestion added - the agent applies it" : "comment added");
-    return annotationId;
-  }
-
-  updateAnnotation(id: string, body: string): void {
-    const session = this.snap.session;
-    if (!session) return;
-    const existing = session.annotations.find((annotation) => annotation.id === id);
-    if (!existing) return;
-    // the daemon's annotate verb upserts by id: same id + anchor, new body
-    this.apply(
-      this.client!.sessionAnnotate(session.id, {
-        id: existing.id,
-        kind: existing.kind,
-        anchor: existing.anchor,
-        body,
-      }),
-    );
-    this.setStatus("annotation updated");
-  }
-
-  removeAnnotation(id: string): void {
-    const session = this.snap.session;
-    if (!session) return;
-    this.apply(this.client!.sessionRemoveAnnotation(session.id, id));
-    this.setStatus("annotation deleted");
-  }
-
-  setWorkingCopy(content: string | undefined): void {
-    const session = this.snap.session;
-    if (!session) return;
-    this.apply(this.client!.sessionSetWorkingCopy(session.id, content));
-  }
-
-  submit(verdict: VerdictKind, summary: string): void {
-    const session = this.snap.session;
-    if (!session) return;
-    this.client!.sessionResolve(session.id, verdict, summary)
-      .then((resolved) => {
-        this.update({ session: resolved, status: `review submitted - ${verdict.replace("_", " ")}` });
-        // notes-vault export: guarded by config, default is manual (no-op)
-        const obsidian = this.obsidian;
-        const exporter = this.exporters.get("obsidian");
-        if (obsidian && exporter && shouldExport(obsidian.exportOn, verdict)) {
-          void exporter(resolved).then((r) => {
-            this.setStatus(r.success && r.path ? `exported to ${r.path}` : `export failed: ${r.error ?? "unknown"}`);
-          });
-        }
-        // hand the reviewer back to the agent: prompt or count down per config;
-        // inside herdr with a known return pane, closing is the default
-        const delay = this.autoClose;
-        const returns = returnPaneFor(resolved.artifact.meta.herdrPane) !== undefined;
-        if (delay === 0) this.finishReview();
-        else if (typeof delay === "number") this.startCounting(delay);
-        else if (returns) this.startCounting(3);
-        else this.update({ completion: { phase: "prompt" } });
-      })
-      .catch((e: unknown) => this.setStatus(String(e instanceof Error ? e.message : e)));
-  }
-
-  // ── completion hand-back ────────────────────
-  private startCounting(remaining: number): void {
-    if (remaining <= 0) return this.finishReview();
-    this.update({ completion: { phase: "counting", remaining } });
-    this.countdown = setTimeout(() => this.startCounting(remaining - 1), 1000);
-  }
-
-  finishReview(): void {
-    clearTimeout(this.countdown);
-    const pane = returnPaneFor(this.snap.session?.artifact.meta.herdrPane);
-    if (pane) focusHerdrPane(pane);
-    this.opts.onExit?.(0);
-  }
-
-  dismissCompletion(): void {
-    clearTimeout(this.countdown);
-    this.update({ completion: { phase: "dismissed" } });
-  }
-
-  optInAutoClose(): void {
-    // opt in: close in 3s from now on, persisted to the user config
-    try {
-      persistAutoClose(3);
-    } catch {
-      // a read-only config dir must not block closing the review
-    }
-    this.autoClose = 3;
-    this.startCounting(3);
-  }
-}

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);
-  });
-});