@cueloop/client 0.1.0-alpha.4 → 0.1.0-alpha.41

package/src/share.ts

@@ -0,0 +1,113 @@
+/**
+ * Publish a review session as a share: pack it, stream it to the gateway's
+ * `share` user over SSH, and copy the returned `ssh p_…@host` line to the
+ * clipboard. The planner holds no key, so all this side does is upload; the
+ * gateway seals and stores. Used by both `cueloop share` and the in-TUI
+ * Share button, so the two share exactly the same path.
+ */
+
+import {
+  DEFAULT_SHARE_HOST,
+  DEFAULT_SHARE_PORT,
+  SHARE_UPLOAD_USER,
+  packSessionBlob,
+} from "@cueloop/daemon/share-blob";
+import type { Annotation, ReviewSession } from "@cueloop/schema";
+import { copyToClipboard } from "./clipboard";
+
+export interface ShareTarget {
+  host?: string;
+  port?: number;
+}
+
+export interface ShareResult {
+  /** The one line to paste: `ssh p_xxxxxxxx@host`. */
+  line: string;
+  /** Whether the line made it onto the system clipboard. */
+  copied: boolean;
+}
+
+/** The `p_…` share id inside a `ssh p_…@host` line, or undefined. */
+export function shareIdFromLine(line: string): string | undefined {
+  return line.match(/^ssh (\S+)@/)?.[1];
+}
+
+/** Upload the session to the gateway and copy the resulting ssh line. */
+export async function publishShare(
+  session: ReviewSession,
+  target: ShareTarget = {},
+): Promise<ShareResult> {
+  const { stdout, stderr, code } = await runShareSsh(
+    "cueloop-share",
+    packSessionBlob(session),
+    target,
+  );
+  if (code !== 0)
+    throw new Error(`gateway upload failed: ${stderr.trim() || `ssh exited ${code}`}`);
+  const line = stdout.trim();
+  if (!line.startsWith("ssh ")) throw new Error(`unexpected gateway reply: ${line || "(empty)"}`);
+  const copied = await copyToClipboard(line);
+  return { line, copied };
+}
+
+/**
+ * Pull a share's current session back from the gateway. The gateway lets only
+ * the fingerprint that uploaded it through, so collaborator notes reach the
+ * planner without exposing the master key.
+ */
+export async function pullShare(shareId: string, target: ShareTarget = {}): Promise<ReviewSession> {
+  const { stdout, stderr, code } = await runShareSsh("cueloop-pull", Buffer.from(shareId), target);
+  if (code !== 0) throw new Error(`gateway pull failed: ${stderr.trim() || `ssh exited ${code}`}`);
+  return JSON.parse(stdout) as ReviewSession;
+}
+
+/** A share's collaborator notes: the ones a viewer authored (author stamped). */
+export function collaboratorAnnotations(session: ReviewSession): Annotation[] {
+  return session.annotations.filter((annotation) => annotation.author);
+}
+
+/**
+ * Mirror the planner's own annotations up into the share, so collaborators see
+ * them on their next refresh. Owner-gated at the gateway; the notes stay
+ * unauthored (the planner's), unioned by id.
+ */
+export async function pushShare(
+  shareId: string,
+  annotations: Array<Omit<Annotation, "createdAt">>,
+  target: ShareTarget = {},
+): Promise<void> {
+  const { stderr, code } = await runShareSsh(
+    "cueloop-push",
+    Buffer.from(JSON.stringify({ shareId, annotations })),
+    target,
+  );
+  if (code !== 0) throw new Error(`gateway push failed: ${stderr.trim() || `ssh exited ${code}`}`);
+}
+
+/** Run one `share@host:port` ssh command with `stdin`; hand back its streams and exit code. */
+async function runShareSsh(
+  command: string,
+  stdin: Buffer,
+  target: ShareTarget,
+): Promise<{ stdout: string; stderr: string; code: number }> {
+  const host = target.host ?? DEFAULT_SHARE_HOST;
+  const port = target.port ?? DEFAULT_SHARE_PORT;
+  const proc = Bun.spawn(
+    [
+      "ssh",
+      "-p",
+      String(port),
+      "-o",
+      "StrictHostKeyChecking=accept-new",
+      `${SHARE_UPLOAD_USER}@${host}`,
+      command,
+    ],
+    { stdin, stdout: "pipe", stderr: "pipe" },
+  );
+  const [stdout, stderr, code] = await Promise.all([
+    new Response(proc.stdout).text(),
+    new Response(proc.stderr).text(),
+    proc.exited,
+  ]);
+  return { stdout, stderr, code };
+}

