@tangle-network/ui 11.51.7 → 11.51.9

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

package/src/markdown/markdown-table.test.tsx

@@ -1,76 +0,0 @@
-import { cleanup, fireEvent, render, screen, waitFor, within } from "@testing-library/react";
-import { afterEach, describe, expect, it, vi } from "vitest";
-import { Markdown } from "./markdown";
-import { columnKinds, numericColumns, tableCsv } from "./markdown-table";
-
-const TABLE = [
-  "| Variant | Impressions | CTR % | Spend $ | Note |",
-  "| --- | --- | --- | --- | --- |",
-  "| Hero A | 12,400 | 2.50% | $182.40 | Wins on \"reach\", barely |",
-  "| Hero B | 9,870 | 4.17% | $160.05 | =SUM(A1) |",
-].join("\n");
-
-afterEach(() => {
-  cleanup();
-  vi.restoreAllMocks();
-});
-
-describe("Markdown tables", () => {
-  it("renders a header row and right-aligns figures in tabular numerals", () => {
-    render(<Markdown>{TABLE}</Markdown>);
-    const table = screen.getByRole("table");
-    const headers = within(table).getAllByRole("columnheader");
-    expect(headers.map((header) => header.textContent)).toEqual(["Variant", "Impressions", "CTR %", "Spend $", "Note"]);
-    expect(headers[0].className).toContain("text-left");
-    expect(headers[1].className).toContain("text-right");
-    // Inside `.tangle-prose`, a vendored header rule cannot left-align a figure column.
-    expect(headers[1].className).toContain("[.tangle-prose_&]:text-right!");
-    const cells = within(table).getAllByRole("cell");
-    expect(cells[1].className).toContain("text-right");
-    expect(cells[1].className).toContain("tabular-nums");
-    expect(cells[0].className).not.toContain("text-right");
-    expect(cells[0].className).toContain("whitespace-nowrap");
-    expect(cells[4].className).not.toContain("tabular-nums");
-  });
-
-  it("scrolls inside a named, focusable region and never uses a tiny font", () => {
-    render(<Markdown>{TABLE}</Markdown>);
-    const region = screen.getByRole("region", { name: "Table" });
-    expect(region.className).toContain("overflow-x-auto");
-    expect(region.getAttribute("tabindex")).toBe("0");
-    expect(region.closest(".not-prose")).not.toBeNull();
-    expect(screen.getByRole("table").className).toContain("text-sm");
-    // Brand's raw-table prose rules skip the card, so the table never becomes its own scroller.
-    expect(screen.getByRole("table").hasAttribute("data-markdown-table")).toBe(true);
-    expect(document.body.innerHTML).not.toContain("text-xs");
-  });
-
-  it("contains its screen-reader status line, so a table deep in a scrolling panel cannot stretch the page", () => {
-    render(<Markdown>{TABLE}</Markdown>);
-    const status = screen.getByRole("status");
-    expect(status.className).toContain("sr-only");
-    // The status is absolutely positioned; the card it sits in must be its containing block.
-    const card = status.closest(".not-prose") as HTMLElement;
-    expect(card.className.split(" ")).toEqual(expect.arrayContaining(["relative", "overflow-hidden"]));
-  });
-
-  it("copies the table as CSV with quoting and formula-safe cells", async () => {
-    const writeText = vi.fn().mockResolvedValue(undefined);
-    Object.defineProperty(navigator, "clipboard", { value: { writeText }, configurable: true });
-    render(<Markdown>{TABLE}</Markdown>);
-    fireEvent.click(screen.getByRole("button", { name: "Copy CSV" }));
-    await waitFor(() => expect(writeText).toHaveBeenCalledTimes(1));
-    expect(writeText.mock.calls[0][0]).toBe([
-      "Variant,Impressions,CTR %,Spend $,Note",
-      "Hero A,\"12,400\",2.50%,$182.40,\"Wins on \"\"reach\"\", barely\"",
-      "Hero B,\"9,870\",4.17%,$160.05,'=SUM(A1)",
-    ].join("\n"));
-    expect(await screen.findByText("Table copied as CSV")).toBeInTheDocument();
-  });
-
-  it("treats a column as numeric only when every filled cell is a figure", () => {
-    expect(numericColumns([["a", "1", "", "$2.50"], ["b", "x", "3", "-4%"]])).toEqual([false, false, true, true]);
-    expect(columnKinds([["Hero A", "1", "A long note that wraps across more than one line"]])).toEqual(["short", "figure", "long"]);
-    expect(tableCsv([["a,b", " c"]])).toBe('"a,b"," c"');
-  });
-});

