@tangle-network/ui 11.51.7 → 11.51.9

package/src/files/file-card.test.tsx

@@ -1,62 +0,0 @@
-import { fireEvent, render, screen } from "@testing-library/react";
-import { describe, expect, it, vi } from "vitest";
-import { FileCard } from "./file-card";
-
-const UPLOADED = new Date("2026-10-06T15:30:00Z");
-
-describe("FileCard", () => {
-  it("names the file with its size, date and uploader", () => {
-    const { container } = render(
-      <FileCard
-        filename="Engagement letter.pdf"
-        size={2_516_582}
-        date={UPLOADED}
-        uploader={{ name: "Dana Ruiz", role: "Client" }}
-      />,
-    );
-
-    expect(screen.getByText("Engagement letter.pdf")).toBeInTheDocument();
-    expect(screen.getByText("2.4 MB")).toBeInTheDocument();
-    expect(container.querySelector("time")).toHaveAttribute("datetime", UPLOADED.toISOString());
-    expect(screen.getByText("Uploaded by Dana Ruiz (Client)")).toBeInTheDocument();
-  });
-
-  it("leaves out what it does not know", () => {
-    const { container } = render(<FileCard filename="notes.txt" date="not a date" />);
-    expect(container.querySelector("time")).toBeNull();
-    expect(screen.queryByText(/Uploaded by/)).toBeNull();
-    expect(screen.queryByRole("button")).toBeNull();
-  });
-
-  it("takes its icon tone from the file kind, with the MIME type outranking the name", () => {
-    const pdf = render(<FileCard filename="brief.pdf" />);
-    expect(pdf.container.querySelector("[aria-hidden='true']")?.className).toContain(
-      "--tone-orange-bg",
-    );
-    pdf.unmount();
-
-    const sheet = render(<FileCard filename="export" mimeType="text/csv" />);
-    expect(sheet.container.querySelector("[aria-hidden='true']")?.className).toContain(
-      "--tone-lime-bg",
-    );
-  });
-
-  it("offers Download and the host's own actions", () => {
-    const onDownload = vi.fn();
-    render(
-      <FileCard
-        filename="book.xlsx"
-        description="Download to open this workbook in a spreadsheet app."
-        onDownload={onDownload}
-        actions={<button type="button">Open</button>}
-      />,
-    );
-
-    expect(
-      screen.getByText("Download to open this workbook in a spreadsheet app."),
-    ).toBeInTheDocument();
-    fireEvent.click(screen.getByRole("button", { name: "Download" }));
-    expect(onDownload).toHaveBeenCalledTimes(1);
-    expect(screen.getByRole("button", { name: "Open" })).toBeInTheDocument();
-  });
-});

package/src/files/file-list.test.tsx