package/src/test-support.test.ts

@@ -0,0 +1,55 @@
+import { describe, expect, test } from "bun:test";
+import { mkdtempSync, rmSync, writeFileSync } from "node:fs";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+import { loadConfig } from "./config";
+import { isolateUserConfig } from "./test-support";
+
+describe("isolateUserConfig", () => {
+  test("loadConfig sees defaults while isolated and the env is restored after", () => {
+    // Arrange
+    const home = mkdtempSync(join(tmpdir(), "cueloop-isolate-"));
+    const userConfigPath = join(home, "config.toml");
+    writeFileSync(userConfigPath, '[ui]\nreview_state = "compact"\n');
+    const priorEnv = process.env.CUELOOP_CONFIG;
+    process.env.CUELOOP_CONFIG = userConfigPath;
+
+    try {
+      // Act
+      const restoreUserConfig = isolateUserConfig(home);
+      const isolated = loadConfig({ repoRoot: home });
+      restoreUserConfig();
+      const restored = loadConfig({ repoRoot: home });
+
+      // Assert
+      expect(isolated.ui.reviewState).toBe("expanded");
+      expect(process.env.CUELOOP_CONFIG).toBe(userConfigPath);
+      expect(restored.ui.reviewState).toBe("compact");
+    } finally {
+      if (priorEnv === undefined) delete process.env.CUELOOP_CONFIG;
+      else process.env.CUELOOP_CONFIG = priorEnv;
+      rmSync(home, { recursive: true, force: true });
+    }
+  });
+
+  test("restore removes the variable when nothing was set before", () => {
+    // Arrange
+    const home = mkdtempSync(join(tmpdir(), "cueloop-isolate-"));
+    const priorEnv = process.env.CUELOOP_CONFIG;
+    delete process.env.CUELOOP_CONFIG;
+
+    try {
+      // Act
+      const restoreUserConfig = isolateUserConfig(home);
+      const pointedAt = process.env.CUELOOP_CONFIG ?? "";
+      restoreUserConfig();
+
+      // Assert
+      expect(pointedAt).toBe(join(home, "no-config.toml"));
+      expect(process.env.CUELOOP_CONFIG).toBeUndefined();
+    } finally {
+      if (priorEnv !== undefined) process.env.CUELOOP_CONFIG = priorEnv;
+      rmSync(home, { recursive: true, force: true });
+    }
+  });
+});

package/src/test-support.ts