package/src/markdown/markdown.test.tsx

@@ -1,166 +0,0 @@
-import { describe, expect, it, vi } from "vitest";
-import { fireEvent, render, screen } from "@testing-library/react";
-import { getSanitizedMarkdownHeadingIdFromRawFragment, Markdown } from "./markdown";
-
-describe("Markdown", () => {
-  it("uses the tokenized Tangle prose class instead of host typography defaults", () => {
-    const { container } = render(<Markdown>{"# Heading\n\nBody with `code`."}</Markdown>);
-    const surface = container.firstElementChild;
-
-    expect(surface).toHaveClass("tangle-prose");
-    expect(surface).not.toHaveClass("prose");
-    expect(surface).not.toHaveClass("dark:prose-invert");
-  });
-
-  it("adds GitHub-style Unicode and duplicate heading IDs before sanitizing them", () => {
-    const { container } = render(
-      <Markdown>{"# Duplicate\n\n## Crème brûlée\n\n# Duplicate\n\n# user-content-heading"}</Markdown>,
-    );
-
-    expect(container.querySelectorAll("h1, h2")).toHaveLength(4);
-    expect(container.querySelector("h2")).toHaveAttribute("id", "user-content-crème-brûlée");
-    expect(container.querySelectorAll("h1")[0]).toHaveAttribute("id", "user-content-duplicate");
-    expect(container.querySelectorAll("h1")[1]).toHaveAttribute("id", "user-content-duplicate-1");
-    expect(container.querySelectorAll("h1")[2]).toHaveAttribute(
-      "id",
-      "user-content-user-content-heading",
-    );
-  });
-
-  it("maps raw fragments exactly once to the sanitized target prefix", () => {
-    expect(getSanitizedMarkdownHeadingIdFromRawFragment("Cr%C3%A8me%20br%C3%BBl%C3%A9e"))
-      .toBe("user-content-crème-brûlée");
-    expect(getSanitizedMarkdownHeadingIdFromRawFragment("user-content-heading"))
-      .toBe("user-content-user-content-heading");
-  });
-
-  it("maps same-document fragments to sanitized heading IDs", () => {
-    render(<Markdown>{"[Jump](#Cr%C3%A8me%20br%C3%BBl%C3%A9e)\n\n# Crème brûlée"}</Markdown>);
-
-    expect(screen.getByRole("link", { name: "Jump" })).toHaveAttribute(
-      "href",
-      "#user-content-crème-brûlée",
-    );
-  });
-
-  it("keeps custom URL transforms behind ReactMarkdown protocol checks", () => {
-    const urlTransform = vi.fn((url: string) => url);
-
-    render(
-      <Markdown urlTransform={urlTransform}>
-        {"[External](https://example.com/docs#install)\n\n![Safe](https://example.com/image.png)\n\n![Unsafe](javascript:alert(1))"}
-      </Markdown>,
-    );
-
-    expect(screen.getByRole("link", { name: "External" })).toHaveAttribute(
-      "href",
-      "https://example.com/docs#install",
-    );
-    expect(screen.getByRole("img", { name: "Safe" })).toHaveAttribute(
-      "src",
-      "https://example.com/image.png",
-    );
-    expect(screen.getByRole("img", { name: "Image unavailable: Unsafe" })).not.toHaveAttribute("src");
-    expect(urlTransform).toHaveBeenCalledWith(
-      "https://example.com/image.png",
-      "src",
-      expect.objectContaining({ tagName: "img" }),
-    );
-  });
-
-  it("keeps inline code on semantic tokens", () => {
-    const { container } = render(<Markdown>{"Use `token` values."}</Markdown>);
-    const inlineCode = container.querySelector("code");
-
-    expect(inlineCode).toHaveClass("border-border");
-    expect(inlineCode).toHaveClass("bg-muted");
-    expect(inlineCode).toHaveClass("text-foreground");
-  });
-
-  it("passes parsed URLs through the typed transform hook", () => {
-    const urlTransform = vi.fn((url: string, key: string) => (
-      key === "href" && url === "system/brief.md"
-        ? "/app/ws-1/vault?file=system%2Fbrief.md"
-        : url
-    ));
-
-    render(
-      <Markdown urlTransform={urlTransform}>
-        {'[Brief](system/brief.md)'}
-      </Markdown>,
-    );
-
-    expect(screen.getByRole("link", { name: "Brief" })).toHaveAttribute(
-      "href",
-      "/app/ws-1/vault?file=system%2Fbrief.md",
-    );
-    expect(urlTransform).toHaveBeenCalledWith(
-      "system/brief.md",
-      "href",
-      expect.objectContaining({ tagName: "a" }),
-    );
-  });
-
-  it("links an image to its full-size source unless a Markdown link already wraps it", () => {
-    render(
-      <Markdown>
-        {"![Ad](https://example.com/ad.png)\n\n[![Badge](https://example.com/badge.svg)](https://example.com/docs)"}
-      </Markdown>,
-    );
-
-    const ad = screen.getByRole("img", { name: "Ad" });
-    expect(ad).toHaveAttribute("src", "https://example.com/ad.png");
-    expect(ad.closest("a")).toHaveAttribute("href", "https://example.com/ad.png");
-    expect(ad.closest("a")).toHaveAttribute("target", "_blank");
-    expect(ad.closest("a")).toHaveAttribute("rel", "noopener noreferrer");
-
-    render(<Markdown>{"![](https://example.com/decorative.png)"}</Markdown>);
-    expect(screen.getByRole("link", { name: "Open image full size" })).toHaveAttribute(
-      "href",
-      "https://example.com/decorative.png",
-    );
-
-    const badge = screen.getByRole("img", { name: "Badge" });
-    expect(badge.closest("a")).toHaveAttribute("href", "https://example.com/docs");
-    expect(badge.closest("a")?.parentElement?.closest("a")).toBeNull();
-  });
-
-  it("replaces an image that fails to load with a labelled placeholder", () => {
-    render(<Markdown>{"![Final ad](campaigns/missing.png)"}</Markdown>);
-
-    fireEvent.error(screen.getByRole("img", { name: "Final ad" }));
-
-    expect(screen.queryByRole("img", { name: "Final ad" })).toBeNull();
-    expect(screen.getByRole("img", { name: "Image unavailable: Final ad" })).toHaveTextContent(
-      "Image unavailable: Final ad",
-    );
-    expect(screen.queryByRole("link")).toBeNull();
-  });
-
-  it("renders a fenced block's file name and highlights it as that file's language", () => {
-    render(<Markdown>{'```ts title="src/lib/ctr.ts"\nexport const x = 1;\n```'}</Markdown>);
-    expect(screen.getByText("src/lib/ctr.ts")).toBeInTheDocument();
-    expect(screen.getByText("TypeScript")).toBeInTheDocument();
-    expect(screen.getByRole("button", { name: "Copy to clipboard" })).toBeInTheDocument();
-  });
-
-  it("renders a single-line fence without a language as a block, not inline code", () => {
-    const { container } = render(<Markdown>{"```\nnpm run build\n```\n\nRun `npm test` too."}</Markdown>);
-    expect(container.querySelectorAll("pre")).toHaveLength(1);
-    expect(container.querySelector("pre")?.textContent).toBe("npm run build");
-    expect(container.querySelector("p code")?.textContent).toBe("npm test");
-  });
-
-  it("renders links the host classifies as chips that keep their href", () => {
-    render(
-      <Markdown linkChip={(href) => href.startsWith("/vault/") ? { kind: "file", label: "REVIEW.md", title: "campaigns/REVIEW.md" } : null}>
-        {"See [the review](/vault/REVIEW.md) and [docs](https://example.com)."}
-      </Markdown>,
-    );
-    const chip = screen.getByRole("link", { name: "REVIEW.md" });
-    expect(chip.getAttribute("href")).toBe("/vault/REVIEW.md");
-    expect(chip.getAttribute("data-link-chip")).toBe("file");
-    expect(chip.getAttribute("title")).toBe("campaigns/REVIEW.md");
-    expect(screen.getByRole("link", { name: "docs" }).hasAttribute("data-link-chip")).toBe(false);
-  });
-});