@@ -1,81 +0,0 @@
-import { fireEvent, render, screen, within } from "@testing-library/react";
-import { describe, expect, it, vi } from "vitest";
-import { FileList, type FileListItem } from "./file-list";
-
-interface CaseDocument extends FileListItem {
-  matterId: string;
-}
-
-const FILES: CaseDocument[] = [
-  {
-    id: "lease",
-    matterId: "m-1",
-    filename: "Commercial lease.pdf",
-    size: 482_000,
-    date: "2026-10-01T12:00:00Z",
-    uploader: { name: "Dana Ruiz", role: "Client" },
-  },
-  {
-    id: "photos",
-    matterId: "m-1",
-    filename: "Water damage.jpg",
-    mimeType: "image/jpeg",
-    size: 3_100_000,
-  },
-];
-
-describe("FileList", () => {
-  it("shows each file's kind, size and uploader", () => {
-    render(<FileList files={FILES} aria-label="Case documents" />);
-    const rows = within(screen.getByRole("list", { name: "Case documents" })).getAllByRole(
-      "listitem",
-    );
-    expect(rows).toHaveLength(2);
-    expect(rows[0]).toHaveTextContent("Commercial lease.pdf");
-    // A dot between facts on screen, a comma for a screen reader.
-    expect(rows[0]).toHaveTextContent(/PDF · , 471 KB · , .+ · , Dana Ruiz \(Client\)/);
-    expect(rows[1]).toHaveTextContent("Image · , 3.0 MB");
-  });
-
-  it("opens a file from its row and hands back the host's own record", () => {
-    const onOpen = vi.fn();
-    render(<FileList files={FILES} onOpen={onOpen} activeId="photos" />);
-
-    fireEvent.click(screen.getByRole("button", { name: /Commercial lease\.pdf/ }));
-    expect(onOpen).toHaveBeenCalledWith(FILES[0]);
-    expect(onOpen.mock.calls[0][0].matterId).toBe("m-1");
-
-    expect(screen.getByRole("button", { name: /Water damage\.jpg/ })).toHaveAttribute(
-      "aria-current",
-      "true",
-    );
-    expect(screen.getByRole("button", { name: /Commercial lease\.pdf/ })).not.toHaveAttribute(
-      "aria-current",
-    );
-  });
-
-  it("downloads and deletes through per-file buttons", () => {
-    const onDownload = vi.fn();
-    const onDelete = vi.fn();
-    render(<FileList files={FILES} onDownload={onDownload} onDelete={onDelete} />);
-
-    fireEvent.click(screen.getByRole("button", { name: "Download Water damage.jpg" }));
-    expect(onDownload).toHaveBeenCalledWith(FILES[1]);
-    fireEvent.click(screen.getByRole("button", { name: "Delete Commercial lease.pdf" }));
-    expect(onDelete).toHaveBeenCalledWith(FILES[0]);
-  });
-
-  it("renders no controls the host did not ask for", () => {
-    render(<FileList files={FILES} />);
-    expect(screen.queryByRole("button")).toBeNull();
-  });
-
-  it("shows the empty message in place of the list", () => {
-    const { rerender } = render(<FileList files={[]} />);
-    expect(screen.queryByRole("list")).toBeNull();
-    expect(screen.getByText("No files yet.")).toBeInTheDocument();
-
-    rerender(<FileList files={[]} empty="Upload the lease to start." />);
-    expect(screen.getByText("Upload the lease to start.")).toBeInTheDocument();
-  });
-});

package/src/files/pdf-loader.test.ts

