@legionworks/facet 1.10.1 → 1.10.2

package/dist/gallery/frame/chunks/{markdown-zazx9h4n.js → markdown-31ee7zgx.js}

@@ -1,7 +1,7 @@
 import {
   FacetRenderError,
   decodeArtifactBytes
-} from "./markdown-d1wfbs70.js";
+} from "./markdown-n9xcxy80.js";
 
 // src/gallery-web/frame/renderers/svg.ts
 var STRIPPED_TAGS = new Set([

package/dist/gallery/frame/chunks/{markdown-g3asgaw3.js → markdown-7scxp44j.js}

@@ -5,7 +5,7 @@ import {
   dispatchRender,
   isRenderer,
   isTsxExecutionMode
-} from "./markdown-d1wfbs70.js";
+} from "./markdown-n9xcxy80.js";
 
 // src/gallery-web/theme.ts
 function isResolvedGalleryTheme(value) {

package/dist/gallery/frame/chunks/{markdown-z1wc0v0d.js → markdown-mksxbxx8.js}

@@ -10,11 +10,11 @@ import {
 } from "./markdown-h7pzv34e.js";
 import {
   importSanitizedSvgText
-} from "./markdown-zazx9h4n.js";
+} from "./markdown-31ee7zgx.js";
 import {
   FacetRenderError,
   decodeArtifactBytes
-} from "./markdown-d1wfbs70.js";
+} from "./markdown-n9xcxy80.js";
 import {
   dedent
 } from "./markdown-qx3cngz2.js";

package/dist/gallery/frame/chunks/{markdown-d1wfbs70.js → markdown-n9xcxy80.js}

@@ -51,6 +51,15 @@ function isHtmlEventHandlerAttribute(name) {
 function isHtmlInlineStyleAttribute(name) {
   return name.toLowerCase() === "style";
 }
+function isExternalHttpsImageSource(src) {
+  if (typeof src !== "string")
+    return false;
+  try {
+    return new URL(src).protocol === "https:";
+  } catch {
+    return false;
+  }
+}
 function isAllowedHtmlUrl(elementName, attributeName, value) {
   const element = htmlUrlBearingElement(elementName);
   if (element === null || !isHtmlUrlBearingAttribute(element, attributeName))
@@ -177,7 +186,8 @@ function countPageShim() {
   const graphRoots = roots.filter((root) => root.getAttribute(RENDERER_GRAPH_ATTRIBUTE) === "true");
   const allMarkedCandidates = safeSelectorElements(MARKED_ROOT_SELECTOR);
   const markedSet = new Set(allMarkedCandidates);
-  const htmlRoots = allMarkedCandidates.filter((root) => root.nodeName.toLowerCase() !== "svg" && !hasMarkedRootAncestor(root, markedSet));
+  const contentRoots = allMarkedCandidates.filter((root) => root.nodeName.toLowerCase() !== "svg" && !hasMarkedRootAncestor(root, markedSet));
+  const htmlRoots = contentRoots.filter((root) => root.getAttribute("data-facet-renderer-kind") !== "markdown");
   const html = htmlRoots.length === 0 ? undefined : {
     rendererRootCount: htmlRoots.length,
     headingCount: 0,
@@ -193,24 +203,19 @@ function countPageShim() {
     html.listCount += safeSelectorElementsWithin(root, HTML_STRUCTURAL_GROUPS.lists.join(",")).length;
     const images = safeSelectorElementsWithin(root, HTML_STRUCTURAL_GROUPS.images.join(","));
     html.imageCount += images.length;
-    html.externalImageCount += images.filter((image) => {
-      try {
-        return new URL(image.getAttribute("src") ?? "").protocol === "https:";
-      } catch {
-        return false;
-      }
-    }).length;
+    html.externalImageCount += images.filter((image) => isExternalHttpsImageSource(image.getAttribute("src"))).length;
     html.canvasCount += safeSelectorElementsWithin(root, HTML_STRUCTURAL_GROUPS.canvases.join(",")).length;
   }
   const mermaidNodeCount = graphRoots.reduce((count, root) => count + safeSelectorElementsWithin(root, "g.node").length, 0);
   const opaqueRegionCount = safeSelectorElements("*").filter((element) => element.nodeName.toLowerCase() === "canvas").length;
+  const externalImageCount = contentRoots.reduce((count, root) => count + safeSelectorElementsWithin(root, HTML_STRUCTURAL_GROUPS.images.join(",")).filter((image) => isExternalHttpsImageSource(image.getAttribute("src"))).length, 0);
   return {
     rendererRootSvgCount: roots.length,
     graphCount: graphRoots.length,
     mermaidNodeCount,
     visibleSvgCount: roots.filter(nonDegenerateViewBox).length,
     opaqueRegionCount,
-    externalImageCount: html?.externalImageCount ?? 0,
+    externalImageCount,
     errorCount: safeSelectorElements("[data-facet-error]").length,
     ...html === undefined ? {} : { html }
   };

package/dist/gallery/frame/chunks/{markdown-rd8w0ng9.js → markdown-rkt612xp.js}

@@ -6,7 +6,7 @@ import {
   isHtmlInlineStyleAttribute,
   isHtmlUrlAttributeName,
   isHtmlUrlBearingAttribute
-} from "./markdown-d1wfbs70.js";
+} from "./markdown-n9xcxy80.js";
 
 // src/gallery-web/frame/renderers/html.ts
 function shouldKeepAttribute(elementName, name, value) {

package/dist/gallery/frame/chunks/{mermaid-de7p4v0x.js → mermaid-b8fxhsgg.js}

@@ -2,12 +2,12 @@ import {
   mermaidInitializeConfig,
   renderMermaidDocument,
   renderMermaidInto
-} from "./markdown-z1wc0v0d.js";
+} from "./markdown-mksxbxx8.js";
 import"./markdown-6zz8efx2.js";
 import"./markdown-rm2yxfjj.js";
 import"./markdown-h7pzv34e.js";
-import"./markdown-zazx9h4n.js";
-import"./markdown-d1wfbs70.js";
+import"./markdown-31ee7zgx.js";
+import"./markdown-n9xcxy80.js";
 import"./markdown-s1jatrnk.js";
 import"./markdown-m7frq8x8.js";
 import"./markdown-tvdpppw8.js";

package/dist/gallery/frame/runtime/chart.js

@@ -1,14 +1,14 @@
 import {
   importSanitizedSvgText
-} from "../chunks/markdown-zazx9h4n.js";
+} from "../chunks/markdown-31ee7zgx.js";
 import {
   installGalleryFrameApi
-} from "../chunks/markdown-g3asgaw3.js";
+} from "../chunks/markdown-7scxp44j.js";
 import {
   FacetRenderError,
   createRendererRegistry,
   decodeArtifactBytes
-} from "../chunks/markdown-d1wfbs70.js";
+} from "../chunks/markdown-n9xcxy80.js";
 import {
   Accent_default,
   Dark2_default,

package/dist/gallery/frame/runtime/html.js

@@ -1,12 +1,12 @@
 import {
   renderHtml
-} from "../chunks/markdown-rd8w0ng9.js";
+} from "../chunks/markdown-rkt612xp.js";
 import {
   installGalleryFrameApi
-} from "../chunks/markdown-g3asgaw3.js";
+} from "../chunks/markdown-7scxp44j.js";
 import {
   createRendererRegistry
-} from "../chunks/markdown-d1wfbs70.js";
+} from "../chunks/markdown-n9xcxy80.js";
 import"../chunks/markdown-809k7q41.js";
 
 // src/gallery-web/frame/entries/html.ts

