@tryvitris/website-harness 0.0.0-stage → 0.1.0-beta.5

package/bin/chunks/chunk-HNORQ74T.js

@@ -0,0 +1,40 @@
+// src/cli/root.ts
+import { existsSync, readFileSync } from "node:fs";
+import { dirname, join, resolve } from "node:path";
+import { fileURLToPath } from "node:url";
+function findHarnessRoot(startDir) {
+  if ((process.env.VITRIS_HARNESS || process.env.VITRIS_KERNEL) && existsSync(process.env.VITRIS_HARNESS || process.env.VITRIS_KERNEL)) {
+    return resolve(process.env.VITRIS_HARNESS || process.env.VITRIS_KERNEL);
+  }
+  let curr = resolve(startDir || dirname(fileURLToPath(import.meta.url)));
+  for (let i = 0; i < 6; i++) {
+    const candidateTmpl = join(curr, "templates/site");
+    const candidatePkg = join(curr, "package.json");
+    if (existsSync(candidateTmpl) && existsSync(candidatePkg)) {
+      try {
+        const pkg = JSON.parse(readFileSync(candidatePkg, "utf8"));
+        if (["@tryvitris/website-harness", "@tryvitris/harness", "@vitris/harness", "@vitris/kernel"].includes(pkg.name)) {
+          return curr;
+        }
+      } catch {
+      }
+    }
+    const parent = dirname(curr);
+    if (parent === curr) break;
+    curr = parent;
+  }
+  const moduleDir = dirname(fileURLToPath(import.meta.url));
+  for (const rel of [".", "..", "../.."]) {
+    const target = resolve(moduleDir, rel);
+    if (existsSync(join(target, "templates/site"))) {
+      return target;
+    }
+  }
+  throw new Error("Could not locate @tryvitris/website-harness root directory containing templates/site");
+}
+var findKernelRoot = findHarnessRoot;
+
+export {
+  findHarnessRoot,
+  findKernelRoot
+};

package/bin/chunks/chunk-IKNMBGGD.js