@@ -1,130 +0,0 @@
-import { afterEach, beforeEach, describe, expect, it, vi } from "vitest";
-
-const PDFJS = "pdfjs-dist/legacy/build/pdf.mjs";
-const WORKER = "pdfjs-dist/legacy/build/pdf.worker.min.mjs";
-
-/** What the next import of pdf.js yields: a namespace, or a thrown error. */
-let pdfjsImport: () => Record<string, unknown>;
-let workerImports = 0;
-
-function installedPdfjs() {
-  return { getDocument: () => ({}), GlobalWorkerOptions: { workerSrc: "", workerPort: null } };
-}
-
-/**
- * Loads the module under test with pdf.js replaced. The loader reads it through
- * a dynamic import, so the substitution happens before the graph is built.
- */
-async function loadModule() {
-  vi.resetModules();
-  vi.doMock(PDFJS, () => pdfjsImport());
-  vi.doMock(WORKER, () => {
-    workerImports += 1;
-    return {};
-  });
-  return await import("./pdf-loader");
-}
-
-let consoleWarn: ReturnType<typeof vi.spyOn>;
-
-beforeEach(() => {
-  pdfjsImport = installedPdfjs;
-  workerImports = 0;
-  consoleWarn = vi.spyOn(console, "warn").mockImplementation(() => {});
-});
-
-afterEach(() => {
-  consoleWarn.mockRestore();
-  vi.doUnmock(PDFJS);
-  vi.doUnmock(WORKER);
-  vi.resetModules();
-});
-
-describe("loadPdfjs", () => {
-  it("runs the worker on the main thread when no worker URL is configured", async () => {
-    const { loadPdfjs } = await loadModule();
-    const pdfjs = await loadPdfjs();
-    expect(typeof pdfjs.getDocument).toBe("function");
-    expect(workerImports).toBe(1);
-    expect(pdfjs.GlobalWorkerOptions.workerSrc).toBe("");
-  });
-
-  it("uses the configured worker URL instead of importing the worker", async () => {
-    const { configurePdfViewer, loadPdfjs } = await loadModule();
-    configurePdfViewer({ workerSrc: "/assets/pdf.worker.min.mjs", assetsUrl: "/pdfjs/" });
-    const pdfjs = await loadPdfjs();
-    expect(pdfjs.GlobalWorkerOptions.workerSrc).toBe("/assets/pdf.worker.min.mjs");
-    expect(workerImports).toBe(0);
-    expect(consoleWarn).not.toHaveBeenCalled();
-  });
-
-  it("warns once that scanned pages need assetsUrl", async () => {
-    const { loadPdfjs } = await loadModule();
-    await loadPdfjs();
-    await loadPdfjs();
-    expect(consoleWarn).toHaveBeenCalledTimes(1);
-    expect(consoleWarn.mock.calls[0][0]).toMatch(/no assetsUrl.*JBIG2, CCITT fax/);
-  });
-
-  it("treats a stub without the pdf.js API as missing, for the rest of the session", async () => {
-    // What a bundler told to ignore the uninstalled peer hands back.
-    pdfjsImport = () => ({ default: {}, getDocument: undefined });
-    const { loadPdfjs, isMissingPdfjsError } = await loadModule();
-    const first = await loadPdfjs().catch((error: unknown) => error);
-    expect(isMissingPdfjsError(first)).toBe(true);
-    expect((first as Error).message).toMatch(/Install pdfjs-dist/);
-
-    pdfjsImport = installedPdfjs;
-    expect(await loadPdfjs().catch((error: unknown) => error)).toBe(first);
-  });
-
-  it("tries again after a failure that is not a missing package", async () => {
-    let attempts = 0;
-    pdfjsImport = () => {
-      attempts += 1;
-      if (attempts === 1) throw new Error("Failed to fetch dynamically imported module");
-      return installedPdfjs();
-    };
-    const { loadPdfjs, isMissingPdfjsError } = await loadModule();
-    const failure = await loadPdfjs().catch((error: unknown) => error);
-    expect(isMissingPdfjsError(failure)).toBe(false);
-    await expect(loadPdfjs()).resolves.toHaveProperty("getDocument");
-  });
-});
-
-describe("asMissingPdfjsError", () => {
-  it("names pdfjs-dist only for a resolution failure about it", async () => {
-    const { asMissingPdfjsError, isMissingPdfjsError } = await loadModule();
-    for (const message of [
-      `Failed to resolve import "${PDFJS}". Does the file exist?`,
-      `Could not resolve "pdfjs-dist/legacy/build/pdf.mjs"`,
-      "Cannot find module 'pdfjs-dist/legacy/build/pdf.mjs'",
-    ]) {
-      expect(isMissingPdfjsError(asMissingPdfjsError(new Error(message))), message).toBe(true);
-    }
-    const chunk = new Error("Failed to fetch dynamically imported module");
-    expect(asMissingPdfjsError(chunk)).toBe(chunk);
-    const other = new Error('Could not resolve "./chunk-abc.js"');
-    expect(asMissingPdfjsError(other)).toBe(other);
-  });
-});
-
-describe("pdfAssetParams", () => {
-  it("asks for nothing until assetsUrl is configured", async () => {
-    const { pdfAssetParams } = await loadModule();
-    expect(pdfAssetParams()).toEqual({});
-  });
-
-  it("points every asset directory under an absolute assetsUrl", async () => {
-    const { configurePdfViewer, pdfAssetParams } = await loadModule();
-    configurePdfViewer({ assetsUrl: "/static/pdfjs" });
-    const base = new URL("/static/pdfjs/", document.baseURI).href;
-    expect(pdfAssetParams()).toEqual({
-      wasmUrl: `${base}wasm/`,
-      cMapUrl: `${base}cmaps/`,
-      cMapPacked: true,
-      standardFontDataUrl: `${base}standard_fonts/`,
-      iccUrl: `${base}iccs/`,
-    });
-  });
-});

package/src/files/pdf-viewer.test.tsx

