@litfamily/litopencode 1.0.7 → 1.0.10

package/skills/lit-typographic-motion/engine/stage/gate.mjs

@@ -0,0 +1,119 @@
+// The stage path's gate rows: the flash audit on the master and the looping
+// preview, exact size / fps / length, file sizes, the reduced-motion still, near-black runs,
+// determinism, and the sound and text rows the sound and QA modules record. Type-engine rules (GLSL
+// passes, presets, glyph masks, frame time) do not apply to a page.
+import { spawnSync } from "node:child_process";
+import { existsSync, readFileSync, statSync } from "node:fs";
+import path from "node:path";
+import { limits } from "../constants.mjs";
+import { countFlashes } from "../flash.mjs";
+import { soundChecks } from "../sound.mjs";
+
+const pass = (detail = "") => ({ pass: true, detail });
+const fail = (detail) => ({ pass: false, detail });
+
+function probe(file) {
+  const result = spawnSync("ffprobe", ["-v", "error", "-show_entries", "stream=codec_type,codec_name,width,height,r_frame_rate,pix_fmt,color_range,color_space,color_transfer,color_primaries,duration,sample_rate,channels:format=duration", "-of", "json", file], { encoding: "utf8" });
+  if (result.status !== 0) return { error: (result.stderr || result.error?.message || "ffprobe failed").trim() };
+  const json = JSON.parse(result.stdout);
+  return { video: json.streams?.find((s) => s.codec_type === "video"), audio: json.streams?.find((s) => s.codec_type === "audio"), duration: Number(json.format?.duration) };
+}
+
+const locate = (root, name) => [path.join(root, name), path.join(root, ".run", name), path.join(root, "withheld", name)].find((file) => existsSync(file)) ?? null;
+const readJson = (file) => (existsSync(file) ? JSON.parse(readFileSync(file, "utf8")) : null);
+
+export function checkStageRun(root) {
+  const manifest = JSON.parse(readFileSync(path.join(root, "manifest.json"), "utf8"));
+  const lines = existsSync(path.join(root, ".run", "stage-frames.jsonl")) ? readFileSync(path.join(root, ".run", "stage-frames.jsonl"), "utf8").split("\n").filter(Boolean).map((line) => JSON.parse(line)) : [];
+  const frameLines = lines.filter((line) => line.stream === undefined).sort((a, b) => a.frame - b.frame);
+  const previewLines = lines.filter((line) => line.stream === "preview").sort((a, b) => a.previewFrame - b.previewFrame);
+  const [width, height] = manifest.resolution;
+  const fps = manifest.fps;
+  const checks = {};
+  const warnings = [];
+
+  // MO-C-03: the grid and window transpose for 9:16 (the render audited with that geometry).
+  const master = countFlashes(frameLines.map((line) => line.transitions ?? {}), fps, false);
+  const preview = previewLines.length ? countFlashes(previewLines.map((line) => line.transitions ?? {}), manifest.preview?.fps ?? fps, true) : null;
+  const general = Math.max(master.general, preview?.general ?? 0), red = Math.max(master.red, preview?.red ?? 0);
+  const flashDetail = `worst window ${general} general / ${red} red  (limit ${limits.flashLimitGeneral} / ${limits.flashLimitRed}); grid ${width >= height ? "320x180" : "180x320"} cells`;
+  checks["MO-C-03"] = frameLines.length !== manifest.frameCount ? fail(`only ${frameLines.length} of ${manifest.frameCount} frames were audited`)
+    : !previewLines.length ? fail(`preview frames were not audited; ${flashDetail}`)
+    : general <= limits.flashLimitGeneral && red <= limits.flashLimitRed ? pass(flashDetail) : fail(flashDetail);
+
+  if (manifest.webgl?.requested) checks["MO-C-02"] = manifest.webgl.failed ? fail("the page asked for WebGL and got none") : pass("WebGL on the stage's software rung (SwiftShader), labelled software");
+
+  const det = readJson(path.join(root, ".run", "determinism.json"));
+  const mismatch = det?.frames?.find((entry) => entry.master !== entry.replay);
+  checks["MO-C-09"] = !det ? fail("no determinism replay was recorded")
+    : det.frames.length < 8 || det.frames.length > 16 ? fail(`${det.frames.length} sample frames; the replay compares 8-16`)
+    : mismatch ? fail(`frame ${mismatch.frame} differs from a fresh replay`) : pass(`${det.frames.length} sample frames match a fresh replay from 0 (frames ${det.frames.map((entry) => entry.frame).join(",")})`);
+
+  const film = locate(root, "film.mp4");
+  const probed = film ? probe(film) : null;
+  const video = probed?.video;
+  const rate = video?.r_frame_rate ? Number(video.r_frame_rate.split("/")[0]) / Number(video.r_frame_rate.split("/")[1] ?? 1) : 0;
+  const tags = video && video.pix_fmt === "yuv420p" && video.color_space === "bt709" && video.color_range === "tv";
+  checks["MO-C-10"] = video && video.codec_name === "h264" && video.width === width && video.height === height && tags
+    ? pass(`${video.width}x${video.height} h264 yuv420p/bt709/tv (${manifest.format})`)
+    : fail(`${video ? `${video.width}x${video.height} ${video.codec_name} ${video.pix_fmt}/${video.color_space}/${video.color_range}` : probed?.error ?? "no MP4"}; the ${manifest.format} stage needs exactly ${width}x${height} with BT.709 tags`);
+  checks["MO-C-11"] = video && Math.abs(rate - fps) < 0.01 && (fps === 60 || fps === 30) ? pass(`${rate} fps`) : fail(`${rate} fps; the stage renders at ${fps}`);
+  const drift = Math.abs(manifest.durationSec - manifest.targetDurationSec) / manifest.targetDurationSec;
+  checks["MO-C-12"] = drift <= 0.1 + 1e-9 && manifest.durationSec >= 4 && manifest.durationSec <= 90
+    ? pass(`${manifest.durationSec.toFixed(2)} s against the treatment's ${manifest.targetDurationSec} s (${(drift * 100).toFixed(1)} %)`)
+    : fail(`${manifest.durationSec.toFixed(2)} s against the treatment's ${manifest.targetDurationSec} s: more than 10 % off`);
+
+  const previewFile = locate(root, "preview.webp") ?? locate(root, "preview.gif");
+  const poster = locate(root, "poster.png");
+  const sizes = { mp4: film ? statSync(film).size : 0, preview: previewFile ? statSync(previewFile).size : 0, poster: poster ? statSync(poster).size : 0 };
+  checks["MO-C-13"] = sizes.preview > 0 && sizes.preview <= limits.previewMaxBytes && sizes.poster > 0 && sizes.poster <= limits.posterMaxBytes
+    ? pass(`mp4 ${sizes.mp4}, preview ${sizes.preview} (cap 3 MB), poster ${sizes.poster} (cap 1 MB)`)
+    : fail(`mp4 ${sizes.mp4}, preview ${sizes.preview} (cap 3 MB), poster ${sizes.poster} (cap 1 MB)`);
+  const still = locate(root, "reduced-motion.png");
+  checks["MO-C-14"] = still && Number.isInteger(manifest.stillFrame) ? pass(`present; the final beat's midpoint, frame ${manifest.stillFrame}`) : fail("no reduced-motion still");
+
+  // MO-D-03: no near-black stretch longer than twice the shortest allowed beat (1.2 s), outside the
+  // first and last second.
+  const allowance = Math.round(2 * 1.2 * fps);
+  let run = 0, emptyError = null;
+  for (const line of frameLines) {
+    run = line.p995L < limits.nearBlackLuminance ? run + 1 : 0;
+    const edge = line.frame < fps || line.frame >= manifest.frameCount - fps ? fps : 0;
+    if (run > allowance + edge) { emptyError = `${run} near-black frames ending at frame ${line.frame}`; break; }
+  }
+  checks["MO-D-03"] = emptyError ? fail(emptyError) : pass(`no near-black run past ${allowance} frames`);
+
+  if (manifest.sound?.mode) Object.assign(checks, soundChecks(film, manifest.durationSec, manifest.sound.mode));
+  const qa = readJson(path.join(root, ".run", "qa.json"));
+  if (qa) Object.assign(checks, qa.checks);
+  else checks["TEXT-copy-found"] = fail("no text QA was recorded");
+  for (const warning of manifest.pageErrors ?? []) warnings.push(`page error: ${warning}`);
+  for (const asset of manifest.missingAssets ?? []) warnings.push(`missing stage asset: ${asset}`);
+  const failed = Object.entries(checks).filter(([, check]) => !check.pass && !check.warn).map(([id]) => id);
+  for (const [id, check] of Object.entries(checks)) if (check.warn) warnings.push(`${id}: ${check.detail}`);
+  return { manifest, checks, warnings, failed, passed: failed.length === 0, sizes, flash: { master, preview } };
+}
+
+const order = ["MO-C-03", "MO-C-02", "MO-C-09", "MO-C-10", "MO-C-11", "MO-C-12", "MO-C-13", "MO-C-14", "MO-D-03"];
+export function formatStageReport(result, context) {
+  const { manifest, checks } = result;
+  const out = (name) => path.join(context.exportDir, name);
+  const lines = [
+    "lit-typographic-motion — render report (stage)",
+    `outputs: ${out("film.mp4")} · ${out(manifest.previewEncoder === "gif" ? "preview.gif" : "preview.webp")} (encoder: ${manifest.previewEncoder}) · ${out("poster.png")} · ${out("reduced-motion.png")}`,
+    `format / fps / length: ${manifest.format} ${manifest.resolution.join("x")} @ ${manifest.fps} fps, ${manifest.durationSec.toFixed(2)} s (treatment ${manifest.targetDurationSec} s)`,
+    `renderer: stage software rung (flags: ${(manifest.chromeFlags ?? []).join(" ")})`,
+    `timing: master ${manifest.timing?.masterSec ?? "?"} s, per frame p50 ${manifest.timing?.frameP50 ?? "?"} ms / p95 ${manifest.timing?.frameP95 ?? "?"} ms, total ${manifest.timing?.totalSec ?? "?"} s`,
+    "",
+    `QA gate: ${result.passed ? "PASS" : "FAIL"}`
+  ];
+  const ids = [...order.filter((id) => checks[id]), ...Object.keys(checks).filter((id) => !order.includes(id))];
+  for (const id of ids) {
+    const check = checks[id];
+    lines.push(`  ${id} ${check.pass ? "PASS" : check.warn ? "WARN" : "FAIL"}${check.detail ? `  (${check.detail})` : ""}`);
+  }
+  lines.push("", `craft rounds run: ${manifest.craftRound} / 3 max`, `frames actually viewed this run: ${context.viewed} (confirmed looked, not just rendered)`);
+  if (result.warnings.length) lines.push(`warnings: ${result.warnings.join("; ")}`);
+  lines.push(`gate exit: ${context.exitCode}`, `export state: ${context.exportState}`, "brief: none (stage path)", "");
+  return lines.join("\n");
+}