@@ -0,0 +1,187 @@
+/**
+ * Shared driving helpers for the virtual-terminal App suites: key presses
+ * settle through a macrotask yield (input parser + React scheduler), one
+ * render pass, and the renderer's visual-idle wait - no fixed-duration
+ * sleeps. Waits on daemon round-trips go through waitForFrame/waitFor with
+ * generous pass budgets.
+ */
+
+import { join } from "node:path";
+import type { TestRendererSetup } from "@opentui/core/testing";
+
+/** Pass budget for waits that include daemon or subprocess round-trips. */
+export const WAIT_PASSES = { maxPasses: 400 };
+
+/**
+ * Isolate the user config: point CUELOOP_CONFIG into the test home so
+ * loadConfig never reads the developer's real ~/.config/cueloop (a persisted
+ * review_state would change what char frames render locally while CI stays
+ * clean). The default file name does not exist, so loadConfig returns
+ * defaults; pass a file name for suites that write and assert a config of
+ * their own. Call in beforeEach; invoke the returned restore in afterEach.
+ */
+export function isolateUserConfig(home: string, fileName = "no-config.toml"): () => void {
+  const priorUserConfig = process.env.CUELOOP_CONFIG;
+  process.env.CUELOOP_CONFIG = join(home, fileName);
+  return () => {
+    if (priorUserConfig === undefined) delete process.env.CUELOOP_CONFIG;
+    else process.env.CUELOOP_CONFIG = priorUserConfig;
+  };
+}
+
+/** The harness drives the real event loop by design; keep React's act warning off. */
+export function allowEventLoopUpdates(): void {
+  (globalThis as { IS_REACT_ACT_ENVIRONMENT?: boolean }).IS_REACT_ACT_ENVIRONMENT = false;
+}
+
+/**
+ * One macrotask yield lets the input parser and the React scheduler run,
+ * then a render pass commits the result before the visual-idle wait.
+ */
+export async function settle(setup: TestRendererSetup): Promise<void> {
+  allowEventLoopUpdates();
+  await new Promise((resolve) => setTimeout(resolve, 0));
+  await setup.renderOnce();
+  await setup.waitForVisualIdle();
+}
+
+/** Drive one key press: letters type as text; named keys use KeyCodes ids. */
+export async function press(setup: TestRendererSetup, key: string): Promise<void> {
+  if (key === "enter") setup.mockInput.pressKey("RETURN");
+  else if (key === "escape") setup.mockInput.pressKey("ESCAPE");
+  else if (key === "backspace") setup.mockInput.pressKey("BACKSPACE");
+  else if (key === "left") setup.mockInput.pressKey("ARROW_LEFT");
+  else if (key === "right") setup.mockInput.pressKey("ARROW_RIGHT");
+  else return typeText(setup, key);
+  await settle(setup);
+}
+
+export async function typeText(setup: TestRendererSetup, text: string): Promise<void> {
+  await setup.mockInput.typeText(text);
+  await settle(setup);
+}
+
+// Below the 60s per-test budget so a genuinely stuck wait throws its frame
+// error (useful) before bun's bare "timed out" fires. Generous because a
+// contended CI runner starves the render loop and daemon round-trips.
+const WAIT_DEADLINE_MS = 45_000;
+
+/** One macrotask turn: hands the event loop back so the in-process daemon can
+ *  read its socket and apply the write before the next poll. Tight render-pass
+ *  bursts starve that read on a contended CI runner - the round-trip then never
+ *  lands and the wait hangs the whole budget. */
+function yieldEventLoop(): Promise<void> {
+  return new Promise((resolve) => setTimeout(resolve, 2));
+}
+
+/** Log a still-waiting line at most this often, so only genuinely slow (i.e.
+ *  flaking) waits are noisy; fast waits stay silent. */
+const PROGRESS_LOG_MS = 4000;
+
+/** The last render frame's tail, so a progress line shows what is on screen. */
+function frameTail(frame: string, rows = 6): string {
+  return frame.split("\n").slice(-rows).join("\n");
+}
+
+/**
+ * Poll gently: one render pass, one frame check, one macrotask yield. No
+ * multi-pass bursts, so the daemon (same event loop) always gets a turn to
+ * process IO between checks. The deadline bounds the whole wait. Slow waits log
+ * progress (poll count + frame-change count) so a CI stall shows whether the
+ * render froze or the content simply never arrived.
+ */
+async function waitForFramePredicate(
+  setup: TestRendererSetup,
+  predicate: (frame: string) => boolean,
+  label: string,
+): Promise<string> {
+  allowEventLoopUpdates();
+  const start = Date.now();
+  const deadline = start + WAIT_DEADLINE_MS;
+  let polls = 0;
+  let frameChanges = 0;
+  let lastFrame = "";
+  let lastLog = start;
+  for (;;) {
+    await setup.renderOnce();
+    const frame = setup.captureCharFrame();
+    polls++;
+    if (frame !== lastFrame) {
+      frameChanges++;
+      lastFrame = frame;
+    }
+    if (predicate(frame)) return frame;
+    const now = Date.now();
+    if (now > deadline) {
+      const frozen = frameChanges <= 1 ? " - render never advanced (frozen)" : "";
+      throw new Error(
+        `waitFor ${label} timed out after ${now - start}ms (${polls} polls, ${frameChanges} frame changes${frozen}).\nlast frame:\n${frame}`,
+      );
+    }
+    if (now - lastLog >= PROGRESS_LOG_MS) {
+      lastLog = now;
+      console.error(
+        `[waitFor] still waiting for ${label} - ${now - start}ms, ${polls} polls, ${frameChanges} frame changes\n${frameTail(frame)}`,
+      );
+    }
+    await yieldEventLoop();
+  }
+}
+
+/** Wait until a state predicate holds (daemon round-trips included). */
+export async function waitForState(
+  setup: TestRendererSetup,
+  predicate: () => boolean,
+  label = "state",
+): Promise<void> {
+  allowEventLoopUpdates();
+  const start = Date.now();
+  const deadline = start + WAIT_DEADLINE_MS;
+  let polls = 0;
+  let frameChanges = 0;
+  let lastFrame = "";
+  let lastLog = start;
+  for (;;) {
+    if (predicate()) return;
+    await setup.renderOnce();
+    const frame = setup.captureCharFrame();
+    polls++;
+    if (frame !== lastFrame) {
+      frameChanges++;
+      lastFrame = frame;
+    }
+    if (predicate()) return;
+    const now = Date.now();
+    if (now > deadline) {
+      const frozen = frameChanges <= 1 ? " - render never advanced (frozen)" : "";
+      throw new Error(
+        `waitForState ${label} timed out after ${now - start}ms (${polls} polls, ${frameChanges} frame changes${frozen}).\nlast frame:\n${frame}`,
+      );
+    }
+    if (now - lastLog >= PROGRESS_LOG_MS) {
+      lastLog = now;
+      console.error(
+        `[waitForState] still waiting for ${label} - ${now - start}ms, ${polls} polls, ${frameChanges} frame changes`,
+      );
+    }
+    await yieldEventLoop();
+  }
+}
+
+/** Wait until the frame contains the needle (daemon round-trips included). */
+export async function waitForText(setup: TestRendererSetup, needle: string): Promise<string> {
+  return waitForFramePredicate(
+    setup,
+    (frame) => frame.includes(needle),
+    `text ${JSON.stringify(needle)}`,
+  );
+}
+
+/** Wait until the frame no longer contains the needle. */
+export async function waitForTextGone(setup: TestRendererSetup, needle: string): Promise<string> {
+  return waitForFramePredicate(
+    setup,
+    (frame) => !frame.includes(needle),
+    `text-gone ${JSON.stringify(needle)}`,
+  );
+}