@@ -1,245 +0,0 @@
-import { act, fireEvent, render, screen, waitFor } from "@testing-library/react";
-import { afterEach, beforeEach, describe, expect, it, vi } from "vitest";
-import { MissingPdfjsError, loadPdfjs, type PdfjsLib } from "./pdf-loader";
-import { PdfViewer } from "./pdf-viewer";
-
-vi.mock("./pdf-loader", async (importOriginal) => ({
-  ...(await importOriginal<typeof import("./pdf-loader")>()),
-  loadPdfjs: vi.fn(),
-}));
-
-const BLOB_URL = "blob:https://app.tangle.tools/9a8b7c";
-/** US Letter in points. */
-const LETTER = { width: 612, height: 792 };
-const CSS_PER_POINT = 96 / 72;
-
-/** A pdf.js stand-in: pages of US Letter that render at once. */
-function fakePdfjs({ numPages = 3, fail }: { numPages?: number; fail?: Error } = {}) {
-  const render = vi.fn(() => ({ promise: Promise.resolve(), cancel: vi.fn() }));
-  const page = {
-    getViewport: ({ scale }: { scale: number }) => ({
-      width: LETTER.width * scale,
-      height: LETTER.height * scale,
-    }),
-    render,
-    cleanup: vi.fn(),
-  };
-  const doc = { numPages, getPage: vi.fn(async () => page) };
-  const destroy = vi.fn(async () => {});
-  const getDocument = vi.fn(() => ({
-    promise: fail ? Promise.reject(fail) : Promise.resolve(doc),
-    destroy,
-    onProgress: undefined,
-  }));
-  const pdfjs = { getDocument } as unknown as PdfjsLib;
-  return { pdfjs, getDocument, destroy, render };
-}
-
-function namedError(name: string, extra: Record<string, unknown> = {}): Error {
-  return Object.assign(new Error(name), { name }, extra);
-}
-
-const pageInput = () => screen.getByRole("textbox", { name: /^Page/ });
-
-let consoleError: ReturnType<typeof vi.spyOn>;
-let consoleWarn: ReturnType<typeof vi.spyOn>;
-const realFetch = globalThis.fetch;
-
-beforeEach(() => {
-  consoleError = vi.spyOn(console, "error").mockImplementation(() => {});
-  consoleWarn = vi.spyOn(console, "warn").mockImplementation(() => {});
-  // Node cannot read a browser's object URLs; serve the test's as a PDF header.
-  vi.stubGlobal("fetch", (input: RequestInfo | URL, init?: RequestInit) =>
-    String(input).startsWith("blob:")
-      ? Promise.resolve(new Response("%PDF-"))
-      : realFetch(input, init),
-  );
-});
-
-afterEach(() => {
-  consoleError.mockRestore();
-  consoleWarn.mockRestore();
-  vi.unstubAllGlobals();
-  vi.mocked(loadPdfjs).mockReset();
-});
-
-describe("PdfViewer", () => {
-  it("renders every page of the document to a canvas", async () => {
-    const fake = fakePdfjs({ numPages: 3 });
-    vi.mocked(loadPdfjs).mockResolvedValue(fake.pdfjs);
-
-    const { container } = render(<PdfViewer src={BLOB_URL} filename="lease.pdf" />);
-
-    expect(screen.getByRole("status")).toHaveTextContent("Loading lease.pdf");
-    expect(await screen.findByRole("img", { name: "Page 3 of 3" })).toBeInTheDocument();
-    expect(screen.getByRole("region", { name: "lease.pdf" })).toBeInTheDocument();
-    expect(pageInput()).toHaveValue("1");
-    expect(screen.getByText("/ 3")).toBeInTheDocument();
-    await waitFor(() => expect(container.querySelectorAll("canvas")).toHaveLength(3));
-    expect(fake.render).toHaveBeenCalledWith(
-      expect.objectContaining({ canvas: expect.any(HTMLCanvasElement) }),
-    );
-  });
-
-  it("streams an http(s) URL and reads other URLs as bytes", async () => {
-    const fake = fakePdfjs();
-    vi.mocked(loadPdfjs).mockResolvedValue(fake.pdfjs);
-
-    const remote = render(<PdfViewer src="https://files.example/brief.pdf" />);
-    await screen.findByRole("img", { name: "Page 1 of 3" });
-    expect(fake.getDocument).toHaveBeenLastCalledWith({ url: "https://files.example/brief.pdf" });
-    remote.unmount();
-
-    render(<PdfViewer src="data:application/pdf;base64,JVBERi0=" />);
-    await screen.findByRole("img", { name: "Page 1 of 3" });
-    const [params] = fake.getDocument.mock.lastCall as unknown as [{ data: Uint8Array }];
-    expect(new TextDecoder().decode(params.data)).toBe("%PDF-");
-  });
-
-  it("moves between pages with the buttons and the page field", async () => {
-    vi.mocked(loadPdfjs).mockResolvedValue(fakePdfjs({ numPages: 3 }).pdfjs);
-    render(<PdfViewer src={BLOB_URL} filename="lease.pdf" />);
-    await screen.findByRole("img", { name: "Page 3 of 3" });
-
-    const previous = screen.getByRole("button", { name: "Previous page" });
-    const next = screen.getByRole("button", { name: "Next page" });
-    expect(previous).toBeDisabled();
-
-    fireEvent.click(next);
-    expect(pageInput()).toHaveValue("2");
-    expect(previous).toBeEnabled();
-
-    fireEvent.change(pageInput(), { target: { value: "9" } });
-    fireEvent.keyDown(pageInput(), { key: "Enter" });
-    expect(pageInput()).toHaveValue("3");
-    expect(next).toBeDisabled();
-
-    fireEvent.change(pageInput(), { target: { value: "1x" } });
-    expect(pageInput()).toHaveValue("1");
-    fireEvent.keyDown(pageInput(), { key: "Escape" });
-    expect(pageInput()).toHaveValue("3");
-  });
-
-  it("zooms in steps and returns to fit-to-width", async () => {
-    vi.mocked(loadPdfjs).mockResolvedValue(fakePdfjs({ numPages: 1 }).pdfjs);
-    render(<PdfViewer src={BLOB_URL} filename="lease.pdf" />);
-    const page = await screen.findByRole("img", { name: "Page 1 of 1" });
-
-    // jsdom lays nothing out, so the fitted width falls back to 100%.
-    const fit = screen.getByRole("button", { name: "100%, fit to width" });
-    expect(fit).toHaveAttribute("aria-pressed", "true");
-
-    fireEvent.click(screen.getByRole("button", { name: "Zoom in" }));
-    const zoomed = screen.getByRole("button", { name: "125%, fit to width" });
-    expect(zoomed).toHaveAttribute("aria-pressed", "false");
-    await waitFor(() =>
-      expect(page.style.width).toBe(`${Math.round(LETTER.width * CSS_PER_POINT * 1.25)}px`),
-    );
-
-    fireEvent.click(screen.getByRole("button", { name: "Zoom out" }));
-    fireEvent.click(screen.getByRole("button", { name: "Zoom out" }));
-    expect(screen.getByRole("button", { name: "75%, fit to width" })).toBeInTheDocument();
-
-    fireEvent.click(screen.getByRole("button", { name: "75%, fit to width" }));
-    expect(screen.getByRole("button", { name: "100%, fit to width" })).toHaveAttribute(
-      "aria-pressed",
-      "true",
-    );
-  });
-
-  it("fits the first page to the width of the pane", async () => {
-    const width = vi
-      .spyOn(HTMLElement.prototype, "clientWidth", "get")
-      .mockReturnValue(600);
-    try {
-      vi.mocked(loadPdfjs).mockResolvedValue(fakePdfjs({ numPages: 1 }).pdfjs);
-      render(<PdfViewer src={BLOB_URL} />);
-      const page = await screen.findByRole("img", { name: "Page 1 of 1" });
-      // 600px less the column's 12px padding on each side.
-      await waitFor(() => expect(page.style.width).toBe("576px"));
-      const percent = Math.round((576 / (LETTER.width * CSS_PER_POINT)) * 100);
-      expect(screen.getByRole("button", { name: `${percent}%, fit to width` })).toHaveAttribute(
-        "aria-pressed",
-        "true",
-      );
-    } finally {
-      width.mockRestore();
-    }
-  });
-
-  it("offers Download in the toolbar only when the host handles it", async () => {
-    vi.mocked(loadPdfjs).mockResolvedValue(fakePdfjs().pdfjs);
-    const onDownload = vi.fn();
-    const { rerender } = render(<PdfViewer src={BLOB_URL} filename="lease.pdf" />);
-    await screen.findByRole("img", { name: "Page 1 of 3" });
-    expect(screen.queryByRole("button", { name: "Download lease.pdf" })).toBeNull();
-
-    rerender(<PdfViewer src={BLOB_URL} filename="lease.pdf" onDownload={onDownload} />);
-    fireEvent.click(screen.getByRole("button", { name: "Download lease.pdf" }));
-    expect(onDownload).toHaveBeenCalledTimes(1);
-  });
-
-  it("says so and falls back to the browser's viewer when pdfjs-dist is missing", async () => {
-    vi.mocked(loadPdfjs).mockRejectedValue(new MissingPdfjsError());
-    const onDownload = vi.fn();
-    const { container } = render(
-      <PdfViewer src={BLOB_URL} filename="lease.pdf" size={2048} onDownload={onDownload} />,
-    );
-
-    expect(
-      await screen.findByText(/does not include the page viewer/),
-    ).toBeInTheDocument();
-    const object = container.querySelector("object");
-    expect(object).toHaveAttribute("data", BLOB_URL);
-    expect(object).toHaveAttribute("type", "application/pdf");
-    expect(screen.getByText("This browser does not show PDFs inline.")).toBeInTheDocument();
-    expect(screen.getByText("2.0 KB")).toBeInTheDocument();
-    fireEvent.click(screen.getByRole("button", { name: "Download" }));
-    expect(onDownload).toHaveBeenCalledTimes(1);
-    // A missing package will not appear on a retry.
-    expect(screen.queryByRole("button", { name: "Try again" })).toBeNull();
-    expect(consoleError).toHaveBeenCalledWith(
-      expect.stringContaining("falling back"),
-      expect.any(MissingPdfjsError),
-    );
-  });
-
-  it.each([
-    ["PasswordException", {}, /password-protected/, false],
-    ["InvalidPDFException", {}, /could not be read as a PDF/, false],
-    ["ResponseException", { status: 404 }, /could not be downloaded \(HTTP 404\)/, true],
-    ["UnknownErrorException", {}, /could not open this PDF/, true],
-  ])("explains a %s and offers a retry only when one can help", async (name, extra, notice, retry) => {
-    vi.mocked(loadPdfjs).mockResolvedValue(fakePdfjs({ fail: namedError(name, extra) }).pdfjs);
-    render(<PdfViewer src={BLOB_URL} />);
-    expect(await screen.findByText(notice)).toBeInTheDocument();
-    expect(Boolean(screen.queryByRole("button", { name: "Try again" }))).toBe(retry);
-  });
-
-  it("loads the document again on Try again", async () => {
-    const failing = fakePdfjs({ fail: namedError("UnknownErrorException") });
-    const working = fakePdfjs({ numPages: 2 });
-    vi.mocked(loadPdfjs)
-      .mockResolvedValueOnce(failing.pdfjs)
-      .mockResolvedValueOnce(working.pdfjs);
-    render(<PdfViewer src={BLOB_URL} />);
-
-    fireEvent.click(await screen.findByRole("button", { name: "Try again" }));
-    expect(await screen.findByRole("img", { name: "Page 2 of 2" })).toBeInTheDocument();
-  });
-
-  it("destroys the loading task when it unmounts or the source changes", async () => {
-    const fake = fakePdfjs();
-    vi.mocked(loadPdfjs).mockResolvedValue(fake.pdfjs);
-    const { rerender, unmount } = render(<PdfViewer src={BLOB_URL} />);
-    await screen.findByRole("img", { name: "Page 1 of 3" });
-
-    rerender(<PdfViewer src="blob:https://app.tangle.tools/other" />);
-    expect(fake.destroy).toHaveBeenCalledTimes(1);
-    await screen.findByRole("img", { name: "Page 1 of 3" });
-
-    unmount();
-    await act(async () => {});
-    expect(fake.destroy).toHaveBeenCalledTimes(2);
-  });
-});

