@stigmer/react 3.1.1 → 3.1.2

package/src/workspace/__tests__/EditorTabs.test.tsx

@@ -0,0 +1,100 @@
+import { describe, it, expect, vi, afterEach } from "vitest";
+import { render, screen, cleanup, fireEvent } from "@testing-library/react";
+import { EditorTabs } from "../EditorTabs";
+import { editorKey, type OpenEditor } from "../../internal/store/index";
+
+const editors: OpenEditor[] = [
+  { entryId: "e1", path: "src/a.ts", preview: false },
+  { entryId: "e1", path: "src/b.ts", preview: true },
+];
+
+function renderTabs(
+  overrides: Partial<React.ComponentProps<typeof EditorTabs>> = {},
+) {
+  const onActivate = vi.fn();
+  const onPin = vi.fn();
+  const onClose = vi.fn();
+  render(
+    <EditorTabs
+      editors={editors}
+      activeKey={editorKey("e1", "src/a.ts")}
+      onActivate={onActivate}
+      onPin={onPin}
+      onClose={onClose}
+      {...overrides}
+    />,
+  );
+  return { onActivate, onPin, onClose };
+}
+
+afterEach(() => cleanup());
+
+describe("EditorTabs", () => {
+  it("renders a tab per editor with basenames", () => {
+    renderTabs();
+    expect(screen.getByRole("tab", { name: /a\.ts/ })).toBeTruthy();
+    expect(screen.getByRole("tab", { name: /b\.ts/ })).toBeTruthy();
+  });
+
+  it("marks the active tab aria-selected", () => {
+    renderTabs();
+    expect(
+      screen.getByRole("tab", { name: /a\.ts/ }).getAttribute("aria-selected"),
+    ).toBe("true");
+    expect(
+      screen.getByRole("tab", { name: /b\.ts/ }).getAttribute("aria-selected"),
+    ).toBe("false");
+  });
+
+  it("renders the preview tab label in italics", () => {
+    renderTabs();
+    // b.ts is the preview tab; its label span carries the italic class.
+    const label = screen.getByText("b.ts");
+    expect(label.className).toContain("italic");
+    const pinnedLabel = screen.getByText("a.ts");
+    expect(pinnedLabel.className).not.toContain("italic");
+  });
+
+  it("activates a tab on click", () => {
+    const { onActivate } = renderTabs();
+    fireEvent.click(screen.getByRole("tab", { name: /b\.ts/ }));
+    expect(onActivate).toHaveBeenCalledWith("e1", "src/b.ts");
+  });
+
+  it("pins a tab on double click", () => {
+    const { onPin } = renderTabs();
+    fireEvent.doubleClick(screen.getByRole("tab", { name: /b\.ts/ }));
+    expect(onPin).toHaveBeenCalledWith("e1", "src/b.ts");
+  });
+
+  it("closes a tab via its close button", () => {
+    const { onClose } = renderTabs();
+    fireEvent.click(screen.getByRole("button", { name: "Close a.ts" }));
+    expect(onClose).toHaveBeenCalledWith("e1", "src/a.ts");
+  });
+
+  it("closes a tab on middle click", () => {
+    const { onClose } = renderTabs();
+    fireEvent(
+      screen.getByRole("tab", { name: /a\.ts/ }),
+      new MouseEvent("auxclick", { bubbles: true, button: 1 }),
+    );
+    expect(onClose).toHaveBeenCalledWith("e1", "src/a.ts");
+  });
+
+  it("moves activation with arrow keys", () => {
+    const { onActivate } = renderTabs();
+    fireEvent.keyDown(screen.getByRole("tab", { name: /a\.ts/ }), {
+      key: "ArrowRight",
+    });
+    expect(onActivate).toHaveBeenCalledWith("e1", "src/b.ts");
+  });
+
+  it("closes the focused tab on Delete", () => {
+    const { onClose } = renderTabs();
+    fireEvent.keyDown(screen.getByRole("tab", { name: /a\.ts/ }), {
+      key: "Delete",
+    });
+    expect(onClose).toHaveBeenCalledWith("e1", "src/a.ts");
+  });
+});

package/src/workspace/__tests__/ExplorerTree.test.tsx

