@tangle-network/ui 11.51.7 → 11.51.8

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();}
- });
-});

package/src/markdown/code-block.test.tsx

@@ -1,201 +0,0 @@
-import { cleanup, fireEvent, render, screen, waitFor } from "@testing-library/react";
-import { renderToString } from "react-dom/server";
-import { afterEach, describe, expect, it, vi } from "vitest";
-import { CodeBlock, CopyButton } from "./code-block";
-
-const originalClipboard = Object.getOwnPropertyDescriptor(navigator, "clipboard");
-
-afterEach(() => {
-  cleanup();
-  vi.restoreAllMocks();
-  if (originalClipboard) Object.defineProperty(navigator, "clipboard", originalClipboard);
-  else delete (navigator as { clipboard?: unknown }).clipboard;
-});
-
-describe("CodeBlock scoped semantic colors", () => {
-  it("keeps code readable before the renderer loads, then applies live semantic colors and line numbers", async () => {
-    // Shiki stops tokenizing a line after 500ms and paints the rest in the last
-    // token's color. The first pass over a cold grammar also compiles its
-    // patterns, which on a loaded host can take longer than that. Warm the
-    // grammar first: this test checks the color mapping, not cold-start time.
-    const warm = render(<CodeBlock code={'const message = "hello";'} language="javascript" />);
-    await waitFor(() => expect(warm.container.querySelector("[data-highlighted]")).not.toBeNull(), { timeout: 10_000 });
-    warm.unmount();
-    const { container } = render(<CodeBlock code={'const message = "hello";'} language="javascript" showLineNumbers />);
-    // Plain code already carries its line numbers, so highlighting shifts no layout.
-    expect(container.querySelector("pre code")?.textContent?.replace(/^1/, "")).toBe('const message = "hello";');
-    // The highlighter loads asynchronously; under a full parallel run it can take longer than waitFor's 1s default.
-    await waitFor(() => expect(container.innerHTML).toContain("var(--syntax-keyword, currentColor)"), { timeout: 10_000 });
-    expect(container.innerHTML).toContain("var(--syntax-string, currentColor)");
-    expect(container.innerHTML).toContain("var(--syntax-comment, currentColor)");
-    expect(container.querySelector("[data-line-number]")).not.toBeNull();
-    expect(container.querySelector("pre code")?.textContent?.replace(/^1/, "")).toBe('const message = "hello";');
-  });
-
-  it("inherits a named scope by default without inserting its own mode", () => {
-    const { container } = render(<section data-theme="arena-light"><CodeBlock data-testid="code" code="const x = 1" language="javascript" /></section>);
-    const code = screen.getByTestId("code");
-    expect(code.hasAttribute("data-theme")).toBe(false);
-    const before = code.innerHTML;
-    container.querySelector("section")!.setAttribute("data-theme", "arena");
-    expect(code.innerHTML).toBe(before); // References stay live; the browser fixture checks the computed colors.
-  });
-
-  it.each([true, false])("preserves explicit light=%s as an opposite nested mode", (light) => {
-    render(<section data-theme={light ? "dark" : "light"}><CodeBlock data-testid="code" code="x" light={light} /></section>);
-    expect(screen.getByTestId("code").getAttribute("data-theme")).toBe(light ? "light" : "dark");
-  });
-
-  it("preserves caller attributes, labels, children and custom scopes", () => {
-    render(<CodeBlock data-testid="code" data-theme="aubergine" className="caller" code="echo hello" language="bash" label="BASHRC"><button>Copy example</button></CodeBlock>);
-    expect(screen.getByTestId("code").getAttribute("data-theme")).toBe("aubergine");
-    expect(screen.getByTestId("code").classList.contains("caller")).toBe(true);
-    expect(screen.getByText("BASHRC")).toBeTruthy();
-    expect(screen.getByRole("button", { name: "Copy example" })).toBeTruthy();
-  });
-
-  it("server-renders readable code with the same semantic references independent of document theme", () => {
-    const source = <CodeBlock code="const x = 1" language="javascript" />;
-    document.documentElement.className = "dark";
-    const dark = renderToString(source);
-    expect(dark).toContain("const x = 1");
-    expect(dark).toContain("var(--syntax-foreground, currentColor)");
-    document.documentElement.className = "light";
-    expect(renderToString(source)).toBe(dark);
-    document.documentElement.removeAttribute("class");
-  });
-});
-
-// Retain the existing header/label/copy-slot contracts alongside theme coverage.
-describe("CodeBlock", () => {
-  it("renders the code through the syntax highlighter", () => {
-    const { container } = render(<CodeBlock code={"const x = 1;"} language="typescript" />);
-    expect(container.querySelector("code")).not.toBeNull();
-  });
-
-  it.each(["javascript", "js", "ts", "tsx"])("highlights %s with Shiki into Brand syntax tokens", async (language) => {
-    const code = "const answer = 42; // the answer";
-    const { container } = render(<CodeBlock code={code} language={language} />);
-    await waitFor(() => expect(container.querySelector("[data-highlighted]")).not.toBeNull(), { timeout: 10_000 });
-    const tokens = Array.from(container.querySelectorAll("pre code span span"));
-    expect(tokens.length).toBeGreaterThan(3);
-    expect(container.innerHTML).toContain("var(--syntax-keyword, currentColor)");
-    expect(container.innerHTML).toContain("var(--syntax-comment, currentColor)");
-    expect(container.innerHTML).not.toContain("--shiki-");
-    expect(container.querySelector("pre code")?.textContent).toBe(code);
-  });
-
-  it.each(["brainfuck", "not-a-language", undefined])("keeps %s as readable plain text", (language) => {
-    const code = "++[>+++<-]";
-    const { container } = render(<CodeBlock code={code} language={language} />);
-    expect(container.querySelector("[data-highlighted]")).toBeNull();
-    expect(container.querySelector("pre code")?.textContent).toBe(code);
-  });
-
-  it("preserves whitespace and numbers every line", async () => {
-    const code = "\tfirst  \n  second\n";
-    const { container } = render(<CodeBlock code={code} language="text" showLineNumbers />);
-    const numbers = Array.from(container.querySelectorAll("[data-line-number]"), (node) => node.textContent);
-    expect(numbers).toEqual(["1", "2", "3"]);
-    const text = Array.from(container.querySelectorAll("pre code > span"), (line) =>
-      Array.from(line.childNodes).filter((node) => !(node instanceof HTMLElement && node.hasAttribute("data-line-number")))
-        .map((node) => node.textContent).join("")).join("");
-    expect(text).toBe(code);
-  });
-
-  it("names the file in the header beside the language", () => {
-    render(<CodeBlock code={"export {}"} language="ts" filename="src/lib/ctr.ts" />);
-    expect(screen.getByText("src/lib/ctr.ts")).toBeInTheDocument();
-    expect(screen.getByText("TypeScript")).toBeInTheDocument();
-    expect(screen.getByRole("region", { name: "src/lib/ctr.ts code" })).toBeInTheDocument();
-  });
-
-  it("uses `label` as the header text, overriding `language`", () => {
-    const { getByText, queryByText } = render(
-      <CodeBlock code={"x"} language="typescript" label="config.ts" />,
-    );
-    expect(getByText("config.ts")).toBeInTheDocument();
-    expect(queryByText("typescript")).toBeNull();
-  });
-
-  it("falls back to the language's name for the header when no `label` is given", () => {
-    const { getByText } = render(<CodeBlock code={"x"} language="python" />);
-    expect(getByText("Python")).toBeInTheDocument();
-  });
-
-  it.each(["text", "TXT", "plain", "plaintext"])("shows no %s label on a plain-text fence, only its copy control", (language) => {
-    const { container, queryByText } = render(
-      <CodeBlock code={"x"} language={language}>
-        <CopyButton text="x" />
-      </CodeBlock>,
-    );
-    expect(container.querySelector(".border-b")).toBeNull();
-    expect(queryByText(language)).toBeNull();
-    expect(container.querySelector('button[title="Copy to clipboard"]')).not.toBeNull();
-  });
-
-  it("renders no header when neither label nor language is set", () => {
-    const { container } = render(<CodeBlock code={"x"} />);
-    // The header is the only element carrying a bottom border.
-    expect(container.querySelector(".border-b")).toBeNull();
-  });
-
-  it("treats an explicit empty label as 'no header', even with a language", () => {
-    const { container, queryByText } = render(
-      <CodeBlock code={"x"} language="python" label="" />,
-    );
-    expect(container.querySelector(".border-b")).toBeNull();
-    expect(queryByText("python")).toBeNull();
-  });
-
-  it("places children in the header when a header is shown", () => {
-    const { container } = render(
-      <CodeBlock code={"x"} label="run.ts">
-        <CopyButton text="x" />
-      </CodeBlock>,
-    );
-    const copyButton = container.querySelector('button[title="Copy to clipboard"]');
-    expect(copyButton).not.toBeNull();
-    // Inside the bordered header, not the absolute hover overlay.
-    expect(copyButton?.closest(".border-b")).not.toBeNull();
-    expect(copyButton?.closest(".absolute")).toBeNull();
-  });
-
-  it("moves children to a hover overlay when no header is shown", () => {
-    const { container } = render(
-      <CodeBlock code={"x"}>
-        <CopyButton text="x" />
-      </CodeBlock>,
-    );
-    const copyButton = container.querySelector('button[title="Copy to clipboard"]');
-    expect(copyButton).not.toBeNull();
-    expect(copyButton?.closest(".absolute")).not.toBeNull();
-    expect(copyButton?.closest(".border-b")).toBeNull();
-  });
-
-  it("names the copy button, keeps it out of forms, and announces the copy", async () => {
-    const writeText = vi.fn().mockResolvedValue(undefined);
-    Object.defineProperty(navigator, "clipboard", { value: { writeText }, configurable: true });
-    render(<CopyButton text="secret" />);
-    const button = screen.getByRole("button", { name: "Copy to clipboard" });
-    expect(button.getAttribute("type")).toBe("button");
-    const status = screen.getByRole("status");
-    expect(status.getAttribute("aria-live")).toBe("polite");
-    expect(status.textContent).toBe("");
-    fireEvent.click(button);
-    await waitFor(() => expect(status.textContent).toBe("Copied to clipboard"));
-    expect(writeText).toHaveBeenCalledWith("secret");
-    expect(screen.getByRole("button", { name: "Copied" })).toBeTruthy();
-  });
-
-  it("announces a failed copy", async () => {
-    const writeText = vi.fn().mockRejectedValue(new Error("denied"));
-    Object.defineProperty(navigator, "clipboard", { value: { writeText }, configurable: true });
-    const warn = vi.spyOn(console, "warn").mockImplementation(() => {});
-    render(<CopyButton text="secret" />);
-    fireEvent.click(screen.getByRole("button", { name: "Copy to clipboard" }));
-    await waitFor(() => expect(screen.getByRole("status").textContent).toBe("Copy failed"));
-    expect(screen.getByRole("button", { name: "Copy to clipboard" })).toBeTruthy();
-    warn.mockRestore();
-  });
-});