package/src/files/rich-file-tree.test.tsx

@@ -1,90 +0,0 @@
-import { describe, it, expect, vi } from "vitest"
-import { fireEvent, render, waitFor } from "@testing-library/react"
-import { RichFileTree } from "./rich-file-tree"
-
-function treeRow(container: HTMLElement, path: string): HTMLElement {
-  const host = container.querySelector("file-tree-container");
-  const row = Array.from(host?.shadowRoot?.querySelectorAll("[data-item-path]") ?? [])
-    .find((element) => element.getAttribute("data-item-path") === path);
-  if (!(row instanceof HTMLElement)) throw new Error(`Missing tree row: ${path}`);
-  return row;
-}
-
-describe("RichFileTree", () => {
-  it("renders without crashing given a flat path list", () => {
-    const { container } = render(
-      <RichFileTree paths={["README.md", "src/index.ts"]} />,
-    )
-    // Pierre renders into a custom element / shadow root; we can't peek
-    // inside shadow DOM from RTL, but we can confirm the host mounted.
-    expect(container.querySelectorAll("*").length).toBeGreaterThan(0)
-  })
-
-  it("flattens a recursive FileNode tree to paths", () => {
-    const { container } = render(
-      <RichFileTree
-        root={{
-          name: "root",
-          path: "",
-          type: "directory",
-          children: [
-            { name: "a.md", path: "a.md", type: "file" },
-            {
-              name: "b",
-              path: "b",
-              type: "directory",
-              children: [{ name: "c.md", path: "b/c.md", type: "file" }],
-            },
-          ],
-        }}
-      />,
-    )
-    expect(container.querySelectorAll("*").length).toBeGreaterThan(0)
-  })
-
-  it("calls the current selection callback after its owner rerenders", async () => {
-    const original = vi.fn();
-    const current = vi.fn();
-    const paths = ["brief.md", "outreach.md"];
-    const { container, rerender } = render(<RichFileTree paths={paths} onSelect={original} />);
-    rerender(<RichFileTree paths={paths} onSelect={current} />);
-    fireEvent.click(treeRow(container, "outreach.md"));
-    await waitFor(() => expect(current).toHaveBeenCalledWith("outreach.md"));
-    expect(original).not.toHaveBeenCalled();
-  });
-
-  it("clears controlled selection so a closed file can be selected again", async () => {
-    const onSelect = vi.fn();
-    const paths = ["brief.md", "outreach.md"];
-    const { container, rerender } = render(
-      <RichFileTree paths={paths} selectedPath="brief.md" onSelect={onSelect} />,
-    );
-    rerender(<RichFileTree paths={paths} selectedPath={undefined} onSelect={onSelect} />);
-    await waitFor(() => expect(treeRow(container, "brief.md")).toHaveAttribute("aria-selected", "false"));
-    fireEvent.click(treeRow(container, "brief.md"));
-    await waitFor(() => expect(onSelect).toHaveBeenCalledExactlyOnceWith("brief.md"));
-  });
-
-  it("preserves uncontrolled selection when the file listing refreshes", async () => {
-    const { container, rerender } = render(<RichFileTree paths={["brief.md"]} />);
-    fireEvent.click(treeRow(container, "brief.md"));
-    await waitFor(() => expect(treeRow(container, "brief.md")).toHaveAttribute("aria-selected", "true"));
-    rerender(<RichFileTree paths={["brief.md", "outreach.md"]} />);
-    await waitFor(() => expect(treeRow(container, "brief.md")).toHaveAttribute("aria-selected", "true"));
-  });
-
-  it("does not notify the owner when a controlled selection is synchronized", async () => {
-    const onSelect = vi.fn();
-    const paths = ["brief.md", "outreach.md"];
-    const { container, rerender } = render(<RichFileTree paths={paths} selectedPath="brief.md" onSelect={onSelect} />);
-    rerender(<RichFileTree paths={paths} selectedPath="outreach.md" onSelect={onSelect} />);
-    await waitFor(() => expect(treeRow(container, "outreach.md")).toHaveAttribute("aria-selected", "true"));
-    expect(onSelect).not.toHaveBeenCalled();
-  });
-
-  it("throws when both root and paths are passed", () => {
-    expect(() =>
-      render(<RichFileTree root={{ name: "x", path: "x", type: "file" }} paths={["y"]} />),
-    ).toThrow(/root.*paths.*not both/i)
-  })
-})