@@ -0,0 +1,152 @@
+import { describe, it, expect, vi, afterEach } from "vitest";
+import { render, screen, fireEvent, cleanup } from "@testing-library/react";
+import { ExplorerTree } from "../ExplorerTree";
+import type { WorkspaceEntry } from "../useWorkspaceEntries";
+import type { WorkspaceFileLister } from "../WorkspaceFileLister";
+
+afterEach(cleanup);
+
+// Unique entry ids per test — `useWorkspaceFiles` keys a module-level cache by
+// entry.id, so reusing ids would leak listings across tests.
+function entry(id: string, name = "acme/repo"): WorkspaceEntry {
+  return {
+    id,
+    name,
+    type: "git",
+    gitUrl: "https://github.com/acme/repo",
+    gitBranch: "main",
+  };
+}
+
+function lister(paths: string[]): WorkspaceFileLister {
+  return vi.fn(async () => paths.map((path) => ({ path, isDirectory: false })));
+}
+
+describe("ExplorerTree", () => {
+  it("renders a root header and its top-level files", async () => {
+    render(
+      <ExplorerTree
+        entries={[entry("x1")]}
+        lister={lister(["a.ts", "README.md"])}
+        selectedFile={null}
+        onOpenFile={vi.fn()}
+        onActivateFile={vi.fn()}
+      />,
+    );
+    expect(screen.getByText("acme/repo")).toBeTruthy();
+    expect(await screen.findByText("a.ts")).toBeTruthy();
+    expect(screen.getByText("README.md")).toBeTruthy();
+  });
+
+  it("starts folders collapsed, revealing children on expand", async () => {
+    render(
+      <ExplorerTree
+        entries={[entry("x1b")]}
+        lister={lister(["src/nested.ts"])}
+        selectedFile={null}
+        onOpenFile={vi.fn()}
+        onActivateFile={vi.fn()}
+      />,
+    );
+    const folder = await screen.findByText("src");
+    expect(screen.queryByText("nested.ts")).toBeNull();
+    fireEvent.click(folder);
+    expect(await screen.findByText("nested.ts")).toBeTruthy();
+  });
+
+  it("opens a file (preview) on single click", async () => {
+    const onOpenFile = vi.fn();
+    render(
+      <ExplorerTree
+        entries={[entry("x2")]}
+        lister={lister(["a.ts"])}
+        selectedFile={null}
+        onOpenFile={onOpenFile}
+        onActivateFile={vi.fn()}
+      />,
+    );
+    fireEvent.click(await screen.findByText("a.ts"));
+    expect(onOpenFile).toHaveBeenCalledWith("x2", "a.ts");
+  });
+
+  it("pins a file (activate) on double click", async () => {
+    const onActivateFile = vi.fn();
+    render(
+      <ExplorerTree
+        entries={[entry("x3")]}
+        lister={lister(["a.ts"])}
+        selectedFile={null}
+        onOpenFile={vi.fn()}
+        onActivateFile={onActivateFile}
+      />,
+    );
+    fireEvent.doubleClick(await screen.findByText("a.ts"));
+    expect(onActivateFile).toHaveBeenCalledWith("x3", "a.ts");
+  });
+
+  it("highlights the selected file scoped to its entry", async () => {
+    render(
+      <ExplorerTree
+        entries={[entry("x4")]}
+        lister={lister(["a.ts", "b.ts"])}
+        selectedFile={{ entryId: "x4", path: "a.ts" }}
+        onOpenFile={vi.fn()}
+        onActivateFile={vi.fn()}
+      />,
+    );
+    const selected = await screen.findByText("a.ts");
+    const other = screen.getByText("b.ts");
+    expect(selected.closest("button")?.getAttribute("aria-current")).toBe("true");
+    expect(other.closest("button")?.getAttribute("aria-current")).toBeNull();
+  });
+
+  it("collapses all but the first root by default", async () => {
+    render(
+      <ExplorerTree
+        entries={[entry("x5a", "first"), entry("x5b", "second")]}
+        lister={lister(["a.ts"])}
+        selectedFile={null}
+        onOpenFile={vi.fn()}
+        onActivateFile={vi.fn()}
+      />,
+    );
+    // First root is expanded (its file shows); second root header shows but its
+    // tree is not fetched/rendered until expanded.
+    expect(await screen.findByText("a.ts")).toBeTruthy();
+    const second = screen.getByText("second").closest("button")!;
+    expect(second.getAttribute("aria-expanded")).toBe("false");
+  });
+
+  it("offers a remove control per root when onRemoveEntry is provided", async () => {
+    const onRemoveEntry = vi.fn();
+    render(
+      <ExplorerTree
+        entries={[entry("x6")]}
+        lister={lister(["a.ts"])}
+        selectedFile={null}
+        onOpenFile={vi.fn()}
+        onActivateFile={vi.fn()}
+        onRemoveEntry={onRemoveEntry}
+      />,
+    );
+    fireEvent.click(
+      screen.getByRole("button", { name: "Remove acme/repo from workspace" }),
+    );
+    expect(onRemoveEntry).toHaveBeenCalledWith("x6");
+  });
+
+  it("is browse-only (no remove controls) without onRemoveEntry", () => {
+    render(
+      <ExplorerTree
+        entries={[entry("x7")]}
+        lister={lister(["a.ts"])}
+        selectedFile={null}
+        onOpenFile={vi.fn()}
+        onActivateFile={vi.fn()}
+      />,
+    );
+    expect(
+      screen.queryByRole("button", { name: /Remove .* from workspace/ }),
+    ).toBeNull();
+  });
+});

