@legionworks/facet 1.9.0

package/src/validation/tier0/html.ts

@@ -0,0 +1,408 @@
+import { parse, Tokenizer, TokenizerMode, type TokenHandler } from "parse5";
+
+import { MAX_HTML_NESTING_DEPTH } from "../../shared/config/limits";
+import type { DiscriminativeError, HtmlStructureCounts } from "../../shared/contracts/validation";
+import {
+  HTML_STRUCTURAL_GROUPS,
+  isAllowedHtmlUrl,
+  isHtmlDeniedElement,
+  isHtmlEventHandlerAttribute,
+  isHtmlInlineStyleAttribute,
+  isHtmlUrlAttributeName,
+  isHtmlUrlBearingAttribute,
+} from "../../shared/html/policy";
+
+export interface HtmlParseOk {
+  readonly status: "ok";
+  readonly html: HtmlStructureCounts;
+}
+
+export interface HtmlParseFail {
+  readonly status: "error";
+  readonly html: HtmlStructureCounts;
+  readonly errors: readonly DiscriminativeError[];
+}
+
+export type HtmlParseResult = HtmlParseOk | HtmlParseFail;
+
+interface HtmlAttribute {
+  readonly name: string;
+  readonly value: string;
+}
+
+const HTML_VOID_ELEMENTS = new Set([
+  "area",
+  "base",
+  "br",
+  "col",
+  "embed",
+  "hr",
+  "img",
+  "input",
+  "link",
+  "meta",
+  "param",
+  "source",
+  "track",
+  "wbr",
+]);
+
+function exceedsHtmlNestingDepth(text: string): boolean {
+  const openTags: string[] = [];
+  const positionsByTag = new Map<string, number[]>();
+  let exceeded = false;
+  let tokenizer: Tokenizer;
+  const handler: TokenHandler = {
+    onComment: () => {},
+    onDoctype: () => {},
+    onStartTag: (token) => {
+      if (token.selfClosing || HTML_VOID_ELEMENTS.has(token.tagName)) return;
+      const position = openTags.length;
+      openTags.push(token.tagName);
+      const positions = positionsByTag.get(token.tagName) ?? [];
+      positions.push(position);
+      positionsByTag.set(token.tagName, positions);
+      if (openTags.length > MAX_HTML_NESTING_DEPTH) {
+        exceeded = true;
+        tokenizer.pause();
+      }
+    },
+    onEndTag: (token) => {
+      const positions = positionsByTag.get(token.tagName);
+      const position = positions?.at(-1);
+      if (position === undefined) return;
+      while (openTags.length > position) {
+        const name = openTags.pop()!;
+        const entries = positionsByTag.get(name)!;
+        entries.pop();
+        if (entries.length === 0) positionsByTag.delete(name);
+      }
+    },
+    onEof: () => {},
+    onCharacter: () => {},
+    onNullCharacter: () => {},
+    onWhitespaceCharacter: () => {},
+  };
+  tokenizer = new Tokenizer({}, handler);
+  tokenizer.write(text, true);
+  return exceeded;
+}
+
+function initialCounts(): HtmlStructureCounts {
+  return {
+    rendererRootCount: 1,
+    headingCount: 0,
+    tableCount: 0,
+    listCount: 0,
+    imageCount: 0,
+    canvasCount: 0,
+    externalImageCount: 0,
+  };
+}
+
+function isRecord(value: unknown): value is Record<string, unknown> {
+  return typeof value === "object" && value !== null;
+}
+
+function elementDetails(
+  node: unknown,
+): { readonly tagName: string; readonly attrs: readonly HtmlAttribute[] } | null {
+  if (!isRecord(node) || typeof node.tagName !== "string" || !Array.isArray(node.attrs))
+    return null;
+  const attrs: HtmlAttribute[] = [];
+  for (const attribute of node.attrs) {
+    if (
+      !isRecord(attribute) ||
+      typeof attribute.name !== "string" ||
+      typeof attribute.value !== "string"
+    ) {
+      continue;
+    }
+    attrs.push({ name: attribute.name, value: attribute.value });
+  }
+  return { tagName: node.tagName.toLowerCase(), attrs };
+}
+
+function childNodes(node: unknown): readonly unknown[] {
+  return isRecord(node) && Array.isArray(node.childNodes) ? node.childNodes : [];
+}
+
+function templateContent(node: unknown): unknown | null {
+  return isRecord(node) && isRecord(node.content) ? node.content : null;
+}
+
+function isHttpsUrl(value: string): boolean {
+  try {
+    return new URL(value.trim()).protocol.toLowerCase() === "https:";
+  } catch {
+    return false;
+  }
+}
+
+function isWhitespace(character: string): boolean {
+  return (
+    character === " " ||
+    character === "\t" ||
+    character === "\n" ||
+    character === "\r" ||
+    character === "\f"
+  );
+}
+
+function srcsetCandidates(value: string): readonly string[] {
+  const candidates: string[] = [];
+  let index = 0;
+  while (index < value.length) {
+    while (index < value.length && (value[index] === "," || isWhitespace(value[index]!)))
+      index += 1;
+    if (index >= value.length) break;
+    const start = index;
+    while (index < value.length && !isWhitespace(value[index]!)) index += 1;
+    let candidate = value.slice(start, index);
+    while (candidate.endsWith(",")) candidate = candidate.slice(0, -1);
+    if (candidate.length > 0) candidates.push(candidate);
+    while (index < value.length && isWhitespace(value[index]!)) index += 1;
+    while (index < value.length && value[index] !== ",") index += 1;
+    if (value[index] === ",") index += 1;
+  }
+  return candidates;
+}
+
+function addError(errors: DiscriminativeError[], code: string, message: string): void {
+  errors.push({ code, message });
+}
+
+function validateUrl(
+  tagName: string,
+  attributeName: string,
+  value: string,
+  counts: HtmlStructureCounts,
+  errors: DiscriminativeError[],
+  countStructure: boolean,
+): void {
+  const candidates = attributeName === "srcset" ? srcsetCandidates(value) : [value];
+  for (const candidate of candidates) {
+    if (!isAllowedHtmlUrl(tagName, attributeName, candidate)) {
+      addError(
+        errors,
+        "html_denied_url_scheme",
+        `HTML <${tagName}> ${attributeName} contains a denied URL: ${candidate}`,
+      );
+      continue;
+    }
+    if (countStructure && (tagName === "img" || tagName === "source") && isHttpsUrl(candidate)) {
+      counts.externalImageCount += 1;
+    }
+  }
+}
+
+function walk(root: unknown, counts: HtmlStructureCounts, errors: DiscriminativeError[]): void {
+  const stack: Array<{ readonly node: unknown; readonly countStructure: boolean }> = [
+    { node: root, countStructure: true },
+  ];
+  while (stack.length > 0) {
+    const current = stack.pop()!;
+    const element = elementDetails(current.node);
+    if (element !== null) {
+      const { tagName, attrs } = element;
+      if (isHtmlDeniedElement(tagName)) {
+        addError(errors, "html_denied_element", `HTML contains denied <${tagName}> element`);
+      }
+      if (
+        current.countStructure &&
+        (HTML_STRUCTURAL_GROUPS.headings as readonly string[]).includes(tagName)
+      )
+        counts.headingCount += 1;
+      if (
+        current.countStructure &&
+        (HTML_STRUCTURAL_GROUPS.tables as readonly string[]).includes(tagName)
+      )
+        counts.tableCount += 1;
+      if (
+        current.countStructure &&
+        (HTML_STRUCTURAL_GROUPS.lists as readonly string[]).includes(tagName)
+      )
+        counts.listCount += 1;
+      if (
+        current.countStructure &&
+        (HTML_STRUCTURAL_GROUPS.images as readonly string[]).includes(tagName)
+      )
+        counts.imageCount += 1;
+      if (
+        current.countStructure &&
+        (HTML_STRUCTURAL_GROUPS.canvases as readonly string[]).includes(tagName)
+      )
+        counts.canvasCount += 1;
+      for (const attribute of attrs) {
+        const name = attribute.name.toLowerCase();
+        if (isHtmlEventHandlerAttribute(name) || isHtmlInlineStyleAttribute(name)) {
+          addError(
+            errors,
+            "html_denied_attribute",
+            `HTML <${tagName}> contains denied ${name} attribute`,
+          );
+          continue;
+        }
+        if (isHtmlUrlBearingAttribute(tagName, name)) {
+          validateUrl(tagName, name, attribute.value, counts, errors, current.countStructure);
+          continue;
+        }
+        if (isHtmlUrlAttributeName(name)) {
+          addError(
+            errors,
+            "html_denied_url_scheme",
+            `HTML <${tagName}> ${name} is not an allowed URL-bearing attribute`,
+          );
+        }
+      }
+      if (tagName === "template") {
+        const content = templateContent(current.node);
+        if (content !== null) stack.push({ node: content, countStructure: false });
+      }
+    }
+    const children = childNodes(current.node);
+    for (let index = children.length - 1; index >= 0; index -= 1) {
+      stack.push({ node: children[index], countStructure: current.countStructure });
+    }
+  }
+}
+
+export function parseHtml(bytes: Uint8Array): HtmlParseResult {
+  let text: string;
+  try {
+    text = new TextDecoder("utf-8", { fatal: true }).decode(bytes);
+  } catch {
+    const html = initialCounts();
+    return {
+      status: "error",
+      html,
+      errors: [
+        {
+          code: "html_encoding_unsupported",
+          message: "HTML bytes are not valid UTF-8",
+        },
+      ],
+    };
+  }
+  const html = initialCounts();
+  if (exceedsHtmlNestingDepth(text)) {
+    return {
+      status: "error",
+      html,
+      errors: [
+        {
+          code: "html_nesting_depth_exceeded",
+          message: `HTML nesting exceeds the ${MAX_HTML_NESTING_DEPTH} element limit`,
+        },
+      ],
+    };
+  }
+  const recovery = detectUnsupportedRecoveryFamilies(text);
+  if (recovery !== null) {
+    return {
+      status: "error",
+      html,
+      errors: [
+        {
+          code: "html_recovery_unsupported",
+          message: recovery,
+        },
+      ],
+    };
+  }
+  const errors: DiscriminativeError[] = [];
+  walk(parse(text, { scriptingEnabled: false }), html, errors);
+  return errors.length === 0 ? { status: "ok", html } : { status: "error", html, errors };
+}
+
+/**
+ * Tokenize the source and detect constructs whose recovery behaviour the
+ * parse5 prediction cannot guarantee against Chromium's DOMParser. Returns
+ * the rejection message for the FIRST unsupported construct found, or null
+ * if the bytes survive.
+ *
+ * Today the only sanctioned reject is the `<select>` family: parse5 drops
+ * table-scoped markup inside select (the WHATWG "in select in table" mode
+ * keeps it on Chromium). Shrinking the accepted input set here is cheaper
+ * than guaranteeing agreement on a niche construct static HTML reports do
+ * not actually need.
+ *
+ * Tokenizing (not scanning) is non-negotiable: a string scan cannot
+ * distinguish a `<select>` tag from the same characters appearing inside
+ * a comment, an attribute value, or a raw-text / RCDATA element's content.
+ * parse5's tree builder normally toggles tokenizer modes; a naive token
+ * detector therefore scores 7/9 and still false-positives on
+ * `<textarea>` / `<title>` content. We toggle the tokenizer mode
+ * ourselves on each RCDATA / RAWTEXT element so the score is 9/9.
+ */
+const TABLE_SCOPED_TAGS = new Set([
+  "table",
+  "tr",
+  "td",
+  "th",
+  "tbody",
+  "thead",
+  "tfoot",
+  "caption",
+  "colgroup",
+  "col",
+]);
+
+/** Escapable raw-text: character references ARE decoded, only the matching
+ * end tag is recognized. */
+const RCDATA_ELEMENTS = new Set(["textarea", "title"]);
+
+/** Raw text: no character references decoded, no tags at all (except the
+ * matching end tag).
+ *
+ * `noscript` is deliberately absent: this file parses with
+ * `scriptingEnabled: false` (matching the frame's DOMParser), and under
+ * scripting-disabled parsing `<noscript>` content is normal markup rather
+ * than raw text. Listing it here would blind the tokenizer walk to elements
+ * the tree walk below can see. These two must agree.
+ */
+const RAWTEXT_ELEMENTS = new Set(["style", "xmp", "iframe", "noembed", "noframes"]);
+
+function detectUnsupportedRecoveryFamilies(text: string): string | null {
+  let selectDepth = 0;
+  let divergent: string | null = null;
+  let tokenizer: Tokenizer;
+  const handler: TokenHandler = {
+    onComment: () => {},
+    onDoctype: () => {},
+    onStartTag: (token) => {
+      const tag = token.tagName.toLowerCase();
+      if (tag === "select") {
+        selectDepth += 1;
+        return;
+      }
+      if (divergent !== null) return;
+      if (selectDepth > 0 && TABLE_SCOPED_TAGS.has(tag)) {
+        divergent = `HTML <select> contains table-scoped <${tag}>; parse5 drops it, Chromium DOMParser keeps it`;
+        tokenizer.pause();
+        return;
+      }
+      // Toggle tokenizer mode so <select> / table markup inside raw text
+      // is not tokenized as a tag. This is the single detail that
+      // decides 9/9 vs 7/9.
+      if (RCDATA_ELEMENTS.has(tag)) {
+        tokenizer.state = TokenizerMode.RCDATA;
+      } else if (RAWTEXT_ELEMENTS.has(tag)) {
+        tokenizer.state = TokenizerMode.RAWTEXT;
+      }
+    },
+    onEndTag: (token) => {
+      const tag = token.tagName.toLowerCase();
+      if (tag === "select") {
+        if (selectDepth > 0) selectDepth -= 1;
+      }
+    },
+    onEof: () => {},
+    onCharacter: () => {},
+    onNullCharacter: () => {},
+    onWhitespaceCharacter: () => {},
+  };
+  tokenizer = new Tokenizer({}, handler);
+  tokenizer.write(text, true);
+  return divergent;
+}