package/src/markdown/api-presentation.test.tsx

@@ -1,63 +0,0 @@
-import { fireEvent,render,screen } from "@testing-library/react";
-import { describe,it,expect,vi } from "vitest";
-import { CodeBlock } from "./code-block";
-import { ApiSchema } from "./api-schema";
-import { bindCopyButton,createCopyFeedback,highlightCode } from "../code-presentation";
-describe("shared API presentation",()=>{
- it("renders field paths without turning schema text into HTML",()=>{
-  render(<ApiSchema fields={[{name:"messages",type:"array",children:[{name:"content",type:"string",description:"<script>bad()</script>"}]}]}/>);
-  expect(screen.getByText("messages.content")).toBeInTheDocument();expect(document.querySelector("script")).toBeNull();
- });
- it("keeps stale clipboard completions and disposed feedback silent",async()=>{
-  const updates=vi.fn();let complete!:()=>void;const feedback=createCopyFeedback(updates,()=>new Promise<void>(resolve=>{complete=resolve;}));
-  const pending=feedback.copy("bytes");feedback.dispose();complete();await pending;expect(updates).toHaveBeenCalledTimes(1);
- });
- it("blocks duplicate writes until the accepted operation settles",async()=>{
-  const updates=vi.fn();let complete!:()=>void;
-  const write=vi.fn(()=>new Promise<void>(resolve=>{complete=resolve;}));
-  const feedback=createCopyFeedback(updates,write);
-  const first=feedback.copy("first");await feedback.copy("duplicate");
-  expect(write.mock.calls).toEqual([["first"]]);
-  expect(updates).toHaveBeenLastCalledWith(expect.objectContaining({copied:false,status:"Copying to clipboard",pending:true}));
-  complete();await first;
-  expect(updates).toHaveBeenLastCalledWith(expect.objectContaining({copied:true,status:"Copied to clipboard",pending:false}));
-  const next=feedback.copy("next");expect(write).toHaveBeenCalledTimes(2);complete();await next;
-  feedback.dispose();await feedback.copy("disposed");expect(write).toHaveBeenCalledTimes(2);
- });
- it("retains exact newlines and plain binary/SSE text",async()=>{
-  const text='data: {"delta":"<x>"}\n\ndata: [DONE]\n';const lines=await highlightCode(text,"text");expect(lines.map(line=>line.map(t=>t.content).join("")).join("\n")).toBe(text);
- });
-});
-
-describe("copy binding cleanup",()=>{
- it.each(["pending","success","failure"])("restores retained DOM after %s",async phase=>{
-  const descriptor=Object.getOwnPropertyDescriptor(navigator,"clipboard");
-  let resolve!:()=>void,reject!:(error:Error)=>void;
-  const writeText=vi.fn(()=>new Promise<void>((yes,no)=>{resolve=yes;reject=no;}));
-  Object.defineProperty(navigator,"clipboard",{configurable:true,value:{writeText}});
-  const button=document.createElement("button"),status=document.createElement("span");
-  button.setAttribute("aria-label","Copy request");status.textContent="Ready";
-  const cleanup=bindCopyButton(button,status,()=>"exact bytes");
-  try {
-   button.click();expect(button.getAttribute("aria-label")).toBe("Copying to clipboard");
-   if(phase!=="pending"){
-    if(phase==="failure")reject(new Error("Denied"));else resolve();
-    await vi.waitFor(()=>expect(button.getAttribute("aria-label")).toBe(phase==="failure"?"Copy to clipboard":"Copied"));
-   }
-   cleanup();
-   expect(button.getAttribute("aria-label")).toBe("Copy request");expect(status.textContent).toBe("Ready");
-   resolve();await Promise.resolve();await Promise.resolve();
-   expect(button.getAttribute("aria-label")).toBe("Copy request");expect(status.textContent).toBe("Ready");
-  }finally{
-   cleanup();if(descriptor)Object.defineProperty(navigator,"clipboard",descriptor);else delete (navigator as {clipboard?:unknown}).clipboard;
-  }
- });
- it("restores an originally absent accessible label",()=>{
-  const button=document.createElement("button"),status=document.createElement("span");
-  const cleanup=bindCopyButton(button,status,()=>"bytes");button.setAttribute("aria-label","Copied");cleanup();expect(button.hasAttribute("aria-label")).toBe(false);
- });
- it("gives a single code example no orphaned tab relationship",()=>{
-  const {container,unmount}=render(<CodeBlock code="fallback" examples={[{label:"Plain",language:"text",code:"one"}]}/>);
-  try {expect(container.querySelector('[role="tab"]')).toBeNull();expect(container.querySelector('[role="tabpanel"]')).toBeNull();expect(container.querySelector('[aria-labelledby]')).toBeNull();expect(container.querySelector("pre")?.textContent).toBe("one");}finally{unmount();}
- });
-});