package/dist/gallery/frame/runtime/markdown.js

@@ -1,10 +1,10 @@
 import {
   installGalleryFrameApi
-} from "../chunks/markdown-g3asgaw3.js";
+} from "../chunks/markdown-7scxp44j.js";
 import {
   createRendererRegistry,
   decodeArtifactBytes
-} from "../chunks/markdown-d1wfbs70.js";
+} from "../chunks/markdown-n9xcxy80.js";
 import {
   __require
 } from "../chunks/markdown-809k7q41.js";
@@ -1380,7 +1380,7 @@ async function renderMarkdown(ctx, bytes) {
   const template = document.createElement("template");
   template.innerHTML = html;
   const mermaidBlocks = Array.from(template.content.querySelectorAll("pre > code.language-mermaid"));
-  const renderMermaidInto = mermaidBlocks.length === 0 ? null : (await import("../chunks/mermaid-de7p4v0x.js")).renderMermaidInto;
+  const renderMermaidInto = mermaidBlocks.length === 0 ? null : (await import("../chunks/mermaid-b8fxhsgg.js")).renderMermaidInto;
   for (const code of mermaidBlocks) {
     const source = code.textContent ?? "";
     const pre = code.parentElement;
@@ -1395,7 +1395,11 @@ async function renderMarkdown(ctx, bytes) {
     else
       pre.remove();
   }
-  ctx.container.appendChild(template.content);
+  const root = document.createElement("div");
+  root.setAttribute("data-facet-renderer-root", "true");
+  root.setAttribute("data-facet-renderer-kind", "markdown");
+  root.appendChild(template.content);
+  ctx.container.appendChild(root);
 }
 
 // src/gallery-web/frame/entries/markdown.ts

package/dist/gallery/frame/runtime/mermaid.js

@@ -1,16 +1,16 @@
 import {
   renderMermaidDocument
-} from "../chunks/markdown-z1wc0v0d.js";
+} from "../chunks/markdown-mksxbxx8.js";
 import"../chunks/markdown-6zz8efx2.js";
 import"../chunks/markdown-rm2yxfjj.js";
 import"../chunks/markdown-h7pzv34e.js";
-import"../chunks/markdown-zazx9h4n.js";
+import"../chunks/markdown-31ee7zgx.js";
 import {
   installGalleryFrameApi
-} from "../chunks/markdown-g3asgaw3.js";
+} from "../chunks/markdown-7scxp44j.js";
 import {
   createRendererRegistry
-} from "../chunks/markdown-d1wfbs70.js";
+} from "../chunks/markdown-n9xcxy80.js";
 import"../chunks/markdown-s1jatrnk.js";
 import"../chunks/markdown-m7frq8x8.js";
 import"../chunks/markdown-tvdpppw8.js";

package/dist/gallery/frame/runtime/svg.js

@@ -1,12 +1,12 @@
 import {
   renderSvgDocument
-} from "../chunks/markdown-zazx9h4n.js";
+} from "../chunks/markdown-31ee7zgx.js";
 import {
   installGalleryFrameApi
-} from "../chunks/markdown-g3asgaw3.js";
+} from "../chunks/markdown-7scxp44j.js";
 import {
   createRendererRegistry
-} from "../chunks/markdown-d1wfbs70.js";
+} from "../chunks/markdown-n9xcxy80.js";
 import"../chunks/markdown-809k7q41.js";
 
 // src/gallery-web/frame/entries/svg.ts

package/dist/gallery/frame/runtime/tsx.js

@@ -1,14 +1,14 @@
 import {
   renderHtml
-} from "../chunks/markdown-rd8w0ng9.js";
+} from "../chunks/markdown-rkt612xp.js";
 import {
   installGalleryFrameApi
-} from "../chunks/markdown-g3asgaw3.js";
+} from "../chunks/markdown-7scxp44j.js";
 import {
   RENDER_ERROR_ATTRIBUTE,
   appendRenderError,
   createRendererRegistry
-} from "../chunks/markdown-d1wfbs70.js";
+} from "../chunks/markdown-n9xcxy80.js";
 import"../chunks/markdown-809k7q41.js";
 
 // src/gallery-web/frame/renderers/tsx.ts

package/docs/reference/validation.md

@@ -14,7 +14,7 @@ Every other layer is bound to it through `VerdictSchema.status`.
 | ---------------------------- | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------ |
 | `ok`                         | Counts agree across protocol + shim + isolated worlds, layout observable, no discriminative errors.                                                                                                                                                                                                                                                                                                                                                                                                                                              |
 | `error`                      | Counts disagree with the lexical expectation OR the protocol surfaced a discriminative error.                                                                                                                                                                                                                                                                                                                                                                                                                                                    |
