@cueloop/client 0.1.0-alpha.76 → 0.1.0-alpha.78

package/src/components/session-tree.ts

@@ -33,7 +33,7 @@ export function projectName(workspace: WorkspaceKey): string {
 export type InboxRow =
   | { kind: "section"; id: string; label: string }
   | { kind: "project"; id: string; label: string }
-  | { kind: "thread"; id: string; session: Thread; selectionIndex: number };
+  | { kind: "thread"; id: string; session: Thread; selectionIndex: number; depth: number };
 
 export interface GroupedInbox {
   rows: InboxRow[];
@@ -78,14 +78,14 @@ export function groupInbox(
 
   const rows: InboxRow[] = [];
   const ordered: Thread[] = [];
-  const pushThread = (session: Thread): void => {
-    rows.push({ kind: "thread", id: session.id, session, selectionIndex: ordered.length });
+  const pushThread = (session: Thread, depth: number): void => {
+    rows.push({ kind: "thread", id: session.id, session, selectionIndex: ordered.length, depth });
     ordered.push(session);
   };
 
   if (pinned.length > 0) {
     rows.push({ kind: "section", id: "section:pinned", label: "Starred" });
-    for (const session of pinned) pushThread(session);
+    for (const session of pinned) pushThread(session, 1);
   }
 
   const projectEntries = [...projects.entries()].sort((a, b) => a[1].name.localeCompare(b[1].name));
@@ -93,13 +93,14 @@ export function groupInbox(
     rows.push({ kind: "section", id: "section:projects", label: "Projects" });
     for (const [key, project] of projectEntries) {
       rows.push({ kind: "project", id: `project:${key}`, label: project.name });
-      for (const session of project.sessions) pushThread(session);
+      // a project's threads cascade one level under its name
+      for (const session of project.sessions) pushThread(session, 2);
     }
   }
 
   if (standalone.length > 0) {
     rows.push({ kind: "section", id: "section:threads", label: "Threads" });
-    for (const session of standalone) pushThread(session);
+    for (const session of standalone) pushThread(session, 1);
   }
 
   return { rows, ordered };

package/src/components/stories-app.tsx

@@ -13,9 +13,10 @@ import { ThemeProvider } from "./theme-context";
 import { buildStoryTree, loadStories, type LoadedStory } from "./story";
 import { PaneGrid } from "./PaneGrid";
 import { ShellHeader } from "./ShellHeader";
+import { AnsiScreen } from "./AnsiScreen";
 import { Tree } from "./primitives/Tree";
 import { NERD } from "./primitives/icons";
-import { allFolderIds, flattenTree } from "./primitives/tree-model";
+import { flattenTree } from "./primitives/tree-model";
 
 interface StoriesAppProps {
   stories: LoadedStory[];
@@ -30,8 +31,8 @@ function StoriesApp({ stories, onExit }: StoriesAppProps): React.ReactNode {
   );
   const firstStoryId = `${stories[0]!.moduleTitle}/${stories[0]!.storyName}`;
 
-  const [expandedIds, setExpandedIds] = useState<ReadonlySet<string>>(() =>
-    allFolderIds(treeNodes),
+  const [expandedIds, setExpandedIds] = useState<ReadonlySet<string>>(
+    () => new Set(treeNodes.filter((node) => node.children !== undefined).map((node) => node.id)),
   );
   const [selectedId, setSelectedId] = useState(firstStoryId);
   const [openedId, setOpenedId] = useState(firstStoryId);
@@ -126,7 +127,15 @@ function StoriesApp({ stories, onExit }: StoriesAppProps): React.ReactNode {
             <scrollbox style={{ flexGrow: 1, paddingLeft: 1, paddingTop: 1 }} focused={false}>
               {/* remount per story so component-local state never leaks across */}
               <box key={openedId} style={{ flexDirection: "column" }}>
-                {opened.story.render()}
+                {opened.story.ansi ? (
+                  <AnsiScreen
+                    ansi={opened.story.ansi()}
+                    cols={opened.story.size?.width ?? 80}
+                    rows={opened.story.size?.height ?? 24}
+                  />
+                ) : (
+                  opened.story.render?.()
+                )}
               </box>
             </scrollbox>
           ) : (

package/src/components/stories.test.tsx

@@ -5,10 +5,12 @@
  * stories file fails the harness, so the safety net cannot silently thin.
  */
 
+import React from "react";
 import { describe, expect, test } from "bun:test";
 import { testRender } from "@opentui/react/test-utils";
 import { RGBA } from "@opentui/core";
 import { componentFilesMissingStories, loadStories } from "./story";
+import { AnsiScreen } from "./AnsiScreen";
 import { allowEventLoopUpdates } from "../test-support";
 
 const stories = await loadStories();
@@ -34,9 +36,14 @@ describe("stories catalog", () => {
     test(`${moduleTitle}/${storyName} renders, snapshots, and carries its colors`, async () => {
       // Arrange
       const size = story.size ?? { width: 80, height: 24 };
+      const node = story.ansi ? (
+        <AnsiScreen ansi={story.ansi()} cols={size.width} rows={size.height} />
+      ) : (
+        story.render!()
+      );
 
       // Act
-      const setup = await testRender(story.render(), size);
+      const setup = await testRender(node, size);
 
       allowEventLoopUpdates();
       await setup.waitForVisualIdle();

package/src/components/story-tree.test.ts

@@ -1,12 +1,12 @@
 import { describe, expect, test } from "bun:test";
-import { buildStoryTree, type LoadedStory } from "./story";
+import { buildStoryTree, type LoadedStory, type StorySection } from "./story";
 import type { TreeNode } from "./primitives/tree-model";
 
 /** A story object whose render is never invoked in these structural tests. */
 const STUB = { render: () => null };
 
-function story(moduleTitle: string, storyName: string): LoadedStory {
-  return { moduleTitle, storyName, story: STUB };
+function story(moduleTitle: string, storyName: string, section: StorySection = "App"): LoadedStory {
+  return { section, moduleTitle, storyName, story: STUB };
 }
 
 function childLabels(node: TreeNode): string[] {
@@ -14,19 +14,31 @@ function childLabels(node: TreeNode): string[] {
 }
 
 describe("buildStoryTree", () => {
-  test("splits moduleTitle on / into nested folders keyed by their path", () => {
+  test("groups the top level by section", () => {
+    const tree = buildStoryTree([
+      story("Primitives/Tree", "Default"),
+      story("Collaborator Join", "JoinSplash", "SSH"),
+    ]);
+
+    expect(tree.map((node) => [node.id, node.label])).toEqual([
+      ["App", "App"],
+      ["SSH", "SSH"],
+    ]);
+  });
+
+  test("splits moduleTitle on / into nested folders under the section", () => {
     // Arrange
     const stories = [story("Primitives/Tree", "Default"), story("Layout/AppShell", "Default")];
 
     // Act
-    const tree = buildStoryTree(stories);
+    const app = buildStoryTree(stories)[0]!;
 
     // Assert
-    expect(tree.map((node) => [node.id, node.label])).toEqual([
-      ["Primitives", "Primitives"],
-      ["Layout", "Layout"],
+    expect(app.children!.map((node) => [node.id, node.label])).toEqual([
+      ["App/Primitives", "Primitives"],
+      ["App/Layout", "Layout"],
     ]);
-    expect(tree[0]!.children!.map((node) => node.id)).toEqual(["Primitives/Tree"]);
+    expect(app.children![0]!.children!.map((node) => node.id)).toEqual(["App/Primitives/Tree"]);
   });
 
   test("groups sibling components under one shared parent folder", () => {
@@ -34,11 +46,11 @@ describe("buildStoryTree", () => {
     const stories = [story("Primitives/Tree", "Default"), story("Primitives/Card", "Default")];
 
     // Act
-    const tree = buildStoryTree(stories);
+    const app = buildStoryTree(stories)[0]!;
 
     // Assert
-    expect(tree).toHaveLength(1);
-    expect(childLabels(tree[0]!)).toEqual(["Tree", "Card"]);
+    expect(app.children).toHaveLength(1);
+    expect(childLabels(app.children![0]!)).toEqual(["Tree", "Card"]);
   });
 
   test("nests to the full depth of the moduleTitle path", () => {
@@ -46,13 +58,12 @@ describe("buildStoryTree", () => {
     const stories = [story("A/B/C", "Only")];
 
     // Act
-    const tree = buildStoryTree(stories);
-    const a = tree[0]!;
+    const a = buildStoryTree(stories)[0]!.children![0]!;
     const b = a.children![0]!;
 
     // Assert
-    expect([a.id, b.id]).toEqual(["A", "A/B"]);
-    expect(b.children![0]!.id).toBe("A/B/C");
+    expect([a.id, b.id]).toEqual(["App/A", "App/A/B"]);
+    expect(b.children![0]!.id).toBe("App/A/B/C");
   });
 
   test("adds each story as a leaf keyed `${moduleTitle}/${storyName}` under its component", () => {
@@ -60,11 +71,10 @@ describe("buildStoryTree", () => {
     const stories = [story("Primitives/Tree", "Empty"), story("Primitives/Tree", "Deep")];
 
     // Act
-    const tree = buildStoryTree(stories);
-    const component = tree[0]!.children![0]!;
+    const component = buildStoryTree(stories)[0]!.children![0]!.children![0]!;
 
     // Assert
-    expect(component.id).toBe("Primitives/Tree");
+    expect(component.id).toBe("App/Primitives/Tree");
     expect(component.children!.map((leaf) => [leaf.id, leaf.label])).toEqual([
       ["Primitives/Tree/Empty", "Empty"],
       ["Primitives/Tree/Deep", "Deep"],
@@ -76,8 +86,7 @@ describe("buildStoryTree", () => {
     const stories = [story("Primitives/Card", "Card")];
 
     // Act
-    const tree = buildStoryTree(stories);
-    const hoisted = tree[0]!.children![0]!;
+    const hoisted = buildStoryTree(stories)[0]!.children![0]!.children![0]!;
 
     // Assert
     expect(hoisted.children).toBeUndefined();
@@ -90,11 +99,10 @@ describe("buildStoryTree", () => {
     const stories = [story("Primitives/Card", "Default")];
 
     // Act
-    const tree = buildStoryTree(stories);
-    const component = tree[0]!.children![0]!;
+    const component = buildStoryTree(stories)[0]!.children![0]!.children![0]!;
 
     // Assert
-    expect(component.id).toBe("Primitives/Card");
+    expect(component.id).toBe("App/Primitives/Card");
     expect(component.children!.map((leaf) => leaf.id)).toEqual(["Primitives/Card/Default"]);
   });
 });

package/src/components/story.ts

@@ -15,7 +15,9 @@ export interface StoryMeta {
 }
 
 export interface Story {
-  render: () => React.ReactNode;
+  render?: () => React.ReactNode;
+  /** Raw ANSI to paint through AnsiScreen instead of a React tree; exactly one of render or ansi is set. */
+  ansi?: () => string;
   /**
    * Colors (hex tokens) that must appear among the rendered frame's styled
    * spans - the color regression net for color-bearing stories.
@@ -25,18 +27,21 @@ export interface Story {
   size?: { width: number; height: number };
 }
 
+export type StorySection = "App" | "SSH";
+
 export interface LoadedStory {
+  section: StorySection;
   moduleTitle: string;
   storyName: string;
   story: Story;
 }
 
 export function isStory(value: unknown): value is Story {
+  if (typeof value !== "object" || value === null) return false;
+
   return (
-    typeof value === "object" &&
-    value !== null &&
-    "render" in value &&
-    typeof value.render === "function"
+    ("render" in value && typeof value.render === "function") ||
+    ("ansi" in value && typeof value.ansi === "function")
   );
 }
 
@@ -49,22 +54,34 @@ function isStoryMeta(value: unknown): value is StoryMeta {
   );
 }
 
-/** Import every *.stories.tsx next to the components and flatten the exports. */
-export async function loadStories(): Promise<LoadedStory[]> {
-  const glob = new Bun.Glob("**/*.stories.tsx");
-  const files = [...glob.scanSync({ cwd: import.meta.dir })].sort();
-  const loaded: LoadedStory[] = [];
+const GATEWAY_SRC_DIR = `${import.meta.dir}/../../../gateway/src`;
+
+async function collectStories(
+  dir: string,
+  pattern: string,
+  section: StorySection,
+  loaded: LoadedStory[],
+): Promise<void> {
+  const glob = new Bun.Glob(pattern);
+  const files = [...glob.scanSync({ cwd: dir })].sort();
 
   for (const file of files) {
-    const moduleExports = await import(`${import.meta.dir}/${file}`);
+    const moduleExports = await import(`${dir}/${file}`);
     const meta = moduleExports["meta"];
-    const moduleTitle = isStoryMeta(meta) ? meta.title : file.replace(/\.stories\.tsx$/, "");
+    const moduleTitle = isStoryMeta(meta) ? meta.title : file.replace(/\.stories\.tsx?$/, "");
 
     for (const [exportName, exported] of Object.entries(moduleExports)) {
       if (exportName === "meta" || !isStory(exported)) continue;
-      loaded.push({ moduleTitle, storyName: exportName, story: exported });
+      loaded.push({ section, moduleTitle, storyName: exportName, story: exported });
     }
   }
+}
+
+export async function loadStories(): Promise<LoadedStory[]> {
+  const loaded: LoadedStory[] = [];
+
+  await collectStories(import.meta.dir, "**/*.stories.tsx", "App", loaded);
+  await collectStories(GATEWAY_SRC_DIR, "**/*.stories.ts", "SSH", loaded);
 
   return loaded;
 }
@@ -102,11 +119,11 @@ export function buildStoryTree(stories: LoadedStory[]): TreeNode[] {
   const roots: TreeNode[] = [];
   const foldersByPath = new Map<string, StoryTreeFolder>();
 
-  for (const { moduleTitle, storyName } of stories) {
+  for (const { section, moduleTitle, storyName } of stories) {
     let siblings = roots;
     let path = "";
 
-    for (const segment of moduleTitle.split("/")) {
+    for (const segment of [section, ...moduleTitle.split("/")]) {
       path = path === "" ? segment : `${path}/${segment}`;
       let folder = foldersByPath.get(path);
       if (folder === undefined) {

package/src/config-identity.test.ts

@@ -0,0 +1,78 @@
+import { expect, test } from "bun:test";
+import { mkdirSync, mkdtempSync, rmSync, writeFileSync } from "node:fs";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+import { loadConfig, persistIdentity } from "./config";
+
+function withTempConfig(run: (path: string) => void): void {
+  const directory = mkdtempSync(join(tmpdir(), "cueloop-config-"));
+
+  try {
+    run(join(directory, "config.toml"));
+  } finally {
+    rmSync(directory, { recursive: true, force: true });
+  }
+}
+
+test("defaults identity to a typed provider with no name", () => {
+  withTempConfig((path) => {
+    expect(loadConfig({ userConfigPath: path }).identity).toEqual({ provider: "typed" });
+  });
+});
+
+test("persists and reloads a GitHub-synced identity", () => {
+  withTempConfig((path) => {
+    persistIdentity({ name: "Markus M", provider: "github" }, path);
+
+    expect(loadConfig({ userConfigPath: path }).identity).toEqual({
+      name: "Markus M",
+      provider: "github",
+    });
+  });
+});
+
+test("rewrites the identity block in place on a re-sync", () => {
+  withTempConfig((path) => {
+    persistIdentity({ name: "typed name", provider: "typed" }, path);
+    persistIdentity({ name: "markus", provider: "github" }, path);
+
+    expect(loadConfig({ userConfigPath: path }).identity).toEqual({
+      name: "markus",
+      provider: "github",
+    });
+  });
+});
+
+test("a display name containing a bracket survives a re-sync without corrupting the config", () => {
+  withTempConfig((path) => {
+    persistIdentity({ name: "Alice [Smith]", provider: "typed" }, path);
+    persistIdentity({ name: "Bob", provider: "github" }, path);
+
+    expect(loadConfig({ userConfigPath: path }).identity).toEqual({
+      name: "Bob",
+      provider: "github",
+    });
+  });
+});
+
+test("repository config cannot forge the reviewer identity", () => {
+  withTempConfig((userPath) => {
+    persistIdentity({ name: "Me", provider: "typed" }, userPath);
+    const repoRoot = mkdtempSync(join(tmpdir(), "cueloop-repo-"));
+
+    try {
+      mkdirSync(join(repoRoot, ".cueloop"), { recursive: true });
+      writeFileSync(
+        join(repoRoot, ".cueloop", "config.toml"),
+        '[identity]\nname = "Forged"\nprovider = "github"\n',
+      );
+
+      expect(loadConfig({ userConfigPath: userPath, repoRoot }).identity).toEqual({
+        name: "Me",
+        provider: "typed",
+      });
+    } finally {
+      rmSync(repoRoot, { recursive: true, force: true });
+    }
+  });
+});

package/src/config.ts

@@ -114,6 +114,8 @@ export interface CueloopConfig {
   };
   /** Planner-local author renames: identity id → display name ([authors] table). */
   authors: Record<string, string>;
+  /** The local reviewer's own display name, and whether it was typed or synced from GitHub ([identity] table). */
+  identity: IdentityConfig;
   /** Marker-popover quick actions ([[actions]] tables); the 5 defaults when unset. */
   actions: QuickAction[];
   /** Directory of user-level skills surfaced in the "/" palette ([skills] path); ~/.agents/skills default. */
@@ -128,6 +130,15 @@ export interface ExperimentalConfig {
   prototypePixels: boolean;
 }
 
+/** Where a display name came from: typed by the user, or verified from a GitHub login. */
+export type IdentityProvider = "typed" | "github";
+
+export interface IdentityConfig {
+  /** The reviewer's own display name; absent until they set or sync one. */
+  name?: string;
+  provider: IdentityProvider;
+}
+
 /** Every action in the grammar, with its default binding(s). */
 export const DEFAULT_KEYS: CueloopConfig["keys"] = {
   down: ["j", "down"],
@@ -166,6 +177,7 @@ function skillsPathFrom(
 const ConfigDocumentSchema = v.object({
   actions: v.optional(v.array(v.unknown())),
   authors: v.optional(v.unknown()),
+  identity: v.optional(v.unknown()),
   integrations: v.optional(v.unknown()),
   keys: v.optional(v.unknown()),
   theme: v.optional(v.unknown()),
@@ -174,6 +186,11 @@ const ConfigDocumentSchema = v.object({
   skills: v.fallback(v.optional(SkillsSectionSchema), undefined),
 });
 
+const IdentitySchema = v.object({
+  name: v.fallback(v.optional(v.string()), undefined),
+  provider: v.fallback(v.optional(v.picklist(["typed", "github"])), undefined),
+});
+
 const QuickActionSchema = v.object({
   prompt: v.pipe(
     v.string(),
@@ -275,6 +292,7 @@ function applyUi(ui: CueloopConfig["ui"], parsed: v.InferOutput<typeof UiSchema>
 function layer(
   base: CueloopConfig,
   raw: v.InferOutput<typeof ConfigDocumentSchema>,
+  allowIdentity: boolean,
 ): CueloopConfig {
   const out: CueloopConfig = {
     keys: { ...base.keys },
@@ -282,6 +300,7 @@ function layer(
     themeOverrides: { ...base.themeOverrides },
     ui: { ...base.ui },
     authors: { ...base.authors },
+    identity: { ...base.identity },
     actions: [...base.actions],
     skillsPath: base.skillsPath,
     integrations: { obsidian: { ...base.integrations.obsidian } },
@@ -289,6 +308,7 @@ function layer(
   };
   const actions = parseActions(raw.actions);
   const authors = v.safeParse(AuthorsSchema, raw.authors);
+  const identity = v.safeParse(IdentitySchema, raw.identity);
   const keys = v.safeParse(KeysSchema, raw.keys);
   const ui = v.safeParse(UiSchema, raw.ui);
   const integrations = v.safeParse(IntegrationsSchema, raw.integrations);
@@ -311,6 +331,11 @@ function layer(
         out.keys[action] = Array.isArray(combo.output) ? combo.output : [combo.output];
     }
   }
+  // The reviewer identity is a personal credential; a repo must never forge a verified name.
+  if (allowIdentity && identity.success) {
+    if (identity.output.name !== undefined) out.identity.name = identity.output.name;
+    if (identity.output.provider !== undefined) out.identity.provider = identity.output.provider;
+  }
   if (ui.success) applyUi(out.ui, ui.output);
   if (integrations.success && integrations.output.obsidian) {
     mergeObsidian(out.integrations.obsidian, integrations.output.obsidian);
@@ -336,6 +361,7 @@ export function loadConfig(
       pins: [],
     },
     authors: {},
+    identity: { provider: "typed" },
     actions: [...DEFAULT_QUICK_ACTIONS],
     skillsPath: join(homedir(), ".agents", "skills"),
     integrations: { obsidian: { ...OBSIDIAN_DEFAULTS } },
@@ -357,7 +383,7 @@ export function loadConfig(
     try {
       const raw = parseToml(readFileSync(path, "utf8"));
 
-      config = layer(config, raw);
+      config = layer(config, raw, path === userPath);
       const ui = v.safeParse(UiSchema, raw.ui);
       const rawTheme = ui.success ? ui.output.theme : undefined;
       const parsedThemeOverrides = v.safeParse(ThemeOverridesSchema, raw.theme);
@@ -459,6 +485,23 @@ export function persistActions(actions: QuickAction[], userConfigPath?: string):
   writeFileSync(path, text);
 }
 
+/** Persist the reviewer's own display name and its provider (`[identity]`) into the user config. */
+export function persistIdentity(identity: IdentityConfig, userConfigPath?: string): void {
+  const path = userConfigPathFrom(userConfigPath);
+  let text = existsSync(path) ? readFileSync(path, "utf8") : "";
+  const nameLine = identity.name === undefined ? "" : `name = ${tomlString(identity.name)}\n`;
+  const block = `[identity]\n${nameLine}provider = ${tomlString(identity.provider)}\n`;
+
+  if (/^\[identity\]/m.test(text)) {
+    // Consume the header and its assignment lines only, so a bracket in a quoted name cannot truncate the block.
+    text = text.replace(/^\[identity\].*(?:\n(?![[\n]).*)*\n?/m, block);
+  } else {
+    text = text.trimEnd() + (text.trim() ? "\n\n" : "") + block;
+  }
+  mkdirSync(dirname(path), { recursive: true });
+  writeFileSync(path, text);
+}
+
 /** Persist the auto-close choice (`[ui] auto_close`) into the user config. */
 export function persistAutoClose(value: AutoClose, userConfigPath?: string): void {
   persistUiSetting("auto_close", value === "off" ? '"off"' : String(value), userConfigPath);

package/src/diff-intraline.test.ts

@@ -1,5 +1,11 @@
-import { describe, expect, test } from "bun:test";
-import { intralineRunsByRow, wordLevelChanges, type IntralineRun } from "./diff-intraline";
+import { describe, expect, spyOn, test } from "bun:test";
+import * as intraline from "./diff-intraline";
+import {
+  createIntralineResolver,
+  intralineRunsByRow,
+  wordLevelChanges,
+  type IntralineRun,
+} from "./diff-intraline";
 import type { DiffRow } from "./view-diff";
 
 function line(kind: DiffRow["kind"], text: string): DiffRow {
@@ -163,3 +169,70 @@ describe("intralineRunsByRow", () => {
     expect(changedText(runsByRow.get(3)!)).toBe("FOUR");
   });
 });
+
+describe("createIntralineResolver", () => {
+  test("resolves each row to the same runs the eager pass would, on demand", () => {
+    // Arrange - context around two separate change blocks
+    const rows = [
+      line("ctx", "header"),
+      line("del", "one two"),
+      line("add", "one TWO"),
+      line("ctx", "middle"),
+      line("del", "alpha beta"),
+      line("add", "alpha GAMMA"),
+      line("ctx", "footer"),
+    ];
+    const eager = intralineRunsByRow(rows);
+
+    // Act
+    const resolver = createIntralineResolver(rows);
+
+    // Assert - lazy row-by-row output matches the eager map, including undefined for context rows
+    for (let index = 0; index < rows.length; index++) {
+      expect(resolver.runsForRow(index)).toEqual(eager.get(index));
+    }
+  });
+
+  test("a second call for the same row returns the cached runs", () => {
+    const rows = [line("del", "one two"), line("add", "one TWO")];
+    const resolver = createIntralineResolver(rows);
+
+    expect(resolver.runsForRow(0)).toBe(resolver.runsForRow(0));
+  });
+
+  // The performance guard: a virtualized diff must word-diff only the change blocks whose rows are on
+  // screen. This is deterministic (a call count, not a wall-clock), so it fails on any machine if a
+  // future change makes the resolver eager again - the regression the nav-latency benchmark would show.
+  test("word-diffs only the accessed block, not the whole diff", () => {
+    // Arrange - 50 independent change blocks, each a single del/add pair separated by context
+    const rows: DiffRow[] = [];
+
+    for (let block = 0; block < 50; block++) {
+      rows.push(
+        line("ctx", `ctx ${block}`),
+        line("del", `old ${block}`),
+        line("add", `new ${block}`),
+      );
+    }
+    const spy = spyOn(intraline, "wordLevelChanges");
+
+    try {
+      // Act - the eager pass word-diffs every block
+      spy.mockClear();
+      intralineRunsByRow(rows);
+      const eagerCalls = spy.mock.calls.length;
+
+      // Act - the resolver word-diffs only the one block whose row is asked for
+      spy.mockClear();
+      const resolver = createIntralineResolver(rows);
+      resolver.runsForRow(1); // a row in block 0
+      const oneBlockCalls = spy.mock.calls.length;
+
+      // Assert - eager pays for all 50 blocks; lazy pays for one
+      expect(eagerCalls).toBe(50);
+      expect(oneBlockCalls).toBe(1);
+    } finally {
+      spy.mockRestore();
+    }
+  });
+});