@cueloop/client 0.1.0-alpha.68 → 0.1.0-alpha.69

package/src/components/{diff-sheet-layout.ts → diff-content-view-layout.ts}

@@ -1,7 +1,7 @@
 /**
  * Pure color logic for the diff review sheet, split out so it can be tested
  * without rendering: a row's colored spans (syntax under the intra-line change
- * color). DiffSheet.tsx paints marks and the caret over these per character.
+ * color). DiffContentView.tsx paints marks and the caret over these per character.
  */
 
 import type { Theme } from "../theme";

package/src/config.test.ts

@@ -126,19 +126,32 @@ describe("loadConfig", () => {
     }
   });
 
-  test("[ui] diff_view defaults to unified and parses split", () => {
+  test("[ui] diff_view defaults to split and parses stacked", () => {
     // Arrange
     const dir = mkdtempSync(join(tmpdir(), "cueloop-cfg-diff-"));
     const path = join(dir, "config.toml");
 
-    writeFileSync(path, `[ui]\ndiff_view = "split"\n`);
+    writeFileSync(path, `[ui]\ndiff_view = "stacked"\n`);
 
     try {
       // Assert
-      expect(loadConfig({ userConfigPath: "/nonexistent/config.toml" }).ui.diffView).toBe(
-        "unified",
-      );
-      expect(loadConfig({ userConfigPath: path }).ui.diffView).toBe("split");
+      expect(loadConfig({ userConfigPath: "/nonexistent/config.toml" }).ui.diffView).toBe("split");
+      expect(loadConfig({ userConfigPath: path }).ui.diffView).toBe("stacked");
+    } finally {
+      rmSync(dir, { recursive: true, force: true });
+    }
+  });
+
+  test('[ui] diff_view loads the pre-rename "unified" value as "stacked"', () => {
+    // Arrange - an upgrade must not flip a user who had persisted the old spelling
+    const dir = mkdtempSync(join(tmpdir(), "cueloop-cfg-diff-"));
+    const path = join(dir, "config.toml");
+
+    writeFileSync(path, `[ui]\ndiff_view = "unified"\n`);
+
+    try {
+      // Assert
+      expect(loadConfig({ userConfigPath: path }).ui.diffView).toBe("stacked");
     } finally {
       rmSync(dir, { recursive: true, force: true });
     }

package/src/config.ts

@@ -26,8 +26,9 @@ export interface IntegrationsConfig {
 /** Post-submit behavior: "off" prompts, 0 closes instantly, N counts down. */
 export type AutoClose = "off" | number;
 
-/** How the Changes diff renders: one inline column, or old|new side by side (only when zoomed). */
-export type DiffViewMode = "unified" | "split";
+/** How the Changes diff renders when wide: old|new side by side, or one stacked column. A narrow
+ *  (unzoomed) pane has no room for two columns, so it is always stacked regardless of this choice. */
+export type DiffViewMode = "split" | "stacked";
 
 /** One marker-popover quick action: a preset comment body, plus optional extra lines. */
 export interface QuickAction {
@@ -99,7 +100,7 @@ export interface CueloopConfig {
     editor?: string;
     /** The selected theme preset name; its tokens are the base for `theme`, before any `[theme]` overrides. */
     theme: ThemeName;
-    /** How the Changes diff renders when zoomed: one inline column or old|new side by side. */
+    /** How the Changes diff renders when wide: old|new side by side or one stacked column. */
     diffView: DiffViewMode;
     /** Session ids the user has pinned to the top of the sidebar; client-local view state. */
     pins: string[];
@@ -109,6 +110,13 @@ export interface CueloopConfig {
   /** Marker-popover quick actions ([[actions]] tables); the 5 defaults when unset. */
   actions: QuickAction[];
   integrations: IntegrationsConfig;
+  /** Opt-in experimental features ([experimental] table); all default off. */
+  experimental: ExperimentalConfig;
+}
+
+export interface ExperimentalConfig {
+  /** Render a prototype as a pixel mockup (kitty graphics) instead of the default markdown design doc. */
+  prototypePixels: boolean;
 }
 
 /** Every action in the grammar, with its default binding(s). */
@@ -143,6 +151,7 @@ const ConfigDocumentSchema = v.object({
   keys: v.optional(v.unknown()),
   theme: v.optional(v.unknown()),
   ui: v.optional(v.unknown()),
+  experimental: v.optional(v.unknown()),
 });
 
 const QuickActionSchema = v.object({
@@ -165,7 +174,7 @@ const UiSchema = v.object({
   ),
   editor: v.fallback(v.optional(v.string()), undefined),
   theme: v.fallback(v.optional(v.string()), undefined),
-  diff_view: v.fallback(v.optional(v.picklist(["unified", "split"])), undefined),
+  diff_view: v.fallback(v.optional(v.picklist(["split", "stacked", "unified"])), undefined),
   pins: v.fallback(v.optional(v.array(v.string())), undefined),
 });
 const ObsidianSchema = v.object({
@@ -176,6 +185,9 @@ const ObsidianSchema = v.object({
   exportOn: v.fallback(v.optional(v.picklist(["approve", "resolve", "manual"])), undefined),
 });
 const IntegrationsSchema = v.object({ obsidian: v.optional(ObsidianSchema) });
+const ExperimentalSchema = v.object({
+  prototype_pixels: v.fallback(v.optional(v.boolean()), undefined),
+});
 const ThemeOverridesSchema = v.record(v.string(), v.unknown());
 
 function isThemeToken(token: string): token is keyof Theme {
@@ -225,12 +237,14 @@ function layer(
     authors: { ...base.authors },
     actions: [...base.actions],
     integrations: { obsidian: { ...base.integrations.obsidian } },
+    experimental: { ...base.experimental },
   };
   const actions = parseActions(raw.actions);
   const authors = v.safeParse(AuthorsSchema, raw.authors);
   const keys = v.safeParse(KeysSchema, raw.keys);
   const ui = v.safeParse(UiSchema, raw.ui);
   const integrations = v.safeParse(IntegrationsSchema, raw.integrations);
+  const experimental = v.safeParse(ExperimentalSchema, raw.experimental);
 
   if (actions) out.actions = actions;
   if (authors.success) {
@@ -251,12 +265,17 @@ function layer(
   if (ui.success) {
     if (ui.output.auto_close !== undefined) out.ui.autoClose = ui.output.auto_close;
     if (ui.output.editor?.trim()) out.ui.editor = ui.output.editor.trim();
-    if (ui.output.diff_view !== undefined) out.ui.diffView = ui.output.diff_view;
+    // "unified" is the pre-rename spelling of "stacked"; keep loading it so an upgrade never flips the layout
+    if (ui.output.diff_view !== undefined)
+      out.ui.diffView = ui.output.diff_view === "unified" ? "stacked" : ui.output.diff_view;
     if (ui.output.pins !== undefined) out.ui.pins = ui.output.pins;
   }
   if (integrations.success && integrations.output.obsidian) {
     mergeObsidian(out.integrations.obsidian, integrations.output.obsidian);
   }
+  if (experimental.success && experimental.output.prototype_pixels !== undefined) {
+    out.experimental.prototypePixels = experimental.output.prototype_pixels;
+  }
 
   return out;
 }
@@ -271,12 +290,13 @@ export function loadConfig(
     ui: {
       autoClose: "off",
       theme: DEFAULT_THEME_NAME,
-      diffView: "unified",
+      diffView: "split",
       pins: [],
     },
     authors: {},
     actions: [...DEFAULT_QUICK_ACTIONS],
     integrations: { obsidian: { ...OBSIDIAN_DEFAULTS } },
+    experimental: { prototypePixels: false },
   };
   // Theme name and per-token overrides are separate concerns, composed once
   // after all layers: the last file to set [ui] theme wins, and every [theme]

package/src/intent-dispatch.test.ts

@@ -97,6 +97,8 @@ function baseController(): ReviewController {
     restoreCuration: mock(),
     edit: mock(),
     annotate: mock(() => undefined),
+    addComment: mock(() => undefined),
+    commentOnWorkbench: mock(() => Promise.resolve()),
     reply: mock(() => undefined),
     annotatePrototype: mock(() => undefined),
     updateAnnotation: mock(),

package/src/intent-dispatch.ts

@@ -113,7 +113,7 @@ export interface IntentDispatchDeps {
   selectCardFromDocument: (annotationId: string) => void;
   runEditorHandOff: () => void;
   openCardEdit: (annotationId: string) => void;
-  /** Flip unified/split diff and persist it (App-owned); split lays out only when zoomed. */
+  /** Flip split/stacked diff and persist it (App-owned); split lays out only when wide/zoomed. */
   toggleDiffView: () => void;
 }
 

package/src/key-bindings.test.ts

@@ -115,7 +115,7 @@ describe("getActiveKeys-generated status hints", () => {
 
   test("submit hint", () => {
     expect(bindings({ overlay: "submit" }).statusHint("submit")).toBe(
-      "verdict ←/→ · enter submit · esc cancel",
+      "decision ←/→ · enter submit · esc cancel",
     );
   });
 

package/src/key-bindings.ts

@@ -92,7 +92,11 @@ const HINT_TEMPLATES: Record<HintMode, HintEntry[]> = {
     { commands: ["cancel_overlay"], label: "cancel" },
   ],
   submit: [
-    { commands: ["cycle_verdict_left", "cycle_verdict_right"], label: "verdict", labelFirst: true },
+    {
+      commands: ["cycle_verdict_left", "cycle_verdict_right"],
+      label: "decision",
+      labelFirst: true,
+    },
     { commands: ["submit_verdict"], label: "submit" },
     { commands: ["cancel_submit"], label: "cancel" },
   ],

package/src/keymap.ts

@@ -372,7 +372,7 @@ function navigationIntent(action: string | undefined): Intent[] | null {
 }
 
 /** Ungated view toggles in the diff: right folds a file to its band, left unfolds it, s flips
- *  unified/split (split lays out only when the Changes pane is zoomed). */
+ *  split/stacked (split lays out only when the Changes pane is wide/zoomed). */
 function viewToggleIntent(action: string | undefined): Intent[] | null {
   if (action === "collapse_file") return [{ type: "foldFile" }];
   if (action === "expand_file") return [{ type: "unfoldFile" }];

package/src/prototype-browser.ts

@@ -42,6 +42,9 @@ export interface LaunchOptions {
   deviceScaleFactor?: number;
   /** Absolute path to a Chrome/Chromium binary; falls back to the channel. */
   executablePath?: string;
+  /** The terminal's color scheme, emulated as prefers-color-scheme so a mockup
+   *  with theme-aware CSS renders to match the surface it emerges into. */
+  colorScheme?: "dark" | "light";
 }
 
 /** Cell click -> CSS pixel inside the letterboxed image, or null when outside it. */
@@ -145,6 +148,11 @@ export async function launchPrototypeRenderer(options: LaunchOptions): Promise<P
       height: options.viewport.height,
       deviceScaleFactor: options.deviceScaleFactor ?? 2,
     });
+    // match the terminal's scheme so a theme-aware mockup renders its dark or
+    // light variant to sit correctly on the surface it emerges into
+    await page.emulateMediaFeatures([
+      { name: "prefers-color-scheme", value: options.colorScheme ?? "light" },
+    ]);
     // `load` waits for images and styles but skips networkidle0's fixed 500ms
     // idle window, which a static local file would otherwise always pay
     await page.goto(pathToFileURL(options.filePath).href, { waitUntil: "load" });

package/src/prototype-pixels.tsx

@@ -0,0 +1,35 @@
+/**
+ * Lazy boundary for the opt-in kitty pixel prototype. The pixel path pulls in the
+ * kitty image writer, the headless-browser renderer, and (on first paint) puppeteer;
+ * none of that belongs in the runtime unless the `[experimental] prototype_pixels`
+ * flag is on. Importing only the TYPE here is erased at build time, so the real
+ * module - and its dependencies - loads only when this component actually mounts,
+ * which App does exclusively for a pixel prototype. This lives outside components/
+ * on purpose: it is an app boundary, not a visual component the story catalog covers.
+ */
+
+import React, { useEffect, useState } from "react";
+import type { PrototypeContentViewProps } from "./components/PrototypeContentView";
+
+type PixelPrototypeView =
+  (typeof import("./components/PrototypeContentView"))["PrototypeContentView"];
+
+export function PrototypePixels(props: PrototypeContentViewProps): React.ReactNode {
+  const [View, setView] = useState<PixelPrototypeView | null>(null);
+
+  useEffect(() => {
+    let alive = true;
+
+    void import("./components/PrototypeContentView").then((module) => {
+      if (alive) setView(() => module.PrototypeContentView);
+    });
+
+    return () => {
+      alive = false;
+    };
+  }, []);
+
+  if (!View) return null;
+
+  return <View {...props} />;
+}

package/src/ready-signal.test.ts

@@ -0,0 +1,85 @@
+/** The ready signal fires once, after a frame, and writes the ready file when the env names one. */
+
+import { afterEach, describe, expect, test } from "bun:test";
+import { existsSync, mkdtempSync, rmSync } from "node:fs";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+import { createElement, useState } from "react";
+import { testRender } from "@opentui/react/test-utils";
+import { READY_FILE_ENV, useReadySignal } from "./ready-signal";
+import { settle } from "./test-support";
+
+const homes: string[] = [];
+
+afterEach(() => {
+  for (const home of homes.splice(0)) rmSync(home, { recursive: true, force: true });
+  delete process.env[READY_FILE_ENV];
+});
+
+/** Hands its readiness setter to the test, so a frame can be rendered before and after the flip. */
+function ReadyProbe(props: {
+  initiallyReady: boolean;
+  onReady: () => void;
+  exposeSetter?: (setReady: (ready: boolean) => void) => void;
+}) {
+  const [ready, setReady] = useState(props.initiallyReady);
+
+  props.exposeSetter?.(setReady);
+  useReadySignal(ready, props.onReady);
+
+  return createElement("text", null, ready ? "ready" : "booting");
+}
+
+describe("useReadySignal", () => {
+  test("fires once on the first frame after ready turns true", async () => {
+    // Arrange - not ready yet
+    let fired = 0;
+    let setReady: ((ready: boolean) => void) | null = null;
+    const onReady = () => {
+      fired += 1;
+    };
+    const setup = await testRender(
+      createElement(ReadyProbe, {
+        initiallyReady: false,
+        onReady,
+        exposeSetter: (setter) => {
+          setReady = setter;
+        },
+      }),
+      { width: 20, height: 3 },
+    );
+
+    await settle(setup);
+    expect(fired).toBe(0);
+
+    // Act - ready, then let the commit, the effect, and more frames than one signal needs run
+    setReady!(true);
+    await settle(setup);
+    await settle(setup);
+
+    // Assert - exactly one signal, and the screen shows the ready tree
+    expect(fired).toBe(1);
+    expect(setup.captureCharFrame()).toContain("ready");
+    setup.renderer.destroy();
+  });
+
+  test("writes the ready file through the env channel", async () => {
+    // Arrange
+    const home = mkdtempSync(join(tmpdir(), "cueloop-ready-"));
+    const readyFile = join(home, "ready");
+
+    homes.push(home);
+    process.env[READY_FILE_ENV] = readyFile;
+    const setup = await testRender(
+      createElement(ReadyProbe, { initiallyReady: true, onReady: () => {} }),
+      { width: 20, height: 3 },
+    );
+
+    // Act
+    await settle(setup);
+
+    // Assert
+    expect(existsSync(readyFile)).toBe(true);
+    setup.renderer.destroy();
+  });
+});

package/src/ready-signal.ts

@@ -0,0 +1,52 @@
+/**
+ * The app ready signal: fired once, after the first frame that paints a
+ * usable screen (a session, the no-thread shell, or an error) has been
+ * flushed. React runs child effects before parent effects, so by the time the
+ * App-level effect arms the frame listener every keyboard handler of that
+ * first screen is already subscribed - a key sent after the signal cannot be
+ * dropped. Surfaces that mount later (a composer, a lazily loaded tab) still
+ * need their own screen predicate. Tests wait on this instead of guessing
+ * from output silence. Two channels: an
+ * `onReady` callback for in-process suites, and the file named by
+ * CUELOOP_READY_FILE for subprocess and PTY suites. Users never see either.
+ */
+
+import { writeFileSync } from "node:fs";
+import { useEffect, useRef } from "react";
+import { useRenderer } from "@opentui/react";
+
+/** The env var naming the file the app writes once it is ready; unset in normal use. */
+export const READY_FILE_ENV = "CUELOOP_READY_FILE";
+
+/** Write the ready file when CUELOOP_READY_FILE names one; a no-op otherwise, so the signal costs nothing outside tests. */
+function announceReady(): void {
+  const path = process.env[READY_FILE_ENV];
+
+  if (!path) return;
+  writeFileSync(path, "ready\n");
+}
+
+/**
+ * Fire the ready signal once, on the first rendered frame after `ready`
+ * turns true. Call it after every keyboard hook of the component so their
+ * subscriptions are in place when the signal goes out.
+ */
+export function useReadySignal(ready: boolean, onReady?: () => void): void {
+  const renderer = useRenderer();
+  const fired = useRef(false);
+
+  useEffect(() => {
+    if (!ready || fired.current) return;
+    const emit = (): void => {
+      fired.current = true;
+      announceReady();
+      onReady?.();
+    };
+
+    renderer?.once("frame", emit);
+
+    return () => {
+      renderer?.off("frame", emit);
+    };
+  }, [ready, renderer, onReady]);
+}

package/src/session-controller.live-diff.test.ts

@@ -0,0 +1,198 @@
+/**
+ * A non-diff thread (here a plan) still renders a real diff in the Changes view:
+ * the controller eagerly captures the live working-tree diff, so repoChanges()
+ * carries file contents and rows() derives from the patch - the same shape a
+ * cueloop diff pins, just computed live.
+ */
+
+import { describe, expect, mock, test } from "bun:test";
+import { SCHEMA_VERSION, type Annotation, type ReviewSession } from "@cueloop/schema";
+import type { SessionClient } from "@cueloop/daemon/client";
+import { createReviewController, type ShareTransport } from "./session-controller";
+import { mergeFromShare } from "./share";
+
+const AT = "2026-01-01T00:00:00.000Z";
+
+const PATCH = `diff --git a/src/x.ts b/src/x.ts
+--- a/src/x.ts
++++ b/src/x.ts
+@@ -1,1 +1,1 @@
+-const a = 1;
++const a = 2;
+`;
+
+const FILES = [
+  {
+    path: "src/x.ts",
+    oldContents: "const a = 1;\n",
+    newContents: "const a = 2;\n",
+    status: "modified" as const,
+  },
+];
+
+const shareTransport: ShareTransport = {
+  publish: mock(async (session: ReviewSession) => ({
+    line: `ssh p_${session.id}@cueloop.dev`,
+    copied: true,
+  })),
+  pull: mock(async () => planSession()),
+  push: mock(async () => {}),
+  watch: () => () => {},
+  parseShareId: (line) => line.match(/^ssh (\S+)@/)?.[1],
+  collaboratorAnnotations: (session) => session.annotations.filter((entry) => entry.author),
+  mergeFromShare,
+};
+
+function planSession(id = "ses_plan", repoRoot = "/repo"): ReviewSession {
+  return {
+    schemaVersion: SCHEMA_VERSION,
+    id,
+    workspace: { repoRoot, branch: "main" },
+    artifact: { type: "plan", content: "# Plan\n", meta: {} },
+    revisions: [{ revision: 1, content: "# Plan\n", submittedAt: AT }],
+    annotations: [],
+    verdict: null,
+    status: "pending",
+    createdAt: AT,
+  };
+}
+
+const unimplemented = (member: string) => () =>
+  Promise.reject(new Error(`fakeClient does not implement ${member}`));
+
+function fakeClient(session: ReviewSession): SessionClient {
+  return {
+    onEvent: () => () => {},
+    subscribe: async () => {},
+    sessionGet: async () => session,
+    sessionList: async () => [session],
+    sessionAnnotate: unimplemented("sessionAnnotate"),
+    sessionRemoveAnnotation: unimplemented("sessionRemoveAnnotation"),
+    sessionSetWorkingCopy: unimplemented("sessionSetWorkingCopy"),
+    sessionCutBlock: unimplemented("sessionCutBlock"),
+    sessionRestoreBlock: unimplemented("sessionRestoreBlock"),
+    sessionCurate: unimplemented("sessionCurate"),
+    sessionNavigate: unimplemented("sessionNavigate"),
+    sessionBranch: unimplemented("sessionBranch"),
+    sessionSwitch: unimplemented("sessionSwitch"),
+    sessionLabel: unimplemented("sessionLabel"),
+    sessionFork: unimplemented("sessionFork"),
+    sessionSetViewed: unimplemented("sessionSetViewed"),
+    sessionSetTitle: unimplemented("sessionSetTitle"),
+    sessionSetShareId: unimplemented("sessionSetShareId"),
+    sessionMergeShared: unimplemented("sessionMergeShared"),
+    sessionDelete: unimplemented("sessionDelete"),
+    sessionSetSelfName: unimplemented("sessionSetSelfName"),
+    sessionResolve: unimplemented("sessionResolve"),
+    repoDiff: async () => ({ patch: PATCH, files: FILES }),
+    close: () => {},
+  } satisfies SessionClient;
+}
+
+const tick = () => new Promise((resolve) => setTimeout(resolve, 0));
+
+describe("live working-tree diff for a non-diff thread", () => {
+  test("repoChanges carries file contents and rows derive from the patch", async () => {
+    const session = planSession();
+    const controller = createReviewController({
+      sessionId: session.id,
+      openClient: async () => fakeClient(session),
+      shareTransport,
+    });
+    controller.connect();
+    await tick();
+
+    // Act - the Changes navigator loads
+    const changes = await controller.repoChanges();
+
+    // Assert - real per-file contents, not empty stubs
+    expect(changes.map((file) => file.path)).toEqual(["src/x.ts"]);
+    expect(changes[0]!.newContents).toBe("const a = 2;\n");
+
+    // and the diff rows derive from the live patch, so an opened file tab shows a diff
+    expect(controller.rows().some((row) => row.file === "src/x.ts")).toBe(true);
+
+    // the live per-file contents let a non-diff thread expand a folded file too
+    expect(controller.canExpandFile("src/x.ts")).toBe(true);
+
+    controller.close();
+  });
+
+  test("annotating the Changes diff stamps a file target anchored to the diff rows", async () => {
+    const session = planSession();
+    let sent: Annotation | undefined;
+    const client = {
+      ...fakeClient(session),
+      sessionAnnotate: async (_id: string, annotation: Annotation) => {
+        sent = annotation;
+
+        return { ...session, annotations: [{ ...annotation, createdAt: AT }] };
+      },
+    } satisfies SessionClient;
+    const controller = createReviewController({
+      sessionId: session.id,
+      openClient: async () => client,
+      shareTransport,
+    });
+    controller.connect();
+    await tick();
+    await controller.repoChanges();
+
+    // Act - comment the added line of the working-tree diff, as the Changes surface does
+    const rows = controller.rows();
+    const addIndex = rows.findIndex((row) => row.kind === "add");
+    const addText = rows[addIndex]!.text.replace(/\n$/, "");
+
+    controller.annotate("comment", addIndex, 0, addText.length, "eviction?", addIndex, {
+      kind: "file",
+      path: "",
+      rev: "worktree",
+    });
+
+    // Assert - the note carries the file target (path and rev filled from the row) and quotes the diff
+    expect(sent?.target).toEqual({ kind: "file", path: "src/x.ts", rev: "worktree" });
+    expect(sent?.anchor.quote).toContain("const a = 2");
+
+    controller.close();
+  });
+
+  test("a late diff response from a previous thread never overwrites the active one", async () => {
+    const sessionA = planSession("ses_A", "/repoA");
+    const sessionB = planSession("ses_B", "/repoB");
+    let resolveA: (diff: { patch: string; files: typeof FILES }) => void = () => {};
+    const pendingA = new Promise<{ patch: string; files: typeof FILES }>((resolve) => {
+      resolveA = resolve;
+    });
+    const diffB = {
+      patch: PATCH.replace(/x\.ts/g, "y.ts"),
+      files: [{ ...FILES[0]!, path: "src/y.ts" }],
+    };
+    const client = {
+      ...fakeClient(sessionA),
+      sessionList: async () => [sessionA, sessionB],
+      repoDiff: async (cwd: string) => (cwd === "/repoA" ? pendingA : diffB),
+    } satisfies SessionClient;
+
+    const controller = createReviewController({
+      sessionId: sessionA.id,
+      openClient: async () => client,
+      shareTransport,
+    });
+    controller.connect();
+    await tick();
+
+    // thread A's diff is still in flight when the user switches to thread B
+    const inFlightA = controller.repoChanges();
+    controller.open("ses_B");
+    await controller.repoChanges();
+    // B's diff is showing; now A's stale response lands
+    resolveA({ patch: PATCH, files: FILES });
+    await inFlightA;
+
+    // the active thread keeps B's changes; A's late response is dropped
+    expect(controller.rows().some((row) => row.file === "src/y.ts")).toBe(true);
+    expect(controller.rows().some((row) => row.file === "src/x.ts")).toBe(false);
+
+    controller.close();
+  });
+});