-| `partial:layout_unverified`  | Counts agree but the layout pass is unverified (no SVG rendered with a non-degenerate viewBox). MUST carry a screenshot path on the wire.                                                                                                                                                                                                                                                                                                                                                                                                        |
+| `partial:layout_unverified`  | Counts agree but the layout pass is unverified (no SVG rendered with a non-degenerate viewBox). Markdown with zero expected renderer roots and opaque regions instead reaches `ok` when protocol and isolated observations agree that its renderer root is non-empty. Empty Markdown remains unverified. MUST carry a screenshot path on the wire.                                                                                                                                                                                               |
 | `partial:opaque_content`     | An opaque DOM region was observed, so structural contents were not verified. MUST carry a screenshot path, or a typed `screenshotError` marker when capture fails transiently.                                                                                                                                                                                                                                                                                                                                                                   |
 | `partial:external_resources` | The artifact references external HTTPS images the no-egress verifier could not observe. MUST carry a screenshot path, or a typed `screenshotError` marker when capture fails transiently.                                                                                                                                                                                                                                                                                                                                                        |
 | `partial:unstable`           | TSX interactive mode: the structure observed at the render barrier differed from the structure observed after a bounded stability window. Deliberately NOT `tampered` — a legitimately animated or async-loading component also changes structure between observations, and branding that a forgery would manufacture the false-verdict class this project has spent three arcs eliminating. `tampered` stays reserved for channel divergence. MUST carry a screenshot path, or a typed `screenshotError` marker when capture fails transiently. |
@@ -48,7 +48,7 @@ ordering, top to bottom:
 7. `error` (declared-opaque, observed-zero) — the artifact declared opaque regions and none were seen.
 8. `partial:opaque_content` — single-snapshot claim: structure has opaque regions.
 9. `partial:external_resources` — single-snapshot claim: structure has external HTTP references.
-10. `partial:layout_unverified` — single-snapshot claim: visible SVG with zeroed viewBoxes.
+10. `partial:layout_unverified` — single-snapshot claim: visible SVG with zeroed viewBoxes; it also applies to empty Markdown, while diagram-free Markdown with matching non-empty observations has no layout to verify.
 11. `ok`.
 
 The rule generalizing rows 4 and 6: a claim that depends on ONE observation
@@ -77,6 +77,14 @@ WebP; legacy PNG evidence remains readable and exportable. Before static
 capture it emulates `prefers-reduced-motion: reduce` and awaits
 `document.fonts.ready`; these pre-flights keep repeated captures byte-identical.
 
+If resizing the capture viewport makes the artifact grow, Tier 1 restores the
+1280×800 evidence viewport and captures the artifact's scroll area in tiles.
+The tiles form one still WebP image, including for interactive or animated
+artifacts. This avoids changing viewport-sized elements such as `100vh` while
+retaining content below and to the right. Fixed and sticky elements repeat in
+each tile. Content that grows while the tiles are captured gets
+`screenshot_unavailable` instead of an incomplete image.
+
 Tier 1 uses the same artifact-type layout rules as the gallery frame: Mermaid,
 SVG, and chart roots are safely centered on both axes, with oversized content
 remaining reachable by scrolling; Markdown is top-aligned in a horizontally

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@legionworks/facet",
-  "version": "1.10.1",
+  "version": "1.10.2",
   "private": false,
   "keywords": [
     "artifacts",

package/src/gallery-web/frame/renderers/markdown.ts

@@ -77,5 +77,9 @@ export async function renderMarkdown(ctx: RenderContext, bytes: Uint8Array): Pro
     if (region.firstElementChild !== null) pre.replaceWith(region);
     else pre.remove();
   }
-  ctx.container.appendChild(template.content);
+  const root = document.createElement("div");
+  root.setAttribute("data-facet-renderer-root", "true");
+  root.setAttribute("data-facet-renderer-kind", "markdown");
+  root.appendChild(template.content);
+  ctx.container.appendChild(root);
 }

package/src/gallery-web/frame/renderers/registry.ts

@@ -1,6 +1,6 @@
 import type { ArtifactType } from "../../../shared/contracts/artifact-types";
 import { isRenderer, type Renderer as RendererKind } from "../../../shared/contracts/renderers";
-import { HTML_STRUCTURAL_GROUPS } from "../../../shared/html/policy";
+import { HTML_STRUCTURAL_GROUPS, isExternalHttpsImageSource } from "../../../shared/html/policy";
 import type { VerdictObserved } from "../../../shared/contracts/validation";
 import type { ObservedCountKey } from "../../../shared/contracts/observed-counts";
 import { isTsxExecutionMode, type TsxExecutionMode } from "../../../shared/tsx/execution";