package/src/theme-presets.ts

@@ -0,0 +1,168 @@
+/**
+ * Named theme presets selectable from Settings and `[ui] theme`. The branded
+ * "cueloop" default keeps the transparent terminal-through look; each of the
+ * well-known palettes paints its own opaque background so it reads exactly like
+ * the published theme. Every preset fills the full Theme token contract, so a
+ * `[theme]` per-token override still layers cleanly on top of the chosen base.
+ *
+ * Each palette maps its first-party spec onto cueloop's semantic slots. Where a
+ * palette has no dedicated green (Rosé Pine), additions use its positive accent
+ * by that palette's own convention.
+ */
+
+import { DARK, type Theme } from "./theme";
+
+/** Selectable theme name; the persisted `[ui] theme` value and cycle key. */
+export type ThemeName =
+  | "cueloop"
+  | "rose-pine-moon"
+  | "catppuccin-mocha"
+  | "tokyo-night"
+  | "gruvbox-dark"
+  | "nord";
+
+/** The branded default; the base every layered config starts from. */
+export const DEFAULT_THEME_NAME: ThemeName = "cueloop";
+
+/** Rosé Pine Moon - rosepinetheme.com. Foam stands in for additions (no green in the palette). */
+const ROSE_PINE_MOON: Theme = {
+  background: "#232136",
+  panel: "#232136",
+  elevated: "#2a273f",
+  border: "#44415a",
+  text: "#e0def4",
+  textMuted: "#908caa",
+  textDim: "#6e6a86",
+  accent: "#ea9a97",
+  accentInk: "#232136",
+  green: "#9ccfd8",
+  red: "#eb6f92",
+  blue: "#3e8fb0",
+  cursorBackground: "#382a2f",
+  markCommentBackground: "#382a37",
+  insertedForeground: "#9ccfd8",
+  deletedForeground: "#eb6f92",
+  backdrop: "transparent",
+};
+
+/** Catppuccin Mocha - catppuccin.com. Mauve is the signature accent. */
+const CATPPUCCIN_MOCHA: Theme = {
+  background: "#1e1e2e",
+  panel: "#1e1e2e",
+  elevated: "#313244",
+  border: "#45475a",
+  text: "#cdd6f4",
+  textMuted: "#a6adc8",
+  textDim: "#6c7086",
+  accent: "#cba6f7",
+  accentInk: "#1e1e2e",
+  green: "#a6e3a1",
+  red: "#f38ba8",
+  blue: "#89b4fa",
+  cursorBackground: "#2e2740",
+  markCommentBackground: "#33222b",
+  insertedForeground: "#a6e3a1",
+  deletedForeground: "#f38ba8",
+  backdrop: "transparent",
+};
+
+/** Tokyo Night - the folke "night" variant. Magenta is the signature accent. */
+const TOKYO_NIGHT: Theme = {
+  background: "#1a1b26",
+  panel: "#1a1b26",
+  elevated: "#292e42",
+  border: "#3b4261",
+  text: "#c0caf5",
+  textMuted: "#a9b1d6",
+  textDim: "#565f89",
+  accent: "#bb9af7",
+  accentInk: "#1a1b26",
+  green: "#9ece6a",
+  red: "#f7768e",
+  blue: "#7aa2f7",
+  cursorBackground: "#2b2740",
+  markCommentBackground: "#2f2230",
+  insertedForeground: "#9ece6a",
+  deletedForeground: "#f7768e",
+  backdrop: "transparent",
+};
+
+/** Gruvbox Dark - morhetz/gruvbox, medium contrast. Orange is the warm signature accent. */
+const GRUVBOX_DARK: Theme = {
+  background: "#282828",
+  panel: "#282828",
+  elevated: "#3c3836",
+  border: "#504945",
+  text: "#ebdbb2",
+  textMuted: "#d5c4a1",
+  textDim: "#928374",
+  accent: "#fe8019",
+  accentInk: "#282828",
+  green: "#b8bb26",
+  red: "#fb4934",
+  blue: "#83a598",
+  cursorBackground: "#3a2f20",
+  markCommentBackground: "#3a2823",
+  insertedForeground: "#b8bb26",
+  deletedForeground: "#fb4934",
+  backdrop: "transparent",
+};
+
+/** Nord - nordtheme.com, the official 16-color spec. Frost cyan is the signature accent. */
+const NORD: Theme = {
+  background: "#2e3440",
+  panel: "#2e3440",
+  elevated: "#3b4252",
+  border: "#434c5e",
+  text: "#eceff4",
+  textMuted: "#d8dee9",
+  textDim: "#4c566a",
+  accent: "#88c0d0",
+  accentInk: "#2e3440",
+  green: "#a3be8c",
+  red: "#bf616a",
+  blue: "#81a1c1",
+  cursorBackground: "#2a3540",
+  markCommentBackground: "#3a2f33",
+  insertedForeground: "#a3be8c",
+  deletedForeground: "#bf616a",
+  backdrop: "transparent",
+};
+
+/** All selectable themes by name; "cueloop" is the branded transparent default. */
+export const THEME_PRESETS: Record<ThemeName, Theme> = {
+  cueloop: DARK,
+  "rose-pine-moon": ROSE_PINE_MOON,
+  "catppuccin-mocha": CATPPUCCIN_MOCHA,
+  "tokyo-night": TOKYO_NIGHT,
+  "gruvbox-dark": GRUVBOX_DARK,
+  nord: NORD,
+};
+
+/** Cycle order for the Settings theme row; the registry's insertion order, branded default first. */
+export const THEME_NAMES: ThemeName[] = Object.keys(THEME_PRESETS) as ThemeName[];
+
+/** Human labels for the Settings cycle row, keyed by the persisted name. */
+export const THEME_LABELS: Record<ThemeName, string> = {
+  cueloop: "cueloop",
+  "rose-pine-moon": "Rosé Pine Moon",
+  "catppuccin-mocha": "Catppuccin Mocha",
+  "tokyo-night": "Tokyo Night",
+  "gruvbox-dark": "Gruvbox Dark",
+  nord: "Nord",
+};
+
+/** Resolve a persisted theme name to its token set; unknown names fall back to the branded default. */
+export function themeForName(name: string): Theme {
+  return THEME_PRESETS[name as ThemeName] ?? DARK;
+}
+
+/** A preset with the user's `[theme]` per-token overrides layered on top - the live-switch equivalent of config load. */
+export function composeTheme(name: string, overrides: Partial<Theme>): Theme {
+  return { ...themeForName(name), ...overrides };
+}
+
+/** True when the name is a known preset (guards a persisted `[ui] theme` value). */
+export function isThemeName(name: string): name is ThemeName {
+  return name in THEME_PRESETS;
+}