package/src/openui/schema.test.tsx

@@ -1,158 +0,0 @@
-import { render, screen } from "@testing-library/react";
-import { describe, expect, it, vi } from "vitest";
-import { getSanitizedMarkdownHeadingIdFromRawFragment } from "../markdown/markdown";
-import { OpenUIArtifactRenderer } from "./openui-artifact-renderer";
-import { OPENUI_NODE_JSON_SCHEMA, OPENUI_NODE_TYPES, validateOpenUIJsonArtifact, validateOpenUIJsonNode } from "./schema";
-
-const validPage = {
-  type: "card",
-  title: "Release proof",
-  badge: { type: "badge", label: "Ready", tone: "success" },
-  children: [
-    { type: "heading", text: "Result", level: 2 },
-    { type: "text", text: "Three checks passed." },
-    { type: "stack", children: [
-      { type: "stat", label: "Checks", value: "3" },
-      { type: "key_value", items: [{ label: "Allowed", value: true }, { label: "Missing", value: null }] },
-      { type: "code", code: "ok", language: "text" },
-      { type: "markdown", content: "**Done**" },
-      { type: "table", columns: [{ key: "name", header: "Name" }], rows: [{ name: "one" }] },
-      { type: "actions", actions: [{ id: "open", label: "Open" }] },
-      { type: "separator" },
-      { type: "grid", children: [{ type: "badge", label: "Nested" }] },
-    ] },
-  ],
-};
-
-type JsonSchema = Record<string, unknown>;
-
-/**
- * Model tool-schema converters accept a recursive `$ref` only when the loop can
- * terminate: it must pass through an optional property or an array that may be
- * empty. Return the first `$defs` path that recurses through required,
- * nonempty values only.
- */
-function findRequiredRefLoop(defs: Record<string, JsonSchema>): string | null {
-  function visit(schema: JsonSchema, path: string, stack: string[]): string | null {
-    const ref = typeof schema.$ref === "string" ? schema.$ref.replace("#/$defs/", "") : null;
-    if (ref) {
-      if (stack.includes(ref)) return path;
-      return visit(defs[ref]!, `$defs.${ref}`, [...stack, ref]);
-    }
-    for (const key of ["oneOf", "anyOf"] as const) {
-      const options = schema[key];
-      if (Array.isArray(options)) {
-        for (const [index, option] of options.entries()) {
-          const loop = visit(option as JsonSchema, `${path}.${key}.${index}`, stack);
-          if (loop) return loop;
-        }
-      }
-    }
-    if (schema.type === "array" && schema.items && Number(schema.minItems ?? 0) > 0) {
-      return visit(schema.items as JsonSchema, `${path}.items`, stack);
-    }
-    const required = Array.isArray(schema.required) ? schema.required as string[] : [];
-    const properties = (schema.properties ?? {}) as Record<string, JsonSchema>;
-    for (const name of required) {
-      if (!properties[name]) continue;
-      const loop = visit(properties[name], `${path}.properties.${name}`, stack);
-      if (loop) return loop;
-    }
-    return null;
-  }
-  return visit({ $ref: "#/$defs/node" }, "$", []);
-}
-
-describe("OpenUI JSON contract", () => {
-  it("advertises every renderer node and accepts nested JSON with primitive cells", () => {
-    expect(OPENUI_NODE_TYPES).toHaveLength(13);
-    expect(OPENUI_NODE_JSON_SCHEMA.$defs.node.oneOf).toHaveLength(13);
-    expect(validateOpenUIJsonNode(validPage)).toMatchObject({ ok: true, value: validPage });
-    expect(validateOpenUIJsonArtifact([validPage, { type: "text", text: "Afterword" }])).toMatchObject({ ok: true });
-  });
-
-  it("keeps every recursive node path terminable for model tool-schema converters", () => {
-    expect(findRequiredRefLoop(OPENUI_NODE_JSON_SCHEMA.$defs as unknown as Record<string, JsonSchema>)).toBeNull();
-    expect(validateOpenUIJsonNode({ type: "card", title: "Empty", children: [] }))
-      .toMatchObject({ ok: false, issue: { path: "$.children" } });
-  });
-
-  it("rejects an unsupported top-level or nested section before it can be dropped", () => {
-    expect(validateOpenUIJsonNode({ type: "section", children: [{ type: "text", text: "hidden" }] }))
-      .toMatchObject({ ok: false, issue: { path: "$", message: expect.stringContaining("section") } });
-    const nested = { type: "card", children: [{ type: "section", children: [{ type: "text", text: "hidden" }] }] };
-    expect(validateOpenUIJsonNode(nested))
-      .toMatchObject({ ok: false, issue: { path: "$.children[0]", message: expect.stringContaining("section") } });
-    expect(validateOpenUIJsonArtifact([{ type: "text", text: "visible" }, nested]))
-      .toMatchObject({ ok: false, issue: { path: "$[1].children[0]" } });
-    expect(validateOpenUIJsonArtifact(Array.from({ length: 1001 }, () => ({ type: "text", text: "too many" }))))
-      .toMatchObject({ ok: false, issue: { path: "$[1000]" } });
-  });
-
-  it("rejects fields the renderer would ignore and table cells with no column", () => {
-    expect(validateOpenUIJsonNode({ type: "text", text: "hello", body: "hidden" }).ok).toBe(false);
-    expect(validateOpenUIJsonNode({ type: "stack", children: [] }).ok).toBe(false);
-    expect(validateOpenUIJsonNode({ type: "key_value", items: [{ label: "Broken", value: { nested: true } }] }).ok).toBe(false);
-    expect(validateOpenUIJsonNode({ type: "table", columns: [{ key: "shown", header: "Shown" }], rows: [{ hidden: "lost" }] }))
-      .toMatchObject({ ok: false, issue: { path: "$.rows[0].hidden" } });
-  });
-
-  it("rejects arrays passed as a single node while keeping optional card fields", () => {
-    expect(validateOpenUIJsonNode([{ type: "text", text: "ok" }]))
-      .toMatchObject({ ok: false, issue: { path: "$" } });
-    expect(validateOpenUIJsonNode({ type: "card" }).ok).toBe(true);
-    expect(validateOpenUIJsonNode({ type: "card", title: "A result" }).ok).toBe(true);
-  });
-
-  it("renders an absent prototype-named table cell safely", () => {
-    const table = JSON.parse('{"type":"table","columns":[{"key":"__proto__","header":"Value"}],"rows":[{}]}');
-    expect(validateOpenUIJsonNode(table).ok).toBe(true);
-    render(<OpenUIArtifactRenderer schema={table} />);
-    expect(screen.getByText("Value")).toBeTruthy();
-  });
-
-  it("forwards URL transforms and keeps cross-file fragments aligned with sanitized headings", () => {
-    const urlTransform = vi.fn((url: string, key: string) => {
-      if (key !== "href") return url;
-      const separator = url.indexOf("#");
-      const fragment = separator >= 0
-        ? "#" + getSanitizedMarkdownHeadingIdFromRawFragment(url.slice(separator + 1))
-        : "";
-      return "/app/ws-1/vault?file=campaigns%2Fpacket.md" + fragment;
-    });
-
-    render(
-      <OpenUIArtifactRenderer
-        schema={{
-          type: "card",
-          children: [{
-            type: "markdown",
-            content: "[Packet](campaigns/packet.md#Cr%C3%A8me%20br%C3%BBl%C3%A9e)\n\n# Crème brûlée",
-          }],
-        }}
-        urlTransform={urlTransform}
-      />,
-    );
-
-    expect(screen.getByRole("link", { name: "Packet" })).toHaveAttribute(
-      "href",
-      "/app/ws-1/vault?file=campaigns%2Fpacket.md#user-content-crème-brûlée",
-    );
-    expect(screen.getByRole("heading", { name: "Crème brûlée" })).toHaveAttribute(
-      "id",
-      "user-content-crème-brûlée",
-    );
-    expect(urlTransform).toHaveBeenCalledWith(
-      "campaigns/packet.md#Cr%C3%A8me%20br%C3%BBl%C3%A9e",
-      "href",
-      expect.objectContaining({ tagName: "a" }),
-    );
-  });
-
-  it("shows an explicit error for an old unsupported artifact", () => {
-    const oldArtifact = { type: "card", children: [{ type: "section", children: [{ type: "text", text: "hidden" }] }] };
-    render(<OpenUIArtifactRenderer schema={oldArtifact as never} />);
-    expect(screen.getByRole("alert").textContent).toContain("$.children[0]");
-    expect(screen.getByRole("alert").textContent).toContain("section");
-  });
-});