package/src/validation/tier0/markdown.ts

@@ -0,0 +1,285 @@
+/**
+ * Tier 0 markdown parser.
+ *
+ * Marked's Lexer tokenizes the source into the CommonMark block tree
+ * without rendering. We use it to (a) confirm the source is structurally
+ * well-formed CommonMark, (b) count fenced blocks and per-language
+ * counts (cross-checking the service-side `computeLexicalExpectations`),
+ * and (c) verify raw HTML is treated as DATA, not executed.
+ *
+ * The Tier 0 renderer root expectation is one per ```mermaid fence.
+ * Marked produces inline `html` tokens for raw HTML blocks; those are
+ * counted but never attached to a DOM. The `marked` lexer therefore
+ * gives us a safe structural check without any rendering surface.
+ *
+ * External-image disclosure: the frozen CSP widens `img-src` to
+ * `https:` for every artifact type, so a markdown artifact carrying a
+ * native `![](https://…)` image loads that image at display time.
+ * `parseMarkdown` walks Marked's token tree (NOT a regex over the
+ * source) and tallies every image whose resolved `href` is `https:`.
+ * Marked resolves inline, reference-style, and autolink forms into the
+ * same `Tokens.Image` shape with the final `href` already populated,
+ * so a single walker pass is sufficient. The count surfaces as
+ * `observed.externalImageCount` so the verdict can downgrade the
+ * artifact to `partial:external_resources`. Raw-HTML smuggling of an
+ * `href`/`src` to `https:` remains a hard Tier 0 rejection — that
+ * pattern is hostile, not authored.
+ */
+
+import { Lexer, type Token, type Tokens } from "marked";
+
+import type { DiscriminativeError, VerdictObserved } from "../../shared/contracts/validation";
+import { countMermaidNodeDeclarations } from "../../shared/util/mermaid-nodes";
+
+export interface MarkdownParseOk {
+  readonly status: "ok";
+  readonly observed: VerdictObserved;
+}
+
+export interface MarkdownParseFail {
+  readonly status: "error";
+  readonly observed: VerdictObserved;
+  readonly errors: readonly DiscriminativeError[];
+}
+
+export type MarkdownParseResult = MarkdownParseOk | MarkdownParseFail;
+
+interface MarkdownCounts {
+  totalFenced: number;
+  mermaidFenced: number;
+  mermaidNodeCount: number | null;
+  rendererRoots: number;
+  htmlTokens: number;
+  externalImageCount: number;
+  hasScript: boolean;
+  hasOnHandler: boolean;
+  hasExternalRef: boolean;
+}
+
+function isExternalHttpsUrl(value: string): boolean {
+  // The URL constructor canonicalizes the protocol; malformed URLs
+  // (e.g. `https://[`) return false here rather than throwing, so the
+  // token walk surfaces a typed zero instead of crashing Tier 0.
+  try {
+    return new URL(value.trim()).protocol.toLowerCase() === "https:";
+  } catch {
+    return false;
+  }
+}
+
+/**
+ * Walk the marked token tree and tally the surfaces that matter for
+ * the Tier 0 verdict: fenced blocks, mermaid blocks, raw HTML blocks,
+ * native-markdown external-image references, and three structural
+ * red flags the verifier must NOT execute (a `<script>` token, an
+ * `on*=…` handler, and an external URL in any raw-HTML attribute).
+ *
+ * Marked resolves every image form (inline `![](https://…)`,
+ * reference-style `![alt][ref]` whose `[ref]: https://…`, autolink
+ * `![<https://…>]()`) into the same `Tokens.Image` shape with the
+ * final `href` already populated — the walker counts one `https:`
+ * image per token regardless of which authoring form produced it.
+ * Raw-HTML `src="https://…"` is the smuggling pattern and is rejected
+ * below.
+ *
+ * Container recursion enumerates every shape Marked actually emits
+ * with children: `tokens[]` (blockquote, paragraph, heading, list_item,
+ * em, strong, link, image, del, tableCell), `items[]` (list carries
+ * ListItem tokens; each item has its own `tokens[]`), `header[]`
+ * (table header cells; each cell carries its own `tokens[]`), and
+ * `rows[][]` (table body rows of cells; each cell carries its own
+ * `tokens[]`). Missing any of these silently misses every image a real
+ * status report places in a list or table — see the per-container
+ * shape table in the regression report. The walker ALSO recurses the
+ * raw-HTML red flags into the same containers: a `<script>` or `on*=`
+ * smuggled into a list item or table cell must still reject the
+ * document, the same as a top-level smuggled reference.
+ */
+function walkTokens(tokens: Token[], counts: MarkdownCounts): void {
+  for (const token of tokens) {
+    if (token.type === "code") {
+      const code = token as Tokens.Code;
+      counts.totalFenced += 1;
+      const lang = (code.lang ?? "").trim().toLowerCase();
+      if (lang === "mermaid") {
+        counts.mermaidFenced += 1;
+        counts.rendererRoots += 1;
+        const nodes = countMermaidNodeDeclarations(code.text);
+        counts.mermaidNodeCount =
+          counts.mermaidNodeCount === null || nodes === null
+            ? null
+            : counts.mermaidNodeCount + nodes;
+      }
+    } else if (token.type === "html") {
+      const html = token as Tokens.HTML;
+      counts.htmlTokens += 1;
+      const raw = html.raw ?? html.text ?? "";
+      if (/<script[\s>]/i.test(raw)) counts.hasScript = true;
+      if (/\son[a-z]+\s*=/i.test(raw)) counts.hasOnHandler = true;
+      if (/\b(?:href|src)\s*=\s*["']https?:/i.test(raw)) counts.hasExternalRef = true;
+    } else if (token.type === "image") {
+      const image = token as Tokens.Image;
+      if (isExternalHttpsUrl(image.href ?? "")) counts.externalImageCount += 1;
+    }
+    // Recurse every container Marked actually emits with children.
+    const recurseTokens = (sub: Token[] | undefined): void => {
+      if (Array.isArray(sub)) walkTokens(sub, counts);
+    };
+    const t = token as unknown as Record<string, unknown>;
+    // tokens[] — blockquote, paragraph, heading, list_item, em,
+    // strong, link, image (inline children), del, tableCell.
+    recurseTokens(t["tokens"] as Token[] | undefined);
+    // items[] — list carries ListItem tokens (each with its own
+    // tokens[] walked above when we visit them).
+    const items = t["items"] as Token[] | undefined;
+    if (Array.isArray(items)) walkTokens(items, counts);
+    // header[] — table header cells. Each cell carries its own
+    // tokens[] walked when we visit the cell token below.
+    const headerCells = t["header"] as Array<{ tokens?: Token[] }> | undefined;
+    if (Array.isArray(headerCells)) {
+      for (const cell of headerCells) {
+        if (cell !== null && typeof cell === "object") {
+          recurseTokens(cell.tokens as Token[] | undefined);
+        }
+      }
+    }
+    // rows[][] — table body rows, each row is an array of cells,
+    // each cell carries its own tokens[].
+    const rows = t["rows"] as Array<Array<{ tokens?: Token[] } | null>> | undefined;
+    if (Array.isArray(rows)) {
+      for (const row of rows) {
+        if (Array.isArray(row)) {
+          for (const cell of row) {
+            if (cell !== null && typeof cell === "object") {
+              recurseTokens(cell.tokens as Token[] | undefined);
+            }
+          }
+        }
+      }
+    }
+  }
+}
+
+/**
+ * Parse the source bytes as markdown. Pure tokenization — no DOM, no
+ * render, no script execution. Raw HTML is counted (it must NOT
+ * execute, and we surface structural red flags if it tries to smuggle
+ * one) but never interpreted.
+ */
+export function parseMarkdown(bytes: Uint8Array): MarkdownParseResult {
+  const text = new TextDecoder("utf-8", { fatal: false }).decode(bytes);
+  const counts: MarkdownCounts = {
+    totalFenced: 0,
+    mermaidFenced: 0,
+    mermaidNodeCount: 0,
+    rendererRoots: 0,
+    htmlTokens: 0,
+    externalImageCount: 0,
+    hasScript: false,
+    hasOnHandler: false,
+    hasExternalRef: false,
+  };
+  let lexError: unknown = null;
+  let tokens: Token[] = [];
+  try {
+    const lexer = new Lexer({ gfm: true });
+    tokens = lexer.lex(text);
+    walkTokens(tokens, counts);
+  } catch (error) {
+    lexError = error;
+  }
+
+  if (lexError !== null) {
+    const message = lexError instanceof Error ? lexError.message : String(lexError);
+    return {
+      status: "error",
+      observed: {
+        rendererRootSvgCount: 0,
+        graphCount: 0,
+        mermaidNodeCount: counts.mermaidNodeCount ?? 0,
+        visibleSvgCount: 0,
+        externalImageCount: 0,
+        errorCount: 1,
+        opaqueRegionCount: 0,
+      },
+      errors: [{ code: "markdown_lex_error", message }],
+    };
+  }
+
+  // Raw HTML must NEVER execute. A token containing a script, an
+  // `on*` handler, or an external URL surfaces as a parser error so a
+  // hostile artifact cannot smuggle executable content past Tier 0.
+  if (counts.hasScript) {
+    return {
+      status: "error",
+      observed: {
+        rendererRootSvgCount: counts.rendererRoots,
+        graphCount: counts.mermaidFenced,
+        mermaidNodeCount: counts.mermaidNodeCount ?? 0,
+        visibleSvgCount: 0,
+        externalImageCount: counts.externalImageCount,
+        errorCount: 1,
+        opaqueRegionCount: 0,
+      },
+      errors: [
+        {
+          code: "html_script_in_markdown",
+          message: "Raw HTML in markdown contains a <script> element; Tier 0 rejects it",
+        },
+      ],
+    };
+  }
+  if (counts.hasOnHandler) {
+    return {
+      status: "error",
+      observed: {
+        rendererRootSvgCount: counts.rendererRoots,
+        graphCount: counts.mermaidFenced,
+        mermaidNodeCount: counts.mermaidNodeCount ?? 0,
+        visibleSvgCount: 0,
+        externalImageCount: counts.externalImageCount,
+        errorCount: 1,
+        opaqueRegionCount: 0,
+      },
+      errors: [
+        {
+          code: "html_event_handler_in_markdown",
+          message: "Raw HTML in markdown contains an on*= event handler; Tier 0 rejects it",
+        },
+      ],
+    };
+  }
+  if (counts.hasExternalRef) {
+    return {
+      status: "error",
+      observed: {
+        rendererRootSvgCount: counts.rendererRoots,
+        graphCount: counts.mermaidFenced,
+        mermaidNodeCount: counts.mermaidNodeCount ?? 0,
+        visibleSvgCount: 0,
+        externalImageCount: counts.externalImageCount,
+        errorCount: 1,
+        opaqueRegionCount: 0,
+      },
+      errors: [
+        {
+          code: "html_external_reference_in_markdown",
+          message: "Raw HTML in markdown contains an external href/src URL; Tier 0 rejects it",
+        },
+      ],
+    };
+  }
+
+  return {
+    status: "ok",
+    observed: {
+      rendererRootSvgCount: counts.rendererRoots,
+      graphCount: counts.mermaidFenced,
+      mermaidNodeCount: counts.mermaidNodeCount ?? 0,
+      visibleSvgCount: 0,
+      externalImageCount: counts.externalImageCount,
+      errorCount: 0,
+      opaqueRegionCount: 0,
+    },
+  };
+}