package/src/workspace/__tests__/FileViewer.test.tsx

@@ -0,0 +1,421 @@
+import { describe, it, expect, vi, beforeEach, afterEach } from "vitest";
+import { render, screen, fireEvent, waitFor, cleanup } from "@testing-library/react";
+import { create } from "@bufbuild/protobuf";
+import {
+  FileChangeSchema,
+  FileContentSchema,
+  type FileChange,
+} from "@stigmer/protos/ai/stigmer/agentic/agentexecution/v1/message_pb";
+import {
+  FileChangeCaptureLevel,
+  FileChangeType,
+} from "@stigmer/protos/ai/stigmer/agentic/agentexecution/v1/enum_pb";
+import type { UseFileChangeContentReturn } from "../../execution/useFileChangeContent";
+
+// Drive FileChangeDiff's content deterministically (it is rendered by the diff
+// pane) — same seam FileChangesView's own tests mock.
+let mockFileChangeContent: UseFileChangeContentReturn;
+vi.mock("../../execution/useFileChangeContent", () => ({
+  useFileChangeContent: () => mockFileChangeContent,
+}));
+
+const { FileViewer } = await import("../FileViewer");
+
+afterEach(cleanup);
+beforeEach(() => {
+  mockFileChangeContent = {
+    beforeText: "alpha\n",
+    afterText: "beta\n",
+    isBinary: false,
+    isLoading: false,
+    error: null,
+    isTruncated: false,
+    downloadUrl: null,
+  };
+});
+import type { WorkspaceEntry } from "../useWorkspaceEntries";
+import type {
+  WorkspaceFileContent,
+  WorkspaceFileReader,
+} from "../WorkspaceFileReader";
+
+function wholeFileChange(path: string): FileChange {
+  return create(FileChangeSchema, {
+    path,
+    changeType: FileChangeType.MODIFY,
+    captureLevel: FileChangeCaptureLevel.WHOLE_FILE,
+    before: create(FileContentSchema, { body: { case: "inline", value: "alpha\n" } }),
+    after: create(FileContentSchema, { body: { case: "inline", value: "beta\n" } }),
+  });
+}
+
+function deleteChange(path: string): FileChange {
+  return create(FileChangeSchema, {
+    path,
+    changeType: FileChangeType.DELETE,
+    captureLevel: FileChangeCaptureLevel.WHOLE_FILE,
+    before: create(FileContentSchema, { body: { case: "inline", value: "alpha\n" } }),
+  });
+}
+
+function gitEntry(id = "e1"): WorkspaceEntry {
+  return {
+    id,
+    name: "acme/repo",
+    type: "git",
+    gitUrl: "https://github.com/acme/repo",
+    gitBranch: "main",
+  };
+}
+
+const ENTRIES = [gitEntry()];
+
+function readerFor(result: WorkspaceFileContent | null): WorkspaceFileReader {
+  return vi.fn(async () => result);
+}
+
+function text(t: string): WorkspaceFileContent {
+  return { text: t, isBinary: false, size: t.length, encoding: "utf-8" };
+}
+
+describe("FileViewer", () => {
+  it("shows the unsupported state when no reader is injected", () => {
+    render(
+      <FileViewer
+        selectedFile={{ entryId: "e1", path: "src/a.ts" }}
+        entries={ENTRIES}
+        reader={undefined}
+      />,
+    );
+    expect(screen.getByText(/Preview isn.t available/i)).toBeTruthy();
+  });
+
+  it("shows a loading skeleton while the read is in flight", () => {
+    const reader: WorkspaceFileReader = () => new Promise(() => {});
+    render(
+      <FileViewer
+        selectedFile={{ entryId: "e1", path: "src/a.ts" }}
+        entries={ENTRIES}
+        reader={reader}
+      />,
+    );
+    expect(screen.getByLabelText("Loading file")).toBeTruthy();
+  });
+
+  it("renders displayable text via the shared renderer", async () => {
+    render(
+      <FileViewer
+        selectedFile={{ entryId: "e1", path: "src/a.ts" }}
+        entries={ENTRIES}
+        reader={readerFor(text("const answer = 42;"))}
+      />,
+    );
+    await waitFor(() =>
+      expect(screen.getByText("const answer = 42;")).toBeTruthy(),
+    );
+  });
+
+  it("shows the binary state for binary content", async () => {
+    render(
+      <FileViewer
+        selectedFile={{ entryId: "e1", path: "logo.png" }}
+        entries={ENTRIES}
+        reader={readerFor({ text: null, isBinary: true, size: 2048, encoding: "unknown" })}
+      />,
+    );
+    await waitFor(() => expect(screen.getByText(/Binary file/i)).toBeTruthy());
+  });
+
+  it("shows the too-large state for a size-capped read with no text", async () => {
+    render(
+      <FileViewer
+        selectedFile={{ entryId: "e1", path: "big.log" }}
+        entries={ENTRIES}
+        reader={readerFor({
+          text: null,
+          isBinary: false,
+          size: 20 * 1024 * 1024,
+          encoding: "none",
+          truncated: true,
+        })}
+      />,
+    );
+    await waitFor(() =>
+      expect(screen.getByText(/too large to preview/i)).toBeTruthy(),
+    );
+  });
+
+  it("shows the undecodable state when text is null without truncation or binary", async () => {
+    render(
+      <FileViewer
+        selectedFile={{ entryId: "e1", path: "weird.dat" }}
+        entries={ENTRIES}
+        reader={readerFor({ text: null, isBinary: false, size: 5, encoding: "unknown" })}
+      />,
+    );
+    await waitFor(() =>
+      expect(screen.getByText(/can.t be displayed as text/i)).toBeTruthy(),
+    );
+  });
+
+  it("shows the error state with a working Retry", async () => {
+    let attempt = 0;
+    const reader: WorkspaceFileReader = vi.fn(async () => {
+      attempt += 1;
+      if (attempt === 1) throw new Error("network down");
+      return text("recovered");
+    });
+    render(
+      <FileViewer
+        selectedFile={{ entryId: "e1", path: "src/a.ts" }}
+        entries={ENTRIES}
+        reader={reader}
+      />,
+    );
+
+    await waitFor(() => expect(screen.getByText("network down")).toBeTruthy());
+
+    fireEvent.click(screen.getByText("Retry"));
+
+    await waitFor(() => expect(screen.getByText("recovered")).toBeTruthy());
+    expect(reader).toHaveBeenCalledTimes(2);
+  });
+
+  it("shows the empty state when the owning entry has been removed", () => {
+    render(
+      <FileViewer
+        selectedFile={{ entryId: "gone", path: "src/a.ts" }}
+        entries={ENTRIES}
+        reader={readerFor(text("x"))}
+      />,
+    );
+    expect(screen.getByText(/no longer in the workspace/i)).toBeTruthy();
+  });
+
+  it("renders the basename and directory in the header", async () => {
+    render(
+      <FileViewer
+        selectedFile={{ entryId: "e1", path: "src/deep/module.ts" }}
+        entries={ENTRIES}
+        reader={readerFor(text("ok"))}
+      />,
+    );
+    expect(screen.getByText("module.ts")).toBeTruthy();
+    expect(screen.getByText("src/deep")).toBeTruthy();
+  });
+
+  it("invokes onClose from the close button", async () => {
+    const onClose = vi.fn();
+    render(
+      <FileViewer
+        selectedFile={{ entryId: "e1", path: "src/a.ts" }}
+        entries={ENTRIES}
+        reader={readerFor(text("ok"))}
+        onClose={onClose}
+      />,
+    );
+    fireEvent.click(screen.getByLabelText("Close file viewer"));
+    expect(onClose).toHaveBeenCalledTimes(1);
+  });
+
+  // --- no `change` prop: unchanged browse-only behavior (regression) --------
+
+  it("shows no view toggle when no change is provided", async () => {
+    render(
+      <FileViewer
+        selectedFile={{ entryId: "e1", path: "src/a.ts" }}
+        entries={ENTRIES}
+        reader={readerFor(text("plain content"))}
+      />,
+    );
+    await waitFor(() => expect(screen.getByText("plain content")).toBeTruthy());
+    expect(screen.queryByRole("radiogroup", { name: "File view" })).toBeNull();
+    expect(screen.queryByText(/Live — may differ/i)).toBeNull();
+  });
+});
+
+// ---------------------------------------------------------------------------
+// Diff mode (Slice 4) — a changed file defaults to its authoritative diff
+// ---------------------------------------------------------------------------
+
+describe("FileViewer — diff mode", () => {
+  it("defaults a changed file to the Diff view", async () => {
+    render(
+      <FileViewer
+        selectedFile={{ entryId: "e1", path: "src/a.ts" }}
+        entries={ENTRIES}
+        reader={readerFor(text("live content"))}
+        change={wholeFileChange("src/a.ts")}
+      />,
+    );
+
+    const group = screen.getByRole("radiogroup", { name: "File view" });
+    const diffRadio = screen.getByRole("radio", { name: "Diff" });
+    expect(diffRadio.getAttribute("aria-checked")).toBe("true");
+    expect(group).toBeTruthy();
+    // The diff (added side) renders; the live file body does not.
+    await waitFor(() => expect(screen.getByText("beta")).toBeTruthy());
+    expect(screen.queryByText("live content")).toBeNull();
+    // Refresh is meaningless for an immutable captured diff.
+    expect(screen.queryByLabelText("Reload a.ts")).toBeNull();
+  });
+
+  it("toggles to the live File view, showing the live caption and content", async () => {
+    render(
+      <FileViewer
+        selectedFile={{ entryId: "e1", path: "src/a.ts" }}
+        entries={ENTRIES}
+        reader={readerFor(text("live content"))}
+        change={wholeFileChange("src/a.ts")}
+      />,
+    );
+
+    fireEvent.click(screen.getByRole("radio", { name: "File" }));
+
+    await waitFor(() => expect(screen.getByText("live content")).toBeTruthy());
+    expect(screen.getByText(/Live — may differ from the reviewed change/i)).toBeTruthy();
+    expect(screen.getByRole("radio", { name: "File" }).getAttribute("aria-checked")).toBe("true");
+    // Refresh returns in the live view.
+    expect(screen.getByLabelText("Reload a.ts")).toBeTruthy();
+  });
+
+  it("omits the File option when no reader supports the substrate (diff only)", async () => {
+    render(
+      <FileViewer
+        selectedFile={{ entryId: "e1", path: "src/a.ts" }}
+        entries={ENTRIES}
+        reader={undefined}
+        change={wholeFileChange("src/a.ts")}
+      />,
+    );
+    await waitFor(() => expect(screen.getByText("beta")).toBeTruthy());
+    expect(screen.queryByRole("radiogroup", { name: "File view" })).toBeNull();
+  });
+
+  it("omits the File option for a DELETE change (no current bytes)", async () => {
+    render(
+      <FileViewer
+        selectedFile={{ entryId: "e1", path: "src/gone.ts" }}
+        entries={ENTRIES}
+        reader={readerFor(text("should not be reachable"))}
+        change={deleteChange("src/gone.ts")}
+      />,
+    );
+    await waitFor(() => expect(screen.getByText("alpha")).toBeTruthy());
+    expect(screen.queryByRole("radiogroup", { name: "File view" })).toBeNull();
+  });
+
+  it("supports arrow-key roving between Diff and File (radiogroup a11y)", async () => {
+    render(
+      <FileViewer
+        selectedFile={{ entryId: "e1", path: "src/a.ts" }}
+        entries={ENTRIES}
+        reader={readerFor(text("live content"))}
+        change={wholeFileChange("src/a.ts")}
+      />,
+    );
+
+    const diffRadio = screen.getByRole("radio", { name: "Diff" });
+    fireEvent.keyDown(diffRadio, { key: "ArrowRight" });
+    await waitFor(() =>
+      expect(screen.getByRole("radio", { name: "File" }).getAttribute("aria-checked")).toBe("true"),
+    );
+
+    fireEvent.keyDown(screen.getByRole("radio", { name: "File" }), { key: "ArrowLeft" });
+    await waitFor(() =>
+      expect(screen.getByRole("radio", { name: "Diff" }).getAttribute("aria-checked")).toBe("true"),
+    );
+  });
+});
+
+// ---------------------------------------------------------------------------
+// Reveal (jump-to-line) — a line target opens File view and scrolls to it
+// ---------------------------------------------------------------------------
+
+describe("FileViewer — reveal (jump-to-line)", () => {
+  let scrollIntoView: ReturnType<typeof vi.fn>;
+  beforeEach(() => {
+    scrollIntoView = vi.fn();
+    Element.prototype.scrollIntoView =
+      scrollIntoView as unknown as typeof Element.prototype.scrollIntoView;
+  });
+
+  it("opens a changed file in the live File view when a reveal is present (DR-1)", async () => {
+    render(
+      <FileViewer
+        selectedFile={{ entryId: "e1", path: "src/a.ts" }}
+        entries={ENTRIES}
+        reader={readerFor(text("live content"))}
+        change={wholeFileChange("src/a.ts")}
+        reveal={{ line: 1, nonce: 1 }}
+      />,
+    );
+
+    // File view wins over the diff-default, but the Diff toggle stays available.
+    expect(screen.getByRole("radio", { name: "File" }).getAttribute("aria-checked")).toBe("true");
+    expect(screen.getByRole("radio", { name: "Diff" })).toBeTruthy();
+    await waitFor(() => expect(screen.getByText("live content")).toBeTruthy());
+  });
+
+  it("highlights the revealed line and scrolls to it", async () => {
+    const { container } = render(
+      <FileViewer
+        selectedFile={{ entryId: "e1", path: "src/a.ts" }}
+        entries={ENTRIES}
+        reader={readerFor(text("one\ntwo\nthree"))}
+        reveal={{ line: 2, nonce: 1 }}
+      />,
+    );
+    await waitFor(() => expect(container.querySelector('[data-line="2"]')).not.toBeNull());
+    expect(container.querySelector('[data-line="2"]')?.className).toContain(
+      "bg-primary-subtle",
+    );
+    expect(scrollIntoView).toHaveBeenCalled();
+  });
+
+  it("re-forces the File view when a new reveal nonce arrives after a manual toggle", async () => {
+    const { rerender } = render(
+      <FileViewer
+        selectedFile={{ entryId: "e1", path: "src/a.ts" }}
+        entries={ENTRIES}
+        reader={readerFor(text("live content"))}
+        change={wholeFileChange("src/a.ts")}
+        reveal={{ line: 1, nonce: 1 }}
+      />,
+    );
+    // User flips to Diff.
+    fireEvent.click(screen.getByRole("radio", { name: "Diff" }));
+    await waitFor(() =>
+      expect(screen.getByRole("radio", { name: "Diff" }).getAttribute("aria-checked")).toBe("true"),
+    );
+
+    // A second search hit in the same (already-mounted) file bumps the nonce.
+    rerender(
+      <FileViewer
+        selectedFile={{ entryId: "e1", path: "src/a.ts" }}
+        entries={ENTRIES}
+        reader={readerFor(text("live content"))}
+        change={wholeFileChange("src/a.ts")}
+        reveal={{ line: 1, nonce: 2 }}
+      />,
+    );
+    await waitFor(() =>
+      expect(screen.getByRole("radio", { name: "File" }).getAttribute("aria-checked")).toBe("true"),
+    );
+  });
+
+  it("is a no-op for a DELETE change (no live bytes to anchor)", async () => {
+    render(
+      <FileViewer
+        selectedFile={{ entryId: "e1", path: "src/gone.ts" }}
+        entries={ENTRIES}
+        reader={readerFor(text("unused"))}
+        change={deleteChange("src/gone.ts")}
+        reveal={{ line: 1, nonce: 1 }}
+      />,
+    );
+    // Falls back to the diff (deleted side); no view toggle, no crash.
+    await waitFor(() => expect(screen.getByText("alpha")).toBeTruthy());
+    expect(screen.queryByRole("radiogroup", { name: "File view" })).toBeNull();
+  });
+});