package/src/theme.ts

@@ -1,12 +1,12 @@
 /**
- * Semantic theme tokens (#22). Values carry over from the design-system
+ * Semantic theme tokens. Values carry over from the design-system
  * prototypes (tokens.css). One built-in dark theme for now; the theme
  * registry (palette-derived themes, terminal theme, user overrides) layers
  * on top of these slots without touching consumers.
  */
 
 export interface Theme {
-  bg: string;
+  background: string;
   panel: string;
   elevated: string;
   border: string;
@@ -18,16 +18,37 @@ export interface Theme {
   green: string;
   red: string;
   blue: string;
-  cursorBg: string;
-  markCommentBg: string;
-  markSuggestionBg: string;
-  insFg: string;
-  delFg: string;
+  cursorBackground: string;
+  markCommentBackground: string;
+  insertedForeground: string;
+  deletedForeground: string;
+  /** Layer behind centered dialogs; transparent keeps the session visible. */
+  backdrop: string;
+}
+
+/**
+ * The dimmed variant behind the walk wizard: every reading color drops to
+ * the dim token so the file list stays legible context, not competition.
+ * Layout tokens (backgrounds, cursor) keep their values.
+ */
+export function dimmedTheme(theme: Theme): Theme {
+  return {
+    ...theme,
+    text: theme.textDim,
+    textMuted: theme.textDim,
+    accent: theme.textDim,
+    green: theme.textDim,
+    red: theme.textDim,
+    blue: theme.textDim,
+    insertedForeground: theme.textDim,
+    deletedForeground: theme.textDim,
+  };
 }
 
 export const DARK: Theme = {
-  bg: "#1f1f29",
-  panel: "#1a1a23",
+  /* Unpainted so the terminal background shows through; override in [theme]. */
+  background: "transparent",
+  panel: "transparent",
   elevated: "#23232f",
   border: "#3a3a4a",
   text: "#e4e6ec",
@@ -38,9 +59,9 @@ export const DARK: Theme = {
   green: "#62d96b",
   red: "#ff6b6b",
   blue: "#84a6e8",
-  cursorBg: "#33262a",
-  markCommentBg: "#3d2a2e",
-  markSuggestionBg: "#20351f",
-  insFg: "#62d96b",
-  delFg: "#ff6b6b",
-}
+  cursorBackground: "#33262a",
+  markCommentBackground: "#3d2a2e",
+  insertedForeground: "#62d96b",
+  deletedForeground: "#ff6b6b",
+  backdrop: "transparent",
+};

package/src/version.ts

@@ -0,0 +1,5 @@
+/** The published client version, read from the package manifest. */
+
+import manifest from "../package.json" with { type: "json" };
+
+export const CLIENT_VERSION: string = manifest.version;

package/src/view-diff.test.ts

@@ -21,23 +21,29 @@ index 111..222 100644
 
 describe("diffRows", () => {
   test("flattens files, hunks, and signed lines with line numbers", () => {
+    // Act
     const rows = diffRows(PATCH);
-    expect(rows[0]).toMatchObject({ t: "file", file: "src/store.ts" });
-    expect(rows[1]!.t).toBe("hunk");
-    const del = rows.find((r) => r.t === "del")!;
+
+    // Assert
+    expect(rows[0]).toMatchObject({ kind: "file", file: "src/store.ts" });
+    expect(rows[1]!.kind).toBe("hunk");
+    const del = rows.find((row) => row.kind === "del")!;
     expect(del.text).toContain("private items = [];");
     expect(del.oldLine).toBe(3);
-    const adds = rows.filter((r) => r.t === "add");
+    const adds = rows.filter((row) => row.kind === "add");
     expect(adds[0]!.text).toContain("new Map()");
     expect(adds[0]!.newLine).toBe(3);
     expect(adds[1]!.newLine).toBe(4);
     // two hunks
-    expect(rows.filter((r) => r.t === "hunk").length).toBe(2);
+    expect(rows.filter((row) => row.kind === "hunk").length).toBe(2);
   });
 
   test("context lines carry both line numbers", () => {
+    // Act
     const rows = diffRows(PATCH);
-    const ctx = rows.find((r) => r.t === "ctx")!;
+
+    // Assert
+    const ctx = rows.find((row) => row.kind === "ctx")!;
     expect(ctx.oldLine).toBe(1);
     expect(ctx.newLine).toBe(1);
   });
@@ -45,9 +51,14 @@ describe("diffRows", () => {
 
 describe("diffRowAnchor", () => {
   test("quote is the line, neighbors are the context selectors", () => {
+    // Arrange
     const rows = diffRows(PATCH);
-    const idx = rows.findIndex((r) => r.text.includes("new Map()"));
-    const anchor = diffRowAnchor(rows, idx);
+    const rowIndex = rows.findIndex((row) => row.text.includes("new Map()"));
+
+    // Act
+    const anchor = diffRowAnchor(rows, rowIndex);
+
+    // Assert
     expect(anchor.quote).toContain("new Map()");
     expect(anchor.prefix.length).toBeGreaterThan(0);
     expect(anchor.suffix.length).toBeGreaterThan(0);