@@ -140,9 +140,12 @@ export function countPageShim(): PageShimCounts {
   const graphRoots = roots.filter((root) => root.getAttribute(RENDERER_GRAPH_ATTRIBUTE) === "true");
   const allMarkedCandidates = safeSelectorElements(MARKED_ROOT_SELECTOR);
   const markedSet = new Set(allMarkedCandidates);
-  const htmlRoots = allMarkedCandidates.filter(
+  const contentRoots = allMarkedCandidates.filter(
     (root) => root.nodeName.toLowerCase() !== "svg" && !hasMarkedRootAncestor(root, markedSet),
   );
+  const htmlRoots = contentRoots.filter(
+    (root) => root.getAttribute("data-facet-renderer-kind") !== "markdown",
+  );
   const html =
     htmlRoots.length === 0
       ? undefined
@@ -170,13 +173,9 @@ export function countPageShim(): PageShimCounts {
     ).length;
     const images = safeSelectorElementsWithin(root, HTML_STRUCTURAL_GROUPS.images.join(","));
     html!.imageCount += images.length;
-    html!.externalImageCount += images.filter((image) => {
-      try {
-        return new URL(image.getAttribute("src") ?? "").protocol === "https:";
-      } catch {
-        return false;
-      }
-    }).length;
+    html!.externalImageCount += images.filter((image) =>
+      isExternalHttpsImageSource(image.getAttribute("src")),
+    ).length;
     html!.canvasCount += safeSelectorElementsWithin(
       root,
       HTML_STRUCTURAL_GROUPS.canvases.join(","),
@@ -192,13 +191,21 @@ export function countPageShim(): PageShimCounts {
   const opaqueRegionCount = safeSelectorElements("*").filter(
     (element) => element.nodeName.toLowerCase() === "canvas",
   ).length;
+  const externalImageCount = contentRoots.reduce(
+    (count, root) =>
+      count +
+      safeSelectorElementsWithin(root, HTML_STRUCTURAL_GROUPS.images.join(",")).filter((image) =>
+        isExternalHttpsImageSource(image.getAttribute("src")),
+      ).length,
+    0,
+  );
   return {
     rendererRootSvgCount: roots.length,
     graphCount: graphRoots.length,
     mermaidNodeCount,
     visibleSvgCount: roots.filter(nonDegenerateViewBox).length,
     opaqueRegionCount,
-    externalImageCount: html?.externalImageCount ?? 0,
+    externalImageCount,
     errorCount: safeSelectorElements("[data-facet-error]").length,
     ...(html === undefined ? {} : { html }),
   };

package/src/shared/html/policy.ts

@@ -61,6 +61,15 @@ export function isHtmlInlineStyleAttribute(name: string): boolean {
   return name.toLowerCase() === "style";
 }
 
+export function isExternalHttpsImageSource(src: string | null | undefined): boolean {
+  if (typeof src !== "string") return false;
+  try {
+    return new URL(src).protocol === "https:";
+  } catch {
+    return false;
+  }
+}
+
 export function isAllowedHtmlUrl(
   elementName: string,
   attributeName: string,

package/src/validation/tier0/html.ts

@@ -10,6 +10,7 @@ import {
   isHtmlInlineStyleAttribute,
   isHtmlUrlAttributeName,
   isHtmlUrlBearingAttribute,
+  isExternalHttpsImageSource,
 } from "../../shared/html/policy";
 
 export interface HtmlParseOk {
@@ -131,14 +132,6 @@ 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 === " " ||
@@ -190,7 +183,11 @@ function validateUrl(
       );
       continue;
     }
-    if (countStructure && (tagName === "img" || tagName === "source") && isHttpsUrl(candidate)) {
+    if (
+      countStructure &&
+      (tagName === "img" || tagName === "source") &&
+      isExternalHttpsImageSource(candidate)
+    ) {
       counts.externalImageCount += 1;
     }
   }

package/src/validation/tier0/markdown.ts

@@ -29,6 +29,7 @@
 import { Lexer, type Token, type Tokens } from "marked";
 
 import type { DiscriminativeError, VerdictObserved } from "../../shared/contracts/validation";
+import { isExternalHttpsImageSource } from "../../shared/html/policy";
 import { countMermaidNodeDeclarations } from "../../shared/util/mermaid-nodes";
 import { parseMermaidText } from "./mermaid";
 
@@ -58,17 +59,6 @@ interface MarkdownCounts {
   mermaidBodies: string[];
 }
 
-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,
@@ -122,7 +112,7 @@ function walkTokens(tokens: Token[], counts: MarkdownCounts): void {
       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;
+      if (isExternalHttpsImageSource(image.href)) counts.externalImageCount += 1;
     }
     // Recurse every container Marked actually emits with children.
     const recurseTokens = (sub: Token[] | undefined): void => {

package/src/validation/tier1/isolated-probe.ts

@@ -19,7 +19,7 @@
  */
 
 import type { ProtocolObservation } from "../../shared/contracts/validation";
-import { HTML_STRUCTURAL_GROUPS } from "../../shared/html/policy";
+import { HTML_STRUCTURAL_GROUPS, isExternalHttpsImageSource } from "../../shared/html/policy";
 
 import type { VerifierCdpSession } from "./browser-process";
 
@@ -32,27 +32,37 @@ export async function probeIsolatedCounts(
     const selectors = Object.fromEntries(
       Object.entries(HTML_STRUCTURAL_GROUPS).map(([group, names]) => [group, names.join(",")]),
     );
+    const externalHttpsImageSource = isExternalHttpsImageSource.toString();
     const result = (await session.send("Runtime.evaluate", {
       contextId: executionContextId,
       returnByValue: true,
       expression: [
         "(function(){",
         "  var candidates = Array.prototype.slice.call(document.querySelectorAll('[data-facet-renderer-root=\"true\"]'));",
-        "  var candidateSet = new Set(candidates);",
-        "  var roots = candidates.filter(function(root){",
-        "    for (var parent = root.parentElement; parent; parent = parent.parentElement) {",
-        "      if (candidateSet.has(parent)) return false;",
-        "    }",
+        "  var svgCandidates = candidates.filter(function(root){ return String(root.nodeName).toLowerCase() === 'svg'; });",
+        "  var svgCandidateSet = new Set(svgCandidates);",
+        "  var svgRoots = svgCandidates.filter(function(root){",
+        "    for (var parent = root.parentElement; parent; parent = parent.parentElement) if (svgCandidateSet.has(parent)) return false;",
         "    return true;",
         "  });",
-        "  var svgRoots = roots.filter(function(root){ return String(root.nodeName).toLowerCase() === 'svg'; });",
+        "  var contentCandidates = candidates.filter(function(root){ return String(root.nodeName).toLowerCase() !== 'svg'; });",
+        "  var contentCandidateSet = new Set(contentCandidates);",
+        "  var contentRoots = contentCandidates.filter(function(root){",
+        "    for (var parent = root.parentElement; parent; parent = parent.parentElement) if (contentCandidateSet.has(parent)) return false;",
+        "    return true;",
+        "  });",
+        "  var htmlRoots = contentRoots.filter(function(root){ return root.getAttribute('data-facet-renderer-kind') !== 'markdown'; });",
         "  var graphRoots = svgRoots.filter(function(root){ return root.getAttribute('data-facet-renderer-graph') === 'true'; });",
-        "  var htmlRoots = roots.filter(function(root){ return String(root.nodeName).toLowerCase() !== 'svg'; });",
         `  var observeContent = ${JSON.stringify(observeContent)};`,
-        "  var emptyRendererRoot = observeContent && htmlRoots.length === 1 ? Array.prototype.every.call(htmlRoots[0].childNodes, function(node){ return node.nodeType !== 1 && (node.nodeType !== 3 || !node.textContent.trim()); }) : undefined;",
+        `  var isExternalHttpsImageSource = (${externalHttpsImageSource});`,
+        "  var emptyRendererRoot = observeContent && contentRoots.length === 1 ? Array.prototype.every.call(contentRoots[0].childNodes, function(node){ return node.nodeType !== 1 && (node.nodeType !== 3 || !node.textContent.trim()); }) : undefined;",
         `  var selectors = ${JSON.stringify(selectors)};`,
         "  var html = htmlRoots.length === 0 ? null : {rendererRootCount:htmlRoots.length,headingCount:0,tableCount:0,listCount:0,imageCount:0,canvasCount:0,externalImageCount:0};",
         "  var externalImageCount = 0;",
+        "  for (var c = 0; c < contentRoots.length; c++) {",
+        "    var contentImages = Array.prototype.slice.call(contentRoots[c].querySelectorAll(selectors.images));",
+        "    externalImageCount += contentImages.filter(function(image){ return isExternalHttpsImageSource(image.getAttribute('src')); }).length;",
+        "  }",
         "  for (var h = 0; h < htmlRoots.length; h++) {",
         "    var htmlRoot = htmlRoots[h];",
         "    html.headingCount += htmlRoot.querySelectorAll(selectors.headings).length;",
@@ -60,9 +70,8 @@ export async function probeIsolatedCounts(
         "    html.listCount += htmlRoot.querySelectorAll(selectors.lists).length;",
         "    var images = Array.prototype.slice.call(htmlRoot.querySelectorAll(selectors.images));",
         "    html.imageCount += images.length;",
-        "    var rootExternal = images.filter(function(image){ try { return new URL(image.getAttribute('src') || '').protocol === 'https:'; } catch (_) { return false; } }).length;",
+        "    var rootExternal = images.filter(function(image){ return isExternalHttpsImageSource(image.getAttribute('src')); }).length;",
         "    html.externalImageCount += rootExternal;",
-        "    externalImageCount += rootExternal;",
         "    html.canvasCount += htmlRoot.querySelectorAll(selectors.canvases).length;",
         "  }",
         "  var nodeCount = 0;",

package/src/validation/tier1/limits.ts

@@ -1,13 +1,15 @@
 /**
  * Resource caps for the Tier 1 verifier.
  *
- * Each cap is named and exposed so the runner, the harness builder,
- * and the penetration test agree on a single value. A failing cap
- * produces a typed `FacetError` with the matching `tier1_*` code.
+ * Named limits keep the runner, harness builder, and penetration test
+ * aligned. Enforced caps produce typed `FacetError`s with matching
+ * `tier1_*` codes; TIER1_TIMEOUT_MS remains an intended total-budget
+ * target until outer enforcement lands.
  */
 
 /**
- * Wall-clock budget for one Tier 1 verifier invocation. The harness
+ * Intended total budget target for one Tier 1 verifier invocation; it
+ * is not enforced yet. The harness
  * bundles the REAL renderers (mermaid + marked + vega, ~8 MB inline);
  * parse + first render of a 40-node fixture needs real headroom.
  */
@@ -36,10 +38,13 @@ export const TIER1_USER_DATA_DIR_MODE = 0o700;
  */
 export const TIER1_RENDER_BARRIER_MS = 30_000;
 
+/** Keep tiled evidence within the intended total-budget target after render and stability windows. */
+export const TIER1_TILED_CAPTURE_DEADLINE_MS = 15_000;
+
 /**
  * Time between the first interactive TSX observation and its bounded
- * stability re-check. It stays below the headroom after the render barrier so
- * a typed `partial:unstable` verdict remains observable before Tier 1 times out.
+ * stability re-check. It stays below the intended total-budget target after
+ * the render barrier; that outer target is not enforced yet.
  */
 export const TSX_STABILITY_WINDOW_MS = 1_000;
 

package/src/validation/tier1/protocol-probe.ts

@@ -20,7 +20,7 @@
  */
 
 import type { HtmlStructureCounts, ProtocolObservation } from "../../shared/contracts/validation";
-import { HTML_STRUCTURAL_GROUPS } from "../../shared/html/policy";
+import { HTML_STRUCTURAL_GROUPS, isExternalHttpsImageSource } from "../../shared/html/policy";
 
 import type { VerifierCdpSession } from "./browser-process";
 import type { ResolvedChildFrame } from "./frame-target";
@@ -49,7 +49,7 @@ export interface SnapshotDocument {
 function snapshotRootEmpty(snapshot: SnapshotResponse, documentIndex: number): boolean | undefined {
   const document = snapshot.documents[documentIndex];
   if (document === undefined) return undefined;
-  const roots = htmlRootIndexes(snapshot, documentIndex);
+  const roots = contentRootIndexes(snapshot, documentIndex);
   if (roots.length !== 1) return undefined;
   const root = roots[0];
   if (root === undefined) return undefined;
@@ -166,6 +166,18 @@ function hasAncestorIn(
 }
 
 function htmlRootIndexes(snapshot: SnapshotResponse, documentIndex: number): number[] {
+  return contentRootIndexes(snapshot, documentIndex).filter(
+    (nodeIndex) =>
+      attributeValue(
+        snapshot,
+        snapshot.documents[documentIndex]!,
+        nodeIndex,
+        "data-facet-renderer-kind",
+      ) !== "markdown",
+  );
+}
+
+function contentRootIndexes(snapshot: SnapshotResponse, documentIndex: number): number[] {
   const document = snapshot.documents[documentIndex];
   if (document === undefined) return [];
   const candidates = new Set<number>();
@@ -181,6 +193,27 @@ function htmlRootIndexes(snapshot: SnapshotResponse, documentIndex: number): num
   });
 }
 
+function countSnapshotExternalImages(snapshot: SnapshotResponse, documentIndex: number): number {
+  const document = snapshot.documents[documentIndex];
+  if (document === undefined) return 0;
+  const roots = new Set(contentRootIndexes(snapshot, documentIndex));
+  let count = 0;
+  for (let nodeIndex = 0; nodeIndex < document.nodes.nodeName.length; nodeIndex += 1) {
+    if (!isDescendantOf(document, nodeIndex, roots)) continue;
+    const name = readString(
+      snapshot.strings,
+      document.nodes.nodeName[nodeIndex] ?? 0,
+    ).toLowerCase();
+    if (
+      (HTML_STRUCTURAL_GROUPS.images as readonly string[]).includes(name) &&
+      isExternalHttpsImageSource(attributeValue(snapshot, document, nodeIndex, "src"))
+    ) {
+      count += 1;
+    }
+  }
+  return count;
+}
+
 function isDescendantOf(
   document: SnapshotDocument,
   nodeIndex: number,
@@ -194,15 +227,6 @@ function isDescendantOf(
   return false;
 }
 
-function isExternalHttps(value: string | undefined): boolean {
-  if (value === undefined) return false;
-  try {
-    return new URL(value).protocol === "https:";
-  } catch {
-    return false;
-  }
-}
-
 export function countSnapshotHtml(
   snapshot: SnapshotResponse,
   documentIndex: number,
@@ -233,7 +257,7 @@ export function countSnapshotHtml(
     if ((HTML_STRUCTURAL_GROUPS.lists as readonly string[]).includes(name)) counts.listCount += 1;
     if ((HTML_STRUCTURAL_GROUPS.images as readonly string[]).includes(name)) {
       counts.imageCount += 1;
-      if (isExternalHttps(attributeValue(snapshot, document, nodeIndex, "src"))) {
+      if (isExternalHttpsImageSource(attributeValue(snapshot, document, nodeIndex, "src"))) {
         counts.externalImageCount += 1;
       }
     }
@@ -372,6 +396,7 @@ export async function probeProtocolSnapshot(
   const discriminativeErrors = collectDiscriminativeErrors(snapshot, documentIndex);
   const errorCount = discriminativeErrors.length;
   const htmlCounts = countSnapshotHtml(snapshot, documentIndex);
+  const externalImageCount = countSnapshotExternalImages(snapshot, documentIndex);
   const emptyRendererRoot = observeContent ? snapshotRootEmpty(snapshot, documentIndex) : undefined;
   return {
     rendererRootSvgCount: rendererRoots.length,
@@ -379,7 +404,7 @@ export async function probeProtocolSnapshot(
     mermaidNodeCount: countGNode(snapshot, documentIndex, graphRoots),
     visibleSvgCount: viewBoxes.filter(isNonDegenerateViewBox).length,
     opaqueRegionCount: countByName(snapshot, documentIndex, "canvas"),
-    externalImageCount: htmlCounts?.externalImageCount ?? 0,
+    externalImageCount,
     ...(htmlCounts === undefined ? {} : { html: htmlCounts }),
     ...(emptyRendererRoot === undefined ? {} : { emptyRendererRoot }),
     viewBoxes,
@@ -424,6 +449,7 @@ export async function probeProtocolGetDocument(
   let gNodeCount = 0;
   let opaqueRegionCount = 0;
   let visibleSvgCount = 0;
+  let externalImageCount = 0;
   let html: HtmlStructureCounts | undefined;
   let emptyRendererRoot: boolean | undefined;
   const viewBoxes: string[] = [];
@@ -458,19 +484,21 @@ export async function probeProtocolGetDocument(
     const name = (record.nodeName ?? "").toLowerCase();
     const markedRoot = findAttr("data-facet-renderer-root") === "true";
     const rendererRoot = name === "svg" && markedRoot && !withinRendererRoot;
-    const htmlRoot = name !== "svg" && markedRoot && !withinMarkedRoot;
+    const contentRoot = name !== "svg" && markedRoot && !withinMarkedRoot;
+    const markdownRoot = contentRoot && findAttr("data-facet-renderer-kind") === "markdown";
+    const htmlRoot = contentRoot && !markdownRoot;
     const graphRoot = rendererRoot && findAttr("data-facet-renderer-graph") === "true";
+    if (contentRoot && observeContent) {
+      const empty = !(record.children ?? []).some((child) => {
+        const direct = child as ProtocolDomNode & { nodeType?: number; nodeValue?: string };
+        return (
+          direct.nodeType === 1 ||
+          (direct.nodeType === 3 && (direct.nodeValue ?? "").trim().length > 0)
+        );
+      });
+      emptyRendererRoot = emptyRendererRoot === undefined ? empty : false;
+    }
     if (htmlRoot) {
-      if (observeContent) {
-        const empty = !(record.children ?? []).some((child) => {
-          const direct = child as ProtocolDomNode & { nodeType?: number; nodeValue?: string };
-          return (
-            direct.nodeType === 1 ||
-            (direct.nodeType === 3 && (direct.nodeValue ?? "").trim().length > 0)
-          );
-        });
-        emptyRendererRoot = emptyRendererRoot === undefined ? empty : false;
-      }
       html ??= {
         rendererRootCount: 0,
         headingCount: 0,
@@ -498,6 +526,12 @@ export async function probeProtocolGetDocument(
     // covers the entire child-frame document so smuggled canvases stay visible.
     // getContext() would create a context and make the observation self-fulfilling.
     if (name === "canvas") opaqueRegionCount += 1;
+    if (
+      (withinMarkedRoot || contentRoot) &&
+      (HTML_STRUCTURAL_GROUPS.images as readonly string[]).includes(name)
+    ) {
+      if (isExternalHttpsImageSource(findAttr("src"))) externalImageCount += 1;
+    }
     if (withinHtmlRoot && html !== undefined) {
       if ((HTML_STRUCTURAL_GROUPS.headings as readonly string[]).includes(name))
         html.headingCount += 1;
@@ -505,7 +539,7 @@ export async function probeProtocolGetDocument(
       if ((HTML_STRUCTURAL_GROUPS.lists as readonly string[]).includes(name)) html.listCount += 1;
       if ((HTML_STRUCTURAL_GROUPS.images as readonly string[]).includes(name)) {
         html.imageCount += 1;
-        if (isExternalHttps(findAttr("src"))) html.externalImageCount += 1;
+        if (isExternalHttpsImageSource(findAttr("src"))) html.externalImageCount += 1;
       }
       if ((HTML_STRUCTURAL_GROUPS.canvases as readonly string[]).includes(name))
         html.canvasCount += 1;
@@ -545,7 +579,7 @@ export async function probeProtocolGetDocument(
     mermaidNodeCount: gNodeCount,
     visibleSvgCount,
     opaqueRegionCount,
-    externalImageCount: html?.externalImageCount ?? 0,
+    externalImageCount,
     ...(html === undefined ? {} : { html }),
     ...(emptyRendererRoot === undefined ? {} : { emptyRendererRoot }),
     viewBoxes,

package/src/validation/tier1/runner.ts

@@ -31,6 +31,7 @@ import { mkdtempSync, rmSync, writeFileSync } from "node:fs";
 import { tmpdir } from "node:os";
 import { join } from "node:path";
 import { Buffer } from "node:buffer";
+import sharp from "sharp";
 
 import {
   Tier1ResultSchema,
@@ -73,6 +74,7 @@ import {
   TIER1_SCREENSHOT_MAX_AXIS_PX,
   TIER1_SCREENSHOT_MAX_PIXELS,
   TIER1_SCREENSHOT_WEBP_QUALITY,
+  TIER1_TILED_CAPTURE_DEADLINE_MS,
   TIER1_VIEWPORT_HEIGHT,
   TIER1_VIEWPORT_WIDTH,
   TSX_STABILITY_WINDOW_MS,
@@ -327,7 +329,7 @@ async function runTier1Attempt(
       artifactFrame,
       isolated.executionContextId,
       interactiveTsx ? runtimeExceptions!.errorsForFrame(artifactFrame.frameId) : [],
-      input.artifactType === "tsx",
+      input.artifactType === "tsx" || input.artifactType === "markdown",
     );
     const secondObservation = interactiveTsx
       ? await waitForStabilityObservation(
@@ -353,6 +355,7 @@ async function runTier1Attempt(
         renderComplete: shim.renderComplete,
         interactive: interactiveTsx,
         tsx: input.artifactType === "tsx",
+        markdown: input.artifactType === "markdown",
         channelDivergence,
         structureChanged:
           interactiveTsx && countsDiffer(firstObservation.protocol, secondObservation.protocol),
@@ -976,6 +979,165 @@ export async function captureEvidenceScreenshot(
   return captureScreenshotWithRetry(session, { bounds: options.bounds });
 }
 
+async function captureTiledScreenshot(
+  session: VerifierCdpSession,
+  executionContextId: number,
+  options: {
+    readonly tileTimeoutMs?: number;
+    readonly tileAttempts?: number;
+    readonly tiledDeadlineMs?: number;
+  } = {},
+): Promise<CapturedEvidenceImage> {
+  const deadlineAt =
+    performance.now() + (options.tiledDeadlineMs ?? TIER1_TILED_CAPTURE_DEADLINE_MS);
+  const assertDeadline = () => {
+    if (performance.now() >= deadlineAt) throw new Error("tiled-capture deadline exceeded");
+  };
+  await configureTier1Viewport(session);
+  await session.send("Runtime.evaluate", {
+    contextId: executionContextId,
+    expression: "new Promise(requestAnimationFrame)",
+    awaitPromise: true,
+  });
+  const source = await measureArtifactCaptureSize(session, executionContextId);
+  const bounds = boundCaptureSize(source);
+  const viewport = (await session.send("Runtime.evaluate", {
+    contextId: executionContextId,
+    returnByValue: true,
+    expression:
+      "(function(){var element=document.getElementById('artifact');" +
+      "if(!element)return null;return {width:element.clientWidth,height:element.clientHeight}})()",
+  })) as { result: { value?: { width: number; height: number } | null } };
+  const visible = viewport.result.value;
+  if (!visible || visible.width <= 0 || visible.height <= 0)
+    throw new Error("artifact tile viewport unavailable");
+  const owner = (await session.send("Runtime.evaluate", {
+    returnByValue: true,
+    expression:
+      "(function(){var frame=document.querySelector('#host-root iframe');" +
+      "if(!frame)return null;var rect=frame.getBoundingClientRect();" +
+      "return {x:rect.left,y:rect.top,width:rect.width,height:rect.height}})()",
+  })) as { result: { value?: { x: number; y: number; width: number; height: number } | null } };
+  const frame = owner.result.value;
+  if (!frame || frame.x < 0 || frame.y < 0)
+    throw new Error("artifact frame capture box unavailable");
+  const tileWidth = Math.min(Math.max(1, Math.floor(visible.width)), Math.floor(frame.width));
+  const tileHeight = Math.min(Math.max(1, Math.floor(visible.height)), Math.floor(frame.height));
+  if (tileWidth <= 0 || tileHeight <= 0) throw new Error("artifact tile bounds unavailable");
+  const columns = Math.ceil(source.width / tileWidth);
+  const rows = Math.ceil(source.height / tileHeight);
+  if (columns * rows > 256) throw new Error("artifact requires too many screenshot tiles");
+  const layers: { input: Buffer; left: number; top: number }[] = [];
+  for (let row = 0; row < rows; row += 1) {
+    for (let column = 0; column < columns; column += 1) {
+      assertDeadline();
+      const x = column * tileWidth;
+      const y = row * tileHeight;
+      const scrolled = (await session.send("Runtime.evaluate", {
+        contextId: executionContextId,
+        returnByValue: true,
+        expression:
+          "(function(){var element=document.getElementById('artifact');" +
+          "element.style.scrollBehavior='auto';element.scrollLeft=" +
+          x +
+          ";element.scrollTop=" +
+          y +
+          ";return new Promise(function(resolve){requestAnimationFrame(function(){resolve({left:element.scrollLeft,top:element.scrollTop})})})})()",
+        awaitPromise: true,
+      })) as { result: { value?: { left: number; top: number } } };
+      const offset = scrolled.result.value;
+      if (!offset || offset.left > x || offset.top > y)
+        throw new Error("artifact tile scroll position unavailable");
+      const tile = await captureScreenshotWithRetry(session, {
+        attempts: options.tileAttempts ?? TIER1_SCREENSHOT_CAPTURE_ATTEMPTS,
+        timeoutMs: options.tileTimeoutMs ?? TIER1_SCREENSHOT_CAPTURE_TIMEOUT_MS,
+        capture: async (cdpSession) => {
+          const shot = (await cdpSession.send("Page.captureScreenshot", {
+            format: "png",
+            captureBeyondViewport: false,
+            clip: {
+              x: Math.floor(frame.x),
+              y: Math.floor(frame.y),
+              width: tileWidth,
+              height: tileHeight,
+              scale: 1,
+            },
+          })) as { data?: string };
+          return shot.data ? { bytes: Buffer.from(shot.data, "base64"), format: "png" } : null;
+        },
+      });
+      if (tile.screenshot === null)
+        throw new Error(`tiled screenshot capture failed: ${tile.screenshotError?.message}`);
+      const outputLeft = Math.floor(x * bounds.scale);
+      const outputTop = Math.floor(y * bounds.scale);
+      const outputWidth =
+        Math.min(bounds.width, Math.floor(Math.min(x + tileWidth, source.width) * bounds.scale)) -
+        outputLeft;
+      const outputHeight =
+        Math.min(
+          bounds.height,
+          Math.floor(Math.min(y + tileHeight, source.height) * bounds.scale),
+        ) - outputTop;
+      if (outputWidth <= 0 || outputHeight <= 0) continue;
+      const input = await sharp(tile.screenshot.bytes)
+        .extract({
+          left: x - offset.left,
+          top: y - offset.top,
+          width: Math.min(tileWidth, source.width - x),
+          height: Math.min(tileHeight, source.height - y),
+        })
+        .resize(outputWidth, outputHeight, { fit: "fill" })
+        .png()
+        .toBuffer();
+      layers.push({ input, left: outputLeft, top: outputTop });
+    }
+  }
+  assertDeadline();
+  const finalSize = await measureArtifactCaptureSize(session, executionContextId);
+  await session.send("Runtime.evaluate", {
+    contextId: executionContextId,
+    expression:
+      "(function(){var element=document.getElementById('artifact');element.scrollLeft=0;element.scrollTop=0})()",
+  });
+  if (finalSize.width > source.width || finalSize.height > source.height)
+    throw new Error("artifact grew during tiled screenshot capture");
+  const bytes = await sharp({
+    create: { width: bounds.width, height: bounds.height, channels: 3, background: "#151823" },
+  })
+    .composite(layers)
+    .webp({ quality: TIER1_SCREENSHOT_WEBP_QUALITY })
+    .toBuffer();
+  if (bytes.byteLength > TIER1_SCREENSHOT_CAP_BYTES)
+    throw new Error("tiled screenshot exceeds encoded-size cap");
+  assertDeadline();
+  return { bytes, format: "webp" };
+}
+
+export async function captureTiledEvidenceScreenshot(
+  session: VerifierCdpSession,
+  executionContextId: number,
+  options: {
+    readonly tileTimeoutMs?: number;
+    readonly tileAttempts?: number;
+    readonly tiledDeadlineMs?: number;
+  } = {},
+): Promise<{
+  readonly screenshot: CapturedEvidenceImage | null;
+  readonly screenshotError: ScreenshotError | null;
+}> {
+  try {
+    return {
+      screenshot: await captureTiledScreenshot(session, executionContextId, options),
+      screenshotError: null,
+    };
+  } catch (error) {
+    return {
+      screenshot: null,
+      screenshotError: { code: "screenshot_unavailable", message: screenshotFailureMessage(error) },
+    };
+  }
+}
+
 interface ScreenshotRetryOptions {
   readonly attempts?: number;
   readonly timeoutMs?: number;
@@ -1092,15 +1254,16 @@ async function captureEvidence(
       returnByValue: true,
     });
     const finalSize = await measureArtifactCaptureSize(target.session, options.executionContextId);
-    if (finalSize.width > initialSize.width || finalSize.height > initialSize.height)
-      throw new Error("artifact grew after viewport resize");
-    const bounds = boundCaptureSize(finalSize);
-    const captureOptions = { bounds: { bounds, source: finalSize } };
-    const capture = await captureEvidenceScreenshot(target.session, {
-      animated,
-      bounds: captureOptions.bounds,
-      ...(captureScreenshot === undefined ? {} : { captureStatic: captureScreenshot }),
-    });
+    // The host iframe clips beyond its own 800px viewport; a larger iframe would
+    // resize 100vh descendants and never converge. Tiles preserve that viewport.
+    const grew = finalSize.width > initialSize.width || finalSize.height > initialSize.height;
+    const capture = grew
+      ? await captureTiledEvidenceScreenshot(target.session, options.executionContextId)
+      : await captureEvidenceScreenshot(target.session, {
+          animated,
+          bounds: { bounds: boundCaptureSize(finalSize), source: finalSize },
+          ...(captureScreenshot === undefined ? {} : { captureStatic: captureScreenshot }),
+        });
     screenshotError = capture.screenshotError;
     const screenshot = capture.screenshot;
     if (screenshot !== null) {

package/src/validation/tier1/verdict.ts

@@ -88,6 +88,8 @@ export interface LifecycleSummary {
   readonly channelDivergence?: boolean;
   /** Interactive TSX has no lexical HTML prediction and no trusted outer shim. */
   readonly interactive?: boolean;
+  /** Markdown can have no layout-bearing roots while still containing readable prose. */
+  readonly markdown?: boolean;
   /** Only TSX has a renderer-root emptiness claim from Tier 1. */
   readonly tsx?: boolean;
 }
@@ -166,6 +168,13 @@ export function deriveVerdict(
   if (
     !lifecycle.interactive &&
     expected.html === undefined &&
+    !(
+      lifecycle.markdown === true &&
+      expected.rendererRootSvgCount === 0 &&
+      expected.opaqueRegionCount === 0 &&
+      protocolObservation.emptyRendererRoot === false &&
+      isolatedObservation?.emptyRendererRoot === false
+    ) &&
     !layoutObservable(protocolObservation)
   ) {
     return "partial:layout_unverified";