@@ -0,0 +1,217 @@
+import {
+  files,
+  fingerprint,
+  json,
+  save,
+  sourceHash,
+  within
+} from "./chunk-T6PE4KN4.js";
+
+// src/agent/lighthouse-browser.ts
+import { rm, realpath } from "node:fs/promises";
+import { basename, relative, resolve, isAbsolute } from "node:path";
+import { tmpdir } from "node:os";
+import { launch } from "chrome-launcher";
+function lighthouseChromeFlags(platform = process.platform, ci = process.env.CI === "true") {
+  return ["--headless=new", "--no-first-run", "--disable-dev-shm-usage", ...platform === "linux" && ci ? ["--no-sandbox"] : []];
+}
+async function lighthouseBrowser(chromePath) {
+  const executable = chromePath || process.env.CHROME_PATH || (await import("playwright")).chromium.executablePath();
+  return launch({ chromePath: executable, chromeFlags: lighthouseChromeFlags() });
+}
+async function closeLighthouseBrowser(chrome) {
+  const raw = chrome.process.spawnargs.find((arg) => arg.startsWith("--user-data-dir="))?.slice("--user-data-dir=".length);
+  const profile = raw ? resolve(raw) : void 0, base = resolve(tmpdir());
+  const rel = profile ? relative(base, profile) : "";
+  const owned = Boolean(profile && rel && !rel.startsWith("..") && !isAbsolute(rel) && basename(profile).startsWith("lighthouse."));
+  try {
+    chrome.kill();
+  } catch (error) {
+    if (!owned || !["EPERM", "EBUSY", "ENOTEMPTY"].includes(error.code || "")) throw error;
+    let actualProfile;
+    try {
+      actualProfile = await realpath(profile);
+    } catch (missing) {
+      if (missing.code === "ENOENT") return;
+      throw missing;
+    }
+    const actualRel = relative(await realpath(base), actualProfile);
+    if (!actualRel || actualRel.startsWith("..") || isAbsolute(actualRel)) throw error;
+    await rm(actualProfile, { recursive: true, force: true, maxRetries: 20, retryDelay: 200 });
+  }
+}
+
+// src/agent/performance.ts
+import { existsSync as existsSync2, readFileSync } from "node:fs";
+import { dirname, join as join2, relative as relative2 } from "node:path";
+import { createHash } from "node:crypto";
+
+// src/agent/api-contracts.ts
+import { existsSync } from "node:fs";
+import { join } from "node:path";
+async function checkApiContracts(root, origin) {
+  const launch2 = existsSync(join(root, "launch.json")) ? json(join(root, "launch.json")) : {};
+  const failures = [];
+  if (launch2.apiChecks !== void 0 && !Array.isArray(launch2.apiChecks)) return ["launch.apiChecks must be an array"];
+  for (const check of launch2.apiChecks || []) {
+    try {
+      if (typeof check.url !== "string") throw new Error("API contract needs a URL");
+      const url = new URL(check.url, origin);
+      if (!["http:", "https:"].includes(url.protocol) || url.username || url.password) throw new Error("API contract must use an HTTP(S) URL without credentials");
+      const response = await fetch(url, { signal: AbortSignal.timeout(15e3), cache: "no-cache", redirect: "error" });
+      if (!response.ok) throw new Error(`HTTP ${response.status}`);
+      if (!/\bapplication\/(?:[a-z0-9.-]+\+)?json\b/i.test(response.headers.get("content-type") || "")) throw new Error(`Expected API JSON, received ${response.headers.get("content-type") || "no Content-Type"}`);
+      await response.json();
+    } catch (error) {
+      failures.push(`${check.url || "(invalid API check)"}: ${error instanceof Error ? error.message : String(error)}`);
+    }
+  }
+  return failures;
+}
+
+// src/agent/performance.ts
+var PERFORMANCE_POLICY = "vitris-mobile-2026-10-15";
+function sampleFromLighthouse(lhr) {
+  if (!lhr || lhr.runtimeError || lhr.configSettings?.formFactor !== "mobile" || lhr.categories?.performance?.score == null) throw new Error(lhr?.runtimeError?.message || "No valid mobile Lighthouse result");
+  const metric = (id) => lhr.audits?.[id]?.numericValue;
+  return { score: lhr.categories.performance.score * 100, lcp: metric("largest-contentful-paint"), tbt: metric("total-blocking-time"), cls: metric("cumulative-layout-shift"), transfer: metric("total-byte-weight") };
+}
+function performancePolicy(root) {
+  const launch2 = existsSync2(join2(root, "launch.json")) ? json(join2(root, "launch.json")) : {};
+  const p = launch2.performance || {};
+  const policy = { enabled: p.enabled === true, runs: Number(p.runs ?? 3), routes: p.routes ?? [], score: Number(p.score ?? 95), lcp: Number(p.lcp ?? 2500), tbt: Number(p.tbt ?? 200), cls: Number(p.cls ?? 0.1), transfer: Number(p.transfer ?? 1.5 * 1024 * 1024) };
+  if (!Number.isInteger(policy.runs) || policy.runs < 3 || policy.runs > 5 || !Array.isArray(policy.routes) || policy.routes.some((r) => typeof r !== "string" || !r.startsWith("/") || r.startsWith("//") || /[?#\\]/.test(r))) throw new Error("performance requires 3\u20135 runs and local route paths");
+  for (const key of ["score", "lcp", "tbt", "cls", "transfer"]) if (!Number.isFinite(policy[key]) || policy[key] <= 0 || key === "score" && policy[key] > 100) throw new Error(`Invalid performance.${key}`);
+  return policy;
+}
+var performanceConfigHash = (root) => fingerprint(root, ["launch.json", "onboarding/storyboard.json"]);
+function performanceRoutes(root, policy = performancePolicy(root)) {
+  const dist = join2(root, "dist");
+  const routes = files(dist).filter((f) => f.endsWith("index.html") && !f.includes("cookie-compliance")).map((file) => {
+    const path = "/" + relative2(dist, file).replaceAll("\\", "/").replace(/index\.html$/, "");
+    const html = readFileSync(file, "utf8");
+    let weight = Buffer.byteLength(html);
+    for (const url of new Set([...html.matchAll(/\b(?:src|poster)=["']([^"']+)["']/g)].map((m) => m[1]))) {
+      if (/^(?:[a-z]+:|\/\/|#)/i.test(url)) continue;
+      try {
+        const asset = within(dist, url.startsWith("/") ? url.slice(1) : join2(relative2(dist, dirname(file)), url));
+        if (existsSync2(asset)) weight += readFileSync(asset).length;
+      } catch {
+      }
+    }
+    return { path, weight };
+  });
+  const normalized = (r) => r === "/" ? "/" : r.replace(/\/$/, "") + "/";
+  const interiors = routes.filter((r) => r.path !== "/").sort((a, b) => b.weight - a.weight || a.path.localeCompare(b.path));
+  const story = existsSync2(join2(root, "onboarding/storyboard.json")) ? json(join2(root, "onboarding/storyboard.json")) : {};
+  const representative = story.pages?.find((p) => p.path !== "/" && p.representative)?.path;
+  const selected = ["/", ...representative ? [representative] : interiors[1] ? [interiors[1].path] : [], ...interiors[0] ? [interiors[0].path] : [], ...policy.routes].map(normalized);
+  for (const path of selected) if (!routes.some((r) => r.path === path)) throw new Error(`Performance route is not built: ${path}`);
+  return [...new Set(selected)];
+}
+function summarizePerformance(samples, policy) {
+  if (samples.length !== policy.runs) throw new Error(`Expected ${policy.runs} valid mobile samples`);
+  const median = {};
+  for (const key of ["score", "lcp", "tbt", "cls", "transfer"]) {
+    if (samples.some((s) => !Number.isFinite(s[key]) || s[key] < 0)) throw new Error(`Missing or invalid Lighthouse metric: ${key}`);
+    const values = samples.map((s) => s[key]).sort((a, b) => a - b);
+    const middle = Math.floor(values.length / 2);
+    median[key] = values.length % 2 ? values[middle] : (values[middle - 1] + values[middle]) / 2;
+  }
+  const failures = ["score", "lcp", "tbt", "cls", "transfer"].filter((key) => key === "score" ? median[key] < policy[key] : median[key] > policy[key]).map((key) => `${key} median ${median[key].toFixed(3)} ${key === "score" ? "<" : ">"} budget ${policy[key]}`);
+  return { median, failures };
+}
+async function measurePerformance(root, origin, options = {}) {
+  const policy = performancePolicy(root);
+  const report = { version: 1, policy: PERFORMANCE_POLICY, configHash: performanceConfigHash(root), sourceHash: sourceHash(root), distHash: fingerprint(root, ["dist"]), origin, scope: options.remote ? "remote" : "local", routes: [], failures: [] };
+  try {
+    if (options.remote) {
+      const apiFailures = await checkApiContracts(root, origin);
+      if (apiFailures.length) throw new Error(apiFailures.join("\n"));
+      const expected = json(join2(root, "dist/build-evidence.json"));
+      const response = await fetch(new URL("/build-evidence.json", origin), { signal: AbortSignal.timeout(15e3), cache: "no-cache" });
+      if (!response.ok || !response.headers.get("content-type")?.includes("application/json")) throw new Error("Hosted build evidence must return JSON from this deployment");
+      const actual = await response.json();
+      if (actual.sourceHash !== expected.sourceHash || actual.compilerHash !== expected.compilerHash) throw new Error("Hosted build does not match the local verified source/compiler");
+    }
+    const { default: lighthouse } = await import("lighthouse");
+    for (const path of performanceRoutes(root, policy)) {
+      const route = { path, samples: [], failures: [], reports: [] };
+      report.routes.push(route);
+      for (let run = 1; run <= policy.runs; run++) {
+        let chrome;
+        try {
+          chrome = await lighthouseBrowser();
+          const result = await lighthouse(new URL(path, origin).href, { port: chrome.port, output: "json", logLevel: "error", onlyCategories: ["performance"], maxWaitForLoad: 3e4 });
+          const lhr = result?.lhr;
+          const sample = sampleFromLighthouse(lhr);
+          if (!lhr) throw new Error("Missing Lighthouse result");
+          if (lhr.audits["http-status-code"]?.score === 0) throw new Error("Lighthouse reached a non-200 page");
+          if ((new URL(lhr.finalDisplayedUrl).pathname.replace(/\/$/, "") || "/") !== (path.replace(/\/$/, "") || "/")) throw new Error("Lighthouse reached a different route");
+          route.finalUrl = lhr.finalDisplayedUrl;
+          route.samples.push(sample);
+          const name = `agent/reviews/performance-runs/${report.distHash}/${options.remote ? "remote" : "local"}-${Buffer.from(path).toString("hex")}-${run}.json`;
+          save(join2(root, name), lhr);
+          route.reports.push({ path: name, sha256: createHash("sha256").update(readFileSync(join2(root, name))).digest("hex") });
+          options.log?.(`performance: ${path} mobile ${run}/${policy.runs}: ${Math.round(route.samples.at(-1).score)}`);
+        } catch (error) {
+          route.failures.push(`Run ${run}: ${error instanceof Error ? error.message : String(error)}`);
+        } finally {
+          if (chrome) await closeLighthouseBrowser(chrome);
+        }
+      }
+      try {
+        const result = summarizePerformance(route.samples, policy);
+        route.median = result.median;
+        route.failures.push(...result.failures);
+      } catch (error) {
+        route.failures.push(String(error));
+      }
+    }
+  } catch (error) {
+    report.failures.push(error instanceof Error ? error.message : String(error));
+  }
+  report.failures.push(...report.routes.flatMap((r) => r.failures.map((f) => `${r.path}: ${f}`)));
+  save(join2(root, `agent/reviews/performance${options.remote ? "-remote" : ""}.json`), report);
+  return report;
+}
+function performanceEvidenceFailures(root) {
+  if (!performancePolicy(root).enabled) return [];
+  const path = join2(root, "agent/reviews/performance.json");
+  if (!existsSync2(path)) return ["Mobile performance evidence is missing; run npm run verify:performance"];
+  const report = json(path), policy = performancePolicy(root);
+  const failures = [...report.failures];
+  if (report.policy !== PERFORMANCE_POLICY || report.scope !== "local" || report.sourceHash !== sourceHash(root) || report.distHash !== fingerprint(root, ["dist"]) || report.configHash !== performanceConfigHash(root)) failures.push("Mobile performance evidence is stale");
+  for (const route of performanceRoutes(root, policy)) {
+    const item = report.routes.find((r) => r.path === route);
+    if (!item || item.reports.length !== policy.runs) {
+      failures.push(`Mobile performance evidence missing: ${route}`);
+      continue;
+    }
+    const samples = [];
+    for (const saved of item.reports) {
+      const file = within(root, saved.path);
+      if (!existsSync2(file) || createHash("sha256").update(readFileSync(file)).digest("hex") !== saved.sha256) failures.push(`Lighthouse report changed: ${saved.path}`);
+      else try {
+        samples.push(sampleFromLighthouse(json(file)));
+      } catch (error) {
+        failures.push(String(error));
+      }
+    }
+    if (JSON.stringify(samples) !== JSON.stringify(item.samples)) failures.push(`Lighthouse summary differs from raw measurements: ${route}`);
+    try {
+      failures.push(...summarizePerformance(samples, policy).failures.map((f) => `${route}: ${f}`));
+    } catch (error) {
+      failures.push(String(error));
+    }
+  }
+  return failures;
+}
+
+export {
+  lighthouseBrowser,
+  closeLighthouseBrowser,
+  performancePolicy,
+  measurePerformance,
+  performanceEvidenceFailures
+};

package/bin/chunks/chunk-JCRGE6AL.js

@@ -0,0 +1,14 @@
+// src/cli/types.ts
+var EXIT_CODES = {
+  SUCCESS: 0,
+  GENERIC_ERROR: 1,
+  CONFIG_OR_CLI_ERROR: 2,
+  PRECONDITION_FAILED: 3,
+  GATES_FAILED: 4,
+  DEPLOYMENT_FAILED: 5,
+  ABORTED: 6
+};
+
+export {
+  EXIT_CODES
+};

package/bin/chunks/chunk-LKN75JGA.js

@@ -0,0 +1,63 @@
+import {
+  defaultTheme
+} from "./chunk-YYPYYOEV.js";
+
+// src/theme.ts
+function mergeTheme(partial) {
+  const merged = { ...defaultTheme, ...partial };
+  if (!partial?.colorFocus) merged.colorFocus = merged.colorAccent;
+  if (!partial?.colorSurface2) {
+    merged.colorSurface2 = partial?.colorSurface2 || defaultTheme.colorSurface2;
+  }
+  if (!partial?.radiusLg) merged.radiusLg = partial?.radiusLg || defaultTheme.radiusLg;
+  return merged;
+}
+function themeCss(tokens) {
+  const t = mergeTheme(tokens);
+  return `:root {
+  --color-bg: ${t.colorBg};
+  --color-text: ${t.colorText};
+  --color-muted: ${t.colorMuted};
+  --color-accent: ${t.colorAccent};
+  --color-accent-text: ${t.colorAccentText};
+  --color-surface: ${t.colorSurface};
+  --color-surface-2: ${t.colorSurface2};
+  --color-border: ${t.colorBorder};
+  --color-focus: ${t.colorFocus || t.colorAccent};
+  --font-body: ${t.fontBody};
+  --font-display: ${t.fontDisplay};
+  --radius: ${t.radius};
+  --radius-lg: ${t.radiusLg};
+  --radius-pill: ${t.radiusPill};
+  --max-width: ${t.maxWidth};
+  --space-1: 0.25rem;
+  --space-2: 0.5rem;
+  --space-3: 0.75rem;
+  --space-4: 1rem;
+  --space-5: 1.5rem;
+  --space-6: 2rem;
+  --space-7: 3rem;
+  --space-8: 4.5rem;
+  --space-9: 6rem;
+  --step-0: ${t.typeStep0 || "clamp(0.9rem, 0.85rem + 0.2vw, 1rem)"};
+  --step-1: ${t.typeStep1 || "clamp(1rem, 0.95rem + 0.3vw, 1.125rem)"};
+  --step-2: ${t.typeStep2 || "clamp(1.2rem, 1.05rem + 0.6vw, 1.5rem)"};
+  --step-3: ${t.typeStep3 || "clamp(1.6rem, 1.25rem + 1.2vw, 2.25rem)"};
+  --step-4: ${t.typeStep4 || "clamp(2.1rem, 1.5rem + 2.2vw, 3.5rem)"};
+  --step-5: ${t.typeStep5 || "clamp(2.6rem, 1.7rem + 3.4vw, 4.75rem)"};
+  --tap-min: 44px;
+  --header-h: 4.75rem;
+  --section-y: ${t.sectionY || "clamp(3.5rem, 3rem + 3vw, 6rem)"};
+  --blur-header: 12px;
+  --shadow-1: 0 1px 2px color-mix(in srgb, var(--color-text) 6%, transparent);
+  --shadow-2: 0 8px 24px color-mix(in srgb, var(--color-text) 8%, transparent);
+  --shadow-3: 0 20px 48px color-mix(in srgb, var(--color-text) 12%, transparent);
+  --ring: 0 0 0 3px color-mix(in srgb, var(--color-focus) 35%, transparent);
+}
+`;
+}
+
+export {
+  mergeTheme,
+  themeCss
+};

package/bin/chunks/chunk-M2ETYSVJ.js

@@ -0,0 +1,176 @@
+import {
+  files,
+  fingerprint,
+  json,
+  sourceHash,
+  within
+} from "./chunk-T6PE4KN4.js";
+
+// src/agent/production-quality.ts
+import { createHash } from "node:crypto";
+import { existsSync, readFileSync } from "node:fs";
+import { join } from "node:path";
+function productionQuality(root) {
+  const launch = existsSync(join(root, "launch.json")) ? json(join(root, "launch.json")) : {};
+  if (launch.productionQuality === void 0) return false;
+  if (launch.productionQuality !== "source-and-realization-v1") throw new Error("Unsupported productionQuality policy");
+  return true;
+}
+var REALIZATION_AXES = ["opening", "navigation", "typography", "imagery", "density", "proof", "interior", "mobile", "actions"];
+var sha256 = (bytes) => createHash("sha256").update(bytes).digest("hex");
+var text = (s) => typeof s === "string" && s.trim().length > 0;
+function normalizeCoverage(s) {
+  return s.normalize("NFKD").toLowerCase().replace(/[’'`]/g, "").replace(/[^\p{L}\p{N}]+/gu, " ").trim();
+}
+var contains = (haystack, needle) => (" " + normalizeCoverage(haystack) + " ").includes(" " + normalizeCoverage(needle) + " ");
+var CONTENT_SOURCE = ["onboarding/brief.json", "onboarding/copy", "onboarding/raw"];
+var CONTENT_OPERATOR = "agent/content-requirements.json";
+var contentOperatorHash = (root) => fingerprint(root, [CONTENT_OPERATOR, "launch.json"]);
+function contentOperator(root) {
+  return existsSync(join(root, CONTENT_OPERATOR)) ? json(join(root, CONTENT_OPERATOR)) : json(join(root, "launch.json")).contentRequirements || { version: 1, requirements: [] };
+}
+var CONTENT_LEDGER = "onboarding/content-requirements.json";
+function applyProductionQualityGraph(root, graph) {
+  if (!productionQuality(root)) return graph;
+  for (const n of graph.nodes) {
+    if (n.id === "harvest" || n.id === "launch") continue;
+    n.refs = [.../* @__PURE__ */ new Set([...n.refs || [], "production-quality"])];
+    n.optionalInputs = [.../* @__PURE__ */ new Set([...n.optionalInputs || [], "launch.json", CONTENT_OPERATOR, ...n.id !== "media" ? [CONTENT_LEDGER] : []])];
+    if (n.id === "business") n.writes = [.../* @__PURE__ */ new Set([...n.writes, CONTENT_LEDGER])];
+    if (["representative", "pages"].includes(n.id)) n.writes = [.../* @__PURE__ */ new Set([...n.writes, "onboarding/direction-deviations.json"])];
+    else if (["representative-review", "representative-quality", "visual-review", "content-review", "preview"].includes(n.id)) n.optionalInputs = [.../* @__PURE__ */ new Set([...n.optionalInputs, "onboarding/direction-deviations.json"])];
+    if (n.id === "content-review") n.writes = [.../* @__PURE__ */ new Set([...n.writes, "agent/reviews/content-coverage.json"])];
+  }
+  return graph;
+}
+function validateContentLedger(root) {
+  const errors = [];
+  const b = json(join(root, "onboarding/business.json"));
+  const ledger = json(join(root, CONTENT_LEDGER));
+  const operator = contentOperator(root);
+  if (ledger.version !== 1 || ledger.sourceHash !== fingerprint(root, CONTENT_SOURCE) || ledger.operatorHash !== contentOperatorHash(root)) errors.push("Content requirements have stale source/operator hashes; reopen business");
+  if (!Array.isArray(ledger.items) || !ledger.items.length) return [...errors, "Business must enumerate source-backed content requirements"];
+  const ids = new Set(ledger.items.map((i) => i.id));
+  if (ids.size !== ledger.items.length) errors.push("Duplicate content requirement IDs");
+  for (const req of operator.requirements) {
+    let captured = "";
+    try {
+      captured = readFileSync(within(root, req.source), "utf8");
+    } catch {
+    }
+    if (!text(req.claim) || !text(req.excerpt) || !contains(captured, req.excerpt)) errors.push(`Requirement source missing: ${req.id}`);
+    const item = ledger.items.find((i) => i.id === req.id);
+    if (!item) errors.push(`Unaccounted source requirement: ${req.id} (${req.claim})`);
+    else if (item.disposition === "excluded" && req.allowExclusion !== true) errors.push(`Required source item cannot be excluded: ${req.id}`);
+  }
+  for (const item of ledger.items) {
+    if (!["required", "excluded"].includes(item.disposition)) errors.push(`Invalid content disposition: ${item.id}`);
+    if (item.disposition === "excluded") {
+      if (!text(item.exclusion?.reason) || !text(item.exclusion?.evidence)) errors.push(`Exclusion needs specific reason and evidence: ${item.id}`);
+    } else {
+      if (!item.factIds?.length || item.factIds.some((id) => !b.facts.some((f) => f.id === id))) errors.push(`Requirement needs supported business fact IDs: ${item.id}`);
+      const req = operator.requirements.find((r) => r.id === item.id);
+      if (req && ![req.claim, ...req.equivalents].some((a) => contains(b.facts.filter((f) => item.factIds?.includes(f.id)).map((f) => f.claim).join(" "), a))) errors.push(`Source requirement absent from associated business facts: ${item.id}`);
+      if (!req && !item.equivalents?.some(text)) errors.push(`Requirement needs faithful display wording: ${item.id}`);
+      if (item.equivalents?.length && !text(item.equivalenceReason)) errors.push(`Paraphrase needs equivalence rationale: ${item.id}`);
+    }
+  }
+  for (const f of b.facts) if (!ledger.items.some((i) => i.factIds?.includes(f.id))) errors.push(`Business fact has no coverage disposition: ${f.id}`);
+  return errors;
+}
+function coverageAudit(root, mode = "rendered") {
+  const errors = validateContentLedger(root);
+  const ledger = json(join(root, CONTENT_LEDGER));
+  const operator = contentOperator(root).requirements;
+  const copy = json(join(root, "onboarding/copy-plan.json"));
+  const passages = [];
+  if (mode === "copy") for (const p of copy.pages) for (const s of p.sections) passages.push({ path: p.path, section: s.id, text: s.heading + " " + s.body, factIds: s.factIds });
+  else {
+    const report = json(join(root, "agent/reviews/browser.json"));
+    if (report.sourceHash !== sourceHash(root) || report.distHash !== fingerprint(root, ["dist"])) errors.push("Rendered coverage browser evidence is stale");
+    for (const c of report.checks) if (c.motion !== "normal") {
+      if (!text(c.visibleText)) errors.push(`Missing visible rendered text: ${c.path} ${c.width}`);
+      else passages.push({ path: c.path, section: "rendered document", width: c.width, text: c.visibleText });
+    }
+  }
+  const results = ledger.items.map((item) => {
+    if (item.disposition === "excluded") return { id: item.id, disposition: "excluded", exclusion: item.exclusion, matches: [] };
+    const req = operator.find((r) => r.id === item.id);
+    const aliases = req ? [req.claim, ...req.equivalents] : item.equivalents;
+    const accepted = passages.filter((p) => aliases.some((a) => text(a) && contains(p.text, a)) && (mode !== "copy" || item.factIds.every((id) => p.factIds?.includes(id))));
+    const widths = mode === "copy" ? [void 0] : [375, 1080];
+    for (const width of widths) if (!accepted.some((p) => p.width === width)) errors.push(`Missing required content: ${item.id}${width ? ` at ${width}px` : " in approved copy"}; preserve an individual faithful statement, or reopen business for an evidenced exclusion`);
+    return { id: item.id, disposition: item.disposition, matches: accepted.map((p) => ({ path: p.path, section: p.section, width: p.width, excerpt: p.text.slice(Math.max(0, normalizeCoverage(p.text).indexOf(normalizeCoverage(aliases[0] || "")) - 80), 600) })) };
+  });
+  return { version: 1, mode, subjectHash: fingerprint(root, [CONTENT_LEDGER, CONTENT_OPERATOR, "launch.json", "onboarding/business.json", "onboarding/copy-plan.json", ...mode === "rendered" ? ["dist", "agent/reviews/browser.json"] : []]), passed: errors.length === 0, errors, results };
+}
+function validateMediaInspections(root) {
+  const errors = [];
+  const inventory = json(join(root, "onboarding/media-inventory.json"));
+  for (const a of inventory.assets.filter((a2) => a2.disposition === "use")) {
+    const p = within(root, a.path.replace(/^\//, ""));
+    if (!a.inspected || !a.sha256 || !existsSync(p) || sha256(readFileSync(p)) !== a.sha256 || a.inspection?.assetHash !== a.sha256 || !text(a.inspection?.description) || !a.inspection?.evidence?.length) errors.push(`Media inspection must be byte-bound before sealing: ${a.id}; inspect at media, or use art revise --kind inspection to reopen that owner`);
+    else for (const e of a.inspection.evidence) if (!existsSync(within(root, e.replace(/^\//, "")))) errors.push(`Missing media inspection evidence: ${a.id} ${e}`);
+  }
+  return errors;
+}
+function validateRealization(root, node) {
+  const errors = [];
+  const d = json(join(root, "onboarding/direction.json"));
+  const contract = d.realizationContract;
+  const ids = new Set((d.decisions || []).map((v) => v.id));
+  if (contract?.version !== 1 || !Array.isArray(contract.axes)) return ["Direction requires realizationContract version 1 with nine observable axes"];
+  for (const axis of REALIZATION_AXES) {
+    const c = contract.axes.find((a) => a.axis === axis);
+    if (!c || !text(c.intention) || !text(c.observable) || !c.decisionIds?.length || c.decisionIds.some((id) => !ids.has(id))) errors.push(`Direction realization incomplete: ${axis}`);
+  }
+  if (["storyboard", "representative-review", "visual-review"].includes(node)) {
+    const story = json(join(root, "onboarding/storyboard.json"));
+    for (const axis of REALIZATION_AXES) {
+      const map = story.realizationMap?.find((m) => m.axis === axis);
+      if (!map || !text(map.implementation) || !map.routes?.length || map.routes.some((p) => !story.pages.some((s) => s.path === p))) errors.push(`Storyboard must carry direction axis: ${axis}`);
+    }
+  }
+  if (["representative-review", "visual-review"].includes(node)) {
+    const browserPath = `agent/reviews/${node === "visual-review" ? "browser" : "representative-browser"}.json`;
+    const browser = json(join(root, browserPath));
+    const review = json(join(root, `agent/reviews/${node}.json`));
+    const fidelity = review.directionFidelity;
+    const expected = fingerprint(root, ["onboarding/direction.json", "onboarding/storyboard.json", "onboarding/direction-deviations.json", browserPath]);
+    if (fidelity?.subjectHash !== expected) return [...errors, "Rendered direction fidelity evidence is stale or missing"];
+    const deviations = existsSync(join(root, "onboarding/direction-deviations.json")) ? json(join(root, "onboarding/direction-deviations.json")).deviations || [] : [];
+    for (const axis of REALIZATION_AXES) for (const width of [375, 1080]) {
+      const o = fidelity.observations?.find((o2) => o2.axis === axis && o2.width === width);
+      const c = browser.checks.find((c2) => c2.width === width && c2.screenshot === o?.screenshot);
+      if (!o || !c || axis === "interior" && c.path === "/" || axis === "opening" && c.path !== "/" || !text(o.observed) || !text(o.relationship) || !existsSync(within(root, o.screenshot)) || o.sha256 !== sha256(readFileSync(within(root, o.screenshot))) || !["survived", "justified-deviation"].includes(o.verdict)) errors.push(`Rendered direction needs current inspected evidence: ${axis} ${width}`);
+      else if (o.verdict === "justified-deviation" && !deviations.some((v) => v.id === o.deviationId && v.axis === axis && text(v.reason) && text(v.preservedConstraints))) errors.push(`Unjustified direction deviation: ${axis}`);
+    }
+  }
+  return errors;
+}
+function productionQualityFailures(root, node) {
+  if (!productionQuality(root)) return [];
+  if (["business", "business-review"].includes(node)) return validateContentLedger(root);
+  if (node === "media") return validateMediaInspections(root);
+  if (["direction", "direction-review", "storyboard", "representative-review", "visual-review"].includes(node)) return validateRealization(root, node);
+  if (node === "copy-expansion") return coverageAudit(root, "copy").errors;
+  if (node === "content-review") {
+    const audit = coverageAudit(root);
+    const retained = json(join(root, "agent/reviews/content-coverage.json"));
+    return [...audit.errors, ...JSON.stringify(audit) !== JSON.stringify(retained) ? ["Content coverage evidence stale or incomplete; regenerate from current browser text"] : []];
+  }
+  return [];
+}
+function hasAnalyticsRuntime(root) {
+  return files(join(root, "dist")).filter((p) => p.endsWith(".html")).some((p) => /\bdata-kernel=|<script[^>]+src=["'][^"']*\/beacon\.js["']/i.test(readFileSync(p, "utf8")));
+}
+
+export {
+  productionQuality,
+  CONTENT_OPERATOR,
+  CONTENT_LEDGER,
+  applyProductionQualityGraph,
+  coverageAudit,
+  productionQualityFailures,
+  hasAnalyticsRuntime
+};