package/skills/lit-typographic-motion/engine/stage/qa-page.js

@@ -0,0 +1,158 @@
+// QA replay helpers, injected only into the QA browser (never the master). They read the page's text
+// runs and, at a QA sample, hide every glyph for one capture so the renderer can difference the two
+// frames into an ink mask. Nothing here runs unless the QA driver calls it.
+(() => {
+  "use strict";
+  const blockDisplays = /^(?:block|flex|grid|list-item|table|table-cell|table-caption|flow-root|inline-block|inline-flex|inline-grid)$/u;
+  const skipTags = new Set(["SCRIPT", "STYLE", "TITLE", "NOSCRIPT", "TEMPLATE", "HEAD"]);
+  const normalize = (text) => String(text).normalize("NFC").toLowerCase().replace(/[\s\p{P}]/gu, "");
+
+  function opacityChain(el) {
+    let value = 1;
+    for (let node = el; node && node.nodeType === 1; node = node.parentElement ?? (node.parentNode?.host ?? null)) {
+      const style = getComputedStyle(node);
+      if (style.display === "none" || style.visibility === "hidden" || style.visibility === "collapse") return 0;
+      value *= Number(style.opacity);
+    }
+    return value;
+  }
+  function scaleOf(el) {
+    if (el instanceof SVGElement && el.getScreenCTM) { const m = el.getScreenCTM(); return m ? Math.hypot(m.a, m.b) : 1; }
+    let scale = 1;
+    for (let node = el; node && node.nodeType === 1; node = node.parentElement) {
+      const t = getComputedStyle(node).transform;
+      if (t && t !== "none") { const m = new DOMMatrixReadOnly(t); scale *= Math.hypot(m.a, m.b); }
+    }
+    return scale;
+  }
+  function clipRects(el, rects) {
+    let out = rects.map((r) => [r.left, r.top, r.right, r.bottom]);
+    // The root and body clip to the viewport (handled below); a collapsed box clips nothing it contains.
+    for (let node = el.parentElement; node && node !== document.body && node !== document.documentElement; node = node.parentElement) {
+      const style = getComputedStyle(node);
+      if (style.overflowX === "visible" && style.overflowY === "visible" && style.clipPath === "none") continue;
+      const box = node.getBoundingClientRect();
+      if (box.width <= 0 || box.height <= 0) continue;
+      out = out.map(([x0, y0, x1, y1]) => [Math.max(x0, box.left), Math.max(y0, box.top), Math.min(x1, box.right), Math.min(y1, box.bottom)]).filter(([x0, y0, x1, y1]) => x1 > x0 && y1 > y0);
+    }
+    return out.map(([x0, y0, x1, y1]) => [Math.max(0, x0), Math.max(0, y0), Math.min(innerWidth, x1), Math.min(innerHeight, y1)]).filter(([x0, y0, x1, y1]) => x1 > x0 && y1 > y0);
+  }
+  function runRoot(textNode) {
+    const parent = textNode.parentElement;
+    const marked = parent.closest("[data-lit-text]");
+    if (marked) return marked;
+    if (parent.closest("svg")) return parent.closest("text") ?? parent;
+    for (let node = parent; node; node = node.parentElement) if (node === document.body || blockDisplays.test(getComputedStyle(node).display)) return node;
+    return parent;
+  }
+
+  // Every text run on screen now: DOM and SVG text, ::before/::after content and registered canvas text.
+  function collectRuns() {
+    const groups = new Map();
+    const walker = document.createTreeWalker(document.body ?? document.documentElement, NodeFilter.SHOW_TEXT);
+    for (let node = walker.nextNode(); node; node = walker.nextNode()) {
+      if (!node.nodeValue.trim() || !node.parentElement || skipTags.has(node.parentElement.tagName) || node.parentElement.closest("title,desc,defs")) continue;
+      const root = runRoot(node);
+      if (!groups.has(root)) groups.set(root, []);
+      groups.get(root).push(node);
+    }
+    const runs = [];
+    for (const [root, nodes] of groups) {
+      const range = document.createRange();
+      const rects = [], elements = new Set();
+      let opacity = 1, fontSize = 0, weight = 400, scale = 1, gradient = false;
+      for (const node of nodes) {
+        range.selectNodeContents(node);
+        rects.push(...clipRects(node.parentElement, [...range.getClientRects()]));
+        const el = node.parentElement;
+        elements.add(el);
+        opacity = Math.min(opacity, opacityChain(el));
+        const style = getComputedStyle(el);
+        const size = parseFloat(style.fontSize), s = scaleOf(el);
+        if (size * s > fontSize * scale) { fontSize = size; scale = s; weight = Number(style.fontWeight) || 400; }
+        if (/text/u.test(style.webkitBackgroundClip || style.backgroundClip) || /url\(|gradient/u.test(style.fill)) gradient = true;
+      }
+      const text = nodes.map((node) => node.nodeValue).join("").replace(/\s+/gu, " ").trim();
+      runs.push({ text, norm: normalize(text), rects, opacity, fontSize, scale, weight, gradient, decor: root.closest("[data-lit-decor]") !== null, kind: root instanceof SVGElement ? "svg" : "dom", elements: [...elements] });
+    }
+    for (const el of document.querySelectorAll("body *")) {
+      for (const pseudo of ["::before", "::after"]) {
+        const content = getComputedStyle(el, pseudo).content;
+        if (!content || content === "none" || content === "normal" || !/^["']/u.test(content)) continue;
+        const text = content.slice(1, -1).trim();
+        if (!text) continue;
+        const style = getComputedStyle(el, pseudo);
+        runs.push({ text, norm: normalize(text), rects: clipRects(el, [el.getBoundingClientRect()]), opacity: opacityChain(el), fontSize: parseFloat(style.fontSize), scale: scaleOf(el), weight: Number(style.fontWeight) || 400, gradient: false, decor: el.closest("[data-lit-decor]") !== null, kind: "pseudo", elements: [el] });
+      }
+    }
+    for (const entry of window.__litStage.registered()) {
+      runs.push({ text: entry.content, norm: normalize(entry.content), rects: [[entry.x, entry.y, entry.x + entry.w, entry.y + entry.h]], opacity: 1, fontSize: entry.h, scale: 1, weight: 400, gradient: false, decor: entry.decor, kind: "canvas", elements: [] });
+    }
+    return runs;
+  }
+
+  let hidden = null;
+  function strip(runs) {
+    return runs.map(({ elements, ...rest }) => rest);
+  }
+  // Marks the run elements, then hides their glyphs with one rule (transitions left alone; the driver
+  // cancels any animation the rule starts).
+  function hideText(runs) {
+    const marked = [];
+    for (const run of runs) for (const el of run.elements) {
+      el.dataset.litQaInk = "";
+      const style = getComputedStyle(el);
+      if (/text/u.test(style.webkitBackgroundClip || style.backgroundClip)) el.dataset.litQaClip = "";
+      for (const prop of ["border-top-color", "border-right-color", "border-bottom-color", "border-left-color", "outline-color"]) el.style.setProperty(prop, style.getPropertyValue(prop));
+      marked.push(el);
+    }
+    const sheet = document.createElement("style");
+    sheet.textContent = "[data-lit-qa-ink] { color: transparent !important; -webkit-text-fill-color: transparent !important; -webkit-text-stroke-color: transparent !important; text-decoration-color: transparent !important; }\n" +
+      "[data-lit-qa-clip] { background-image: none !important; }\n" +
+      "svg text[data-lit-qa-ink], svg [data-lit-qa-ink] tspan, svg tspan[data-lit-qa-ink], svg textPath[data-lit-qa-ink] { fill: transparent !important; stroke: transparent !important; }";
+    document.head.appendChild(sheet);
+    hidden = { sheet, marked };
+  }
+  function showText() {
+    if (!hidden) return;
+    hidden.sheet.remove();
+    for (const el of hidden.marked) {
+      delete el.dataset.litQaInk; delete el.dataset.litQaClip;
+      for (const prop of ["border-top-color", "border-right-color", "border-bottom-color", "border-left-color", "outline-color"]) el.style.removeProperty(prop);
+    }
+    hidden = null;
+  }
+
+  let known = new Set();
+  let current = [];
+  Object.defineProperty(window, "__litQa", {
+    value: Object.freeze({
+      runs() { current = collectRuns(); return strip(current); },
+      snapshot() { known = new Set(document.getAnimations()); },
+      hide() { hideText(current); },
+      show() { showText(); },
+      cancelNew() {
+        getComputedStyle(document.documentElement).opacity;
+        let cancelled = 0;
+        for (const animation of document.getAnimations()) if (!known.has(animation)) { animation.cancel(); cancelled += 1; }
+        return cancelled;
+      },
+      settle() { return new Promise((resolve) => window.__litStage.nativeRaf(() => window.__litStage.nativeRaf(resolve))); },
+      markFonts() {
+        let k = 0;
+        for (const run of current) for (const el of run.elements) if (!el.dataset.litQaRun) el.dataset.litQaRun = String(k++);
+        return current.map((run) => run.elements.map((el) => el.dataset.litQaRun));
+      },
+      unmarkFonts() { for (const el of document.querySelectorAll("[data-lit-qa-run]")) delete el.dataset.litQaRun; },
+      probeFaces(families) {
+        const box = document.createElement("div");
+        box.style.cssText = "position:absolute;left:0;top:0;opacity:0;pointer-events:none";
+        families.forEach((family, i) => { const el = document.createElement("span"); el.dataset.litQaProbe = String(i); el.style.fontFamily = `"${family}"`; el.textContent = "Aa가"; box.appendChild(el); });
+        document.body.appendChild(box);
+        return () => box.remove();
+      },
+      canvasTexts() { return window.__litStage.canvasTexts(); }
+    }),
+    configurable: false
+  });
+})();

package/skills/lit-typographic-motion/engine/stage/qa.mjs

@@ -0,0 +1,208 @@
+// The stage's text QA, in its own replay browser (the master capture never changes a style). The clock
+// is stepped from 0; every 1/10 s the page's text runs are read for the reading-floor track, and at
+// each QA sample (every beat midpoint plus two settled frames per beat) two captures are taken, one
+// as the film shows it and one with every glyph made transparent, so the difference is the ink.
+import { readFileSync } from "node:fs";
+import path from "node:path";
+import { fileURLToPath } from "node:url";
+import { boxContrast } from "../contrast.mjs";
+import { linearLut } from "../flash.mjs";
+import { decodePng } from "../png.mjs";
+import { readingFloor } from "../text.mjs";
+import { normalize, withoutQuotes } from "../treatment.mjs";
+
+const here = path.dirname(fileURLToPath(import.meta.url));
+export const qaPageSource = () => readFileSync(path.join(here, "qa-page.js"), "utf8");
+export const qaLimits = Object.freeze({ inkDelta: 2, minInkPixels: 12, visibleOpacity: 0.6, judgedOpacity: 0.95, settledPx: 2, decorShare: 0.25, presenceStd: 8 / 255, largeShare: 0.03, safeInset: 0.05, floorTolerance: 0.1 });
+const internalTerms = /(?<![\p{L}\p{N}])(?:path|preset|gate|beat|treatment)(?![\p{L}\p{N}])/iu;
+const fileName = /(?<![\p{L}\p{N}])[\w-]+\.(?:html?|json|mjs|js|css|png|jpe?g|webp|svg|wav|mp4|md)(?![\p{L}\p{N}])/iu;
+
+export function titleSafeBox(width, height) {
+  return [width * qaLimits.safeInset, height * qaLimits.safeInset, width * (1 - qaLimits.safeInset), height * (1 - qaLimits.safeInset)];
+}
+
+function rgbaOf(png) {
+  const image = decodePng(png);
+  if (image.channels === 4) return image.pixels;
+  const out = Buffer.alloc(image.width * image.height * 4);
+  for (let i = 0, j = 0; i < image.pixels.length; i += image.channels, j += 4) { out[j] = image.pixels[i]; out[j + 1] = image.pixels[i + 1]; out[j + 2] = image.pixels[i + 2]; out[j + 3] = 255; }
+  return out;
+}
+
+const union = (rects) => rects.length ? [Math.min(...rects.map((r) => r[0])), Math.min(...rects.map((r) => r[1])), Math.max(...rects.map((r) => r[2])), Math.max(...rects.map((r) => r[3]))] : null;
+const onScreen = (rects, width, height) => rects.some(([x0, y0, x1, y1]) => x1 > 0 && y1 > 0 && x0 < width && y0 < height && x1 > x0 && y1 > y0);
+const keyOf = (run, width, height) => {
+  const box = union(run.rects);
+  return box ? `${run.norm}@${Math.floor(((box[0] + box[2]) / 2) / (width / 10))},${Math.floor(((box[1] + box[3]) / 2) / (height / 10))}` : `${run.norm}@off`;
+};
+
+// Drives the QA browser; returns the raw samples and the 10 fps track for analyseQa().
+export async function captureQa(stage, context, frameCount) {
+  const { fps, treatment } = context;
+  const clamp = (f) => Math.max(0, Math.min(frameCount - 1, Math.round(f)));
+  const mids = new Set(treatment.beats.map((b) => clamp(((b.t0 + b.t1) / 2) * fps)));
+  const settled = treatment.beats.flatMap((b) => [0.35, 0.8].map((q) => clamp((b.t0 + q * (b.t1 - b.t0)) * fps)));
+  const qaFrames = new Set([...mids, ...settled]);
+  const trackStep = Math.max(1, Math.round(fps / 10));
+  const page = stage.page, cdp = stage.cdp;
+  await cdp.send("DOM.enable");
+  await cdp.send("CSS.enable");
+  const families = context.fonts.families;
+  // The allowed platform faces are whatever the product's own web fonts report as, probed once in
+  // this browser (a laid-out probe; only custom fonts count, so a system fallback never joins them).
+  const removeProbe = await page.evaluateHandle(async (list) => { const remove = window.__litQa.probeFaces(list); document.body.offsetHeight; await window.__litQa.settle(); return remove; }, families);
+  const allowed = new Set();
+  {
+    const { root } = await cdp.send("DOM.getDocument", { depth: -1 });
+    const { nodeIds } = await cdp.send("DOM.querySelectorAll", { nodeId: root.nodeId, selector: "[data-lit-qa-probe]" });
+    for (const nodeId of nodeIds) for (const font of (await cdp.send("CSS.getPlatformFontsForNode", { nodeId })).fonts) if (font.isCustomFont) allowed.add(font.familyName);
+  }
+  await page.evaluate((remove) => remove(), removeProbe);
+  const track = [], samples = [], canvasTexts = new Set();
+  for (let frame = 0; frame < frameCount; frame++) {
+    const isQa = qaFrames.has(frame);
+    await stage.step(frame, isQa);
+    if (!isQa && frame % trackStep !== 0) continue;
+    const runs = await page.evaluate(() => window.__litQa.runs());
+    if (frame % trackStep === 0) track.push({ frame, runs: runs.map(({ text, norm, rects, opacity, decor, kind }) => ({ text, norm, rects, opacity, decor, kind })) });
+    if (!isQa) continue;
+    for (const text of await page.evaluate(() => window.__litQa.canvasTexts())) canvasTexts.add(text);
+    const a = await stage.capture();
+    await page.evaluate(() => { window.__litQa.snapshot(); window.__litQa.hide(); window.__litQa.cancelNew(); return window.__litQa.settle(); });
+    const b = await stage.capture();
+    await page.evaluate(() => { window.__litQa.show(); window.__litQa.cancelNew(); });
+    let fonts = null;
+    if (mids.has(frame)) {
+      const marks = await page.evaluate(async () => { const list = window.__litQa.markFonts(); document.body.offsetHeight; await window.__litQa.settle(); return list; });
+      const { root } = await cdp.send("DOM.getDocument", { depth: -1 });
+      const byMark = new Map();
+      const { nodeIds } = await cdp.send("DOM.querySelectorAll", { nodeId: root.nodeId, selector: "[data-lit-qa-run]" });
+      for (const nodeId of nodeIds) {
+        const { attributes } = await cdp.send("DOM.getAttributes", { nodeId });
+        const mark = attributes[attributes.indexOf("data-lit-qa-run") + 1];
+        byMark.set(mark, (await cdp.send("CSS.getPlatformFontsForNode", { nodeId })).fonts.map((font) => font.familyName));
+      }
+      fonts = marks.map((list) => [...new Set(list.flatMap((mark) => byMark.get(mark) ?? []))]);
+      await page.evaluate(() => window.__litQa.unmarkFonts());
+    }
+    samples.push({ frame, mid: mids.has(frame), runs, a, b, fonts });
+  }
+  return { track, samples, trackStep, allowed: [...allowed], canvasTexts: [...canvasTexts] };
+}
+
+// Turns the captures into gate rows. Copy runs (their text holds a copy line) FAIL; decor runs WARN.
+export function analyseQa(raw, context) {
+  const { width, height, fps, treatment } = context;
+  const copyLines = treatment.copy.lines.map((line) => ({ line, norm: normalize(line) }));
+  const isCopy = (run) => copyLines.some((copy) => run.norm.includes(copy.norm));
+  const safe = titleSafeBox(width, height);
+  const shortSide = Math.min(width, height);
+  const request = normalize(withoutQuotes(treatment.request)), idea = normalize(treatment.idea);
+  const fails = { contrast: [], safe: [], floor: [], decor: [], fonts: [] };
+  const warns = { contrast: [], moved: [], meta: new Set(), canvas: [], fonts: [], presence: null };
+  const seenVisible = new Set();
+  const trackByFrame = new Map(raw.track.map((entry) => [entry.frame, entry]));
+  let presenceHits = 0, presenceMids = 0;
+  const judged = [];
+  for (const sample of raw.samples) {
+    const A = rgbaOf(sample.a), B = rgbaOf(sample.b);
+    const grow = (run) => Math.max(2, 0.2 * run.fontSize * run.scale);
+    const textRects = sample.runs.flatMap((run) => run.rects.map(([x0, y0, x1, y1]) => [x0 - grow(run), y0 - grow(run), x1 + grow(run), y1 + grow(run)]));
+    const inText = (x, y) => textRects.some(([x0, y0, x1, y1]) => x >= x0 && x < x1 && y >= y0 && y < y1);
+    const diff = new Uint8Array(width * height);
+    let outside = 0;
+    for (let p = 0, i = 0; p < diff.length; p++, i += 4) {
+      if (Math.abs(A[i] - B[i]) > qaLimits.inkDelta || Math.abs(A[i + 1] - B[i + 1]) > qaLimits.inkDelta || Math.abs(A[i + 2] - B[i + 2]) > qaLimits.inkDelta) {
+        diff[p] = 255;
+        if (!inText(p % width, Math.floor(p / width))) outside += 1;
+      }
+    }
+    if (sample.mid) {
+      presenceMids += 1;
+      let n = 0, sum = 0, sumSq = 0;
+      for (let p = 0, i = 0; p < diff.length; p += 7, i += 28) {
+        if (inText(p % width, Math.floor(p / width))) continue;
+        const l = 0.2126 * linearLut[B[i]] + 0.7152 * linearLut[B[i + 1]] + 0.0722 * linearLut[B[i + 2]];
+        n += 1; sum += l; sumSq += l * l;
+      }
+      if (n && Math.sqrt(Math.max(0, sumSq / n - (sum / n) ** 2)) > qaLimits.presenceStd) presenceHits += 1;
+    }
+    if (outside > 0) { warns.moved.push(`frame ${sample.frame}: ${outside} pixels changed outside the text (state moved; sample discarded)`); continue; }
+    let visibleArea = 0, decorArea = 0;
+    sample.runs.forEach((run, index) => {
+      if (run.kind === "canvas") { if (run.opacity >= qaLimits.visibleOpacity && onScreen(run.rects, width, height)) seenVisible.add(run.norm); return; }
+      const mask = new Uint8Array(width * height);
+      let ink = 0;
+      for (const [x0, y0, x1, y1] of run.rects) {
+        for (let y = Math.max(0, Math.floor(y0)); y < Math.min(height, Math.ceil(y1)); y++) for (let x = Math.max(0, Math.floor(x0)); x < Math.min(width, Math.ceil(x1)); x++) {
+          const p = y * width + x;
+          if (diff[p] && !mask[p]) { mask[p] = 255; ink += 1; }
+        }
+      }
+      const visible = run.opacity >= qaLimits.visibleOpacity && onScreen(run.rects, width, height) && ink >= qaLimits.minInkPixels;
+      if (!visible) return;
+      seenVisible.add(run.norm);
+      const box = union(run.rects);
+      const area = (box[2] - box[0]) * (box[3] - box[1]);
+      visibleArea += area;
+      if (run.decor) decorArea += area;
+      const copy = isCopy(run);
+      if (run.decor && copy) fails.decor.push(`decor text "${run.text}" carries a copy line at frame ${sample.frame}`);
+      if (copy && !run.decor && run.rects.some(([x0, y0, x1, y1]) => x0 < safe[0] - 0.5 || y0 < safe[1] - 0.5 || x1 > safe[2] + 0.5 || y1 > safe[3] + 0.5)) fails.safe.push(`"${run.text}" leaves the central 90 % at frame ${sample.frame}`);
+      if (sample.fonts) {
+        const faces = sample.fonts[index] ?? [];
+        const foreign = faces.filter((face) => !raw.allowed.includes(face));
+        if (foreign.length) (copy && !run.decor ? fails.fonts : warns.fonts).push(`"${run.text}" draws with ${foreign.join(", ")} at frame ${sample.frame}`);
+      }
+      // Settled: the box moved less than 2 px against the neighbouring 1/10 s samples, opacity >= 0.95.
+      const key = keyOf(run, width, height);
+      const neighbours = [sample.frame - raw.trackStep, sample.frame + raw.trackStep].map((f) => trackByFrame.get(Math.round(f / raw.trackStep) * raw.trackStep)).filter(Boolean);
+      const settled = run.opacity >= qaLimits.judgedOpacity && neighbours.length > 0 && neighbours.every((entry) => {
+        const match = entry.runs.find((other) => keyOf(other, width, height) === key);
+        const mine = union(run.rects), theirs = match ? union(match.rects) : null;
+        return theirs && mine.every((v, k) => Math.abs(v - theirs[k]) < qaLimits.settledPx);
+      });
+      if (!settled) return;
+      const sizePx = run.fontSize * run.scale;
+      const measured = boxContrast(A, mask, width, height, { bbox: box, capHeightPx: sizePx, fill: run.gradient ? "gradient" : "solid", fontSizePx: sizePx, weight: run.weight }, shortSide / 1080, sizePx >= qaLimits.largeShare * shortSide);
+      if (!measured) return;
+      judged.push({ frame: sample.frame, text: run.text, ratio: Number(measured.ratio.toFixed(2)), floor: measured.floor, copy, decor: run.decor });
+      if (measured.ratio < measured.floor) (copy && !run.decor ? fails.contrast : warns.contrast).push(`"${run.text}" at frame ${sample.frame}: ${measured.ratio.toFixed(2)}:1 < ${measured.floor}:1`);
+    });
+    if (visibleArea > 0 && decorArea / visibleArea > qaLimits.decorShare) fails.decor.push(`decor text covers ${Math.round((100 * decorArea) / visibleArea)} % of the visible text at frame ${sample.frame}`);
+  }
+  // The 1/10 s track: visible copy runs for the reading floor, and every run for the meta-label lint.
+  const stepSec = raw.trackStep / fps;
+  for (const copy of copyLines) {
+    let run = 0, longest = 0;
+    for (const entry of raw.track) {
+      const shown = entry.runs.some((r) => r.norm.includes(copy.norm) && r.opacity >= qaLimits.visibleOpacity && onScreen(r.rects, width, height));
+      if (shown) seenVisible.add(copy.norm);
+      run = shown ? run + 1 : 0;
+      longest = Math.max(longest, run);
+    }
+    const floor = readingFloor(copy.line, "line");
+    if (longest > 0 && longest * stepSec < floor - qaLimits.floorTolerance) fails.floor.push(`"${copy.line}" is readable for ${(longest * stepSec).toFixed(1)} s; its floor is ${floor.toFixed(2)} s`);
+  }
+  for (const entry of raw.track) for (const run of entry.runs) {
+    if (!run.norm || run.opacity < qaLimits.visibleOpacity) continue;
+    if ((request.length >= 4 && (run.norm === request || run.norm.includes(request))) || (idea.length >= 4 && run.norm.includes(idea)) || fileName.test(run.text) || internalTerms.test(run.text)) warns.meta.add(`"${run.text}"`);
+  }
+  const registered = new Set(raw.samples.flatMap((sample) => sample.runs.filter((run) => run.kind === "canvas").map((run) => run.norm)));
+  for (const text of raw.canvasTexts) if (text.trim() && !registered.has(normalize(text))) warns.canvas.push(`"${text}"`);
+  if (presenceMids > 0 && presenceHits * 2 < presenceMids) warns.presence = `only ${presenceHits} of ${presenceMids} beat midpoints show structure outside the text once the words are hidden`;
+  const missing = copyLines.filter((copy) => ![...seenVisible].some((norm) => norm.includes(copy.norm))).map((copy) => copy.line);
+  const row = (list, pass) => (list.length ? { pass: false, detail: `${list.slice(0, 3).join("; ")}${list.length > 3 ? ` (+${list.length - 3} more)` : ""}` } : { pass: true, detail: pass });
+  const warnRow = (list, label) => (list.length ? { pass: false, warn: true, detail: `${label}: ${[...list].slice(0, 3).join("; ")}` } : null);
+  const checks = {
+    "TEXT-copy-found": missing.length ? { pass: false, detail: `never on screen: ${missing.map((line) => `"${line}"`).join(", ")}` } : { pass: true, detail: `${copyLines.length} copy line(s) found on screen` },
+    "TEXT-contrast": row(fails.contrast, `${judged.filter((j) => j.copy).length} settled copy measurements at or above 4.5:1 (3:1 large)`),
+    "TEXT-title-safe": row(fails.safe, "copy inside the central 90 %"),
+    "TEXT-reading-floor": row(fails.floor, "every copy line holds its reading floor"),
+    "TEXT-decor": row(fails.decor, "decor text carries no copy and stays under 25 % of the text"),
+    "TEXT-fonts": row(fails.fonts, `copy draws only with ${raw.allowed.join(", ")}`)
+  };
+  for (const [id, value] of Object.entries({ "TEXT-decor-contrast": warnRow(warns.contrast, "decor contrast"), "TEXT-moved": warnRow(warns.moved, "samples discarded"), "TEXT-meta-labels": warnRow([...warns.meta], "request, idea, file name or internal term on screen"),
+    "TEXT-canvas": warnRow(warns.canvas, "canvas text not measured"), "TEXT-decor-fonts": warnRow(warns.fonts, "decor fonts"), "TEXT-presence": warns.presence ? { pass: false, warn: true, detail: warns.presence } : null })) if (value) checks[id] = value;
+  return { checks, missing, judged, samples: raw.samples.map((sample) => ({ frame: sample.frame, mid: sample.mid, runs: sample.runs.length })), trackFrames: raw.track.length, allowedFaces: raw.allowed };
+}