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

package/bin/chunks/chunk-YQYHROLZ.js

@@ -0,0 +1,1023 @@
+import {
+  artifactManifest
+} from "./chunk-XL2DRAYI.js";
+import {
+  sourceRevision
+} from "./chunk-3CTBXY5K.js";
+import {
+  previewServer
+} from "./chunk-WEFDVXFX.js";
+import {
+  PRESERVE_HEIGHT,
+  PRESERVE_WIDTHS,
+  SUPPORTED_REACT_BLOCKS,
+  approvedEmbedUrl,
+  cancelledReviewTelemetry,
+  iframeSources,
+  isReadOnlyEmbedRequest,
+  pageFile,
+  preserveConfig,
+  preserveManifest,
+  preserveRuntime,
+  providerConsoleWarning,
+  readOnlyEmbedProvider,
+  unresolvedCaptureBlockers
+} from "./chunk-E5Y46VBX.js";
+import {
+  save,
+  within
+} from "./chunk-T6PE4KN4.js";
+
+// src/preserve/capture.ts
+import { createHash, randomUUID } from "node:crypto";
+import { Buffer } from "node:buffer";
+import { existsSync, mkdirSync, renameSync, writeFileSync } from "node:fs";
+import { dirname, extname, join } from "node:path";
+import { chromium } from "playwright";
+import { parse as parse2, serialize } from "parse5";
+
+// src/preserve/components.ts
+import { parse } from "parse5";
+var attr = (n, key) => n.attrs?.find((a) => a.name === key)?.value;
+var children = (n) => n.childNodes || [];
+var nodes = (n) => [n, ...children(n).flatMap(nodes)];
+function isInertFrame(node) {
+  return node.tagName === "iframe" && attr(node, "srcdoc") === void 0 && (!attr(node, "src") || attr(node, "src") === "about:blank") && !attr(node, "data-src");
+}
+function supportsStaticLegacyComponent(node) {
+  const kind = attr(node, "uniquecomponent");
+  if (!["blog-1", "iframe-1", "maps-1", "accordion-1"].includes(kind)) return false;
+  if (["iframe-1", "maps-1"].includes(kind) && !nodes(node).some((n) => n.tagName === "iframe")) return false;
+  if (kind === "accordion-1" && !nodes(node).some((n) => attr(n, "data-toggle") === "collapse")) return false;
+  const visit = (n, hidden = false) => {
+    const cls = attr(n, "class") || "";
+    hidden ||= /\bd-none\b/.test(cls) && !/\bd-(?:sm|md|lg|xl)-(?:block|flex|inline|table|grid)/.test(cls) || /display\s*:\s*none/i.test(attr(n, "style") || "");
+    if (n.tagName === "script" && attr(n, "type") !== "application/ld+json") return false;
+    if (n.tagName === "iframe" && !isInertFrame(n) && !(attr(n, "srcdoc") === void 0 && approvedEmbedUrl(attr(n, "src") || ""))) return false;
+    if (["object", "embed", "canvas"].includes(n.tagName)) return false;
+    if (!hidden) {
+      if (["input", "select", "textarea", "form"].includes(n.tagName)) return false;
+      const handled = ["collapse", "modal"].includes(attr(n, "data-toggle")) || attr(n, "data-dismiss") === "modal";
+      const callback = n.tagName === "button" || attr(n, "role") === "button" || n.tagName === "a" && (/^(javascript:)/i.test(attr(n, "href") || "") || !attr(n, "href") && /\b(btn|page-link)\b/.test(cls));
+      if (callback && !handled) return false;
+    }
+    return children(n).every((c) => visit(c, hidden));
+  };
+  return visit(node);
+}
+function staticLegacyComponents(html) {
+  const all = nodes(parse(html));
+  return new Set(["blog-1", "iframe-1", "maps-1", "accordion-1"].filter((kind) => {
+    const matches = all.filter((n) => attr(n, "uniquecomponent") === kind);
+    return matches.length > 0 && matches.every(supportsStaticLegacyComponent);
+  }));
+}
+function repairedExternalNavigation(original, authored, sourceUrl) {
+  const source = nodes(parse(original)).filter((n) => n.tagName === "a"), copy = nodes(parse(authored)).filter((n) => n.tagName === "a"), result = /* @__PURE__ */ new Set();
+  for (const n of source) {
+    const href = attr(n, "href") || "";
+    let expected;
+    if (/^\/?www\.google\.com\/maps(?:\?|$)/.test(href)) expected = "https://" + href.replace(/^\//, "");
+    if (/^\/?\(?\d{3}\)?(?:%20|\s)+\d{3}-\d{4}$/.test(href)) expected = "tel:" + decodeURIComponent(href).replace(/\D/g, "");
+    if (!expected) continue;
+    const path = new URL(href, sourceUrl).pathname;
+    if (copy.some((n2) => {
+      const marker = attr(n2, "data-preserve-repaired-link");
+      return marker !== void 0 && new URL(marker, sourceUrl).pathname === path && attr(n2, "href") === expected;
+    }) && !copy.some((n2) => {
+      try {
+        const url = new URL(attr(n2, "href") || "", sourceUrl);
+        return url.origin === new URL(sourceUrl).origin && url.pathname === path;
+      } catch {
+        return false;
+      }
+    })) result.add(path);
+  }
+  return result;
+}
+function disabledLegacyServices(original, authored, authorized) {
+  if (!authorized) return false;
+  const source = nodes(parse(original)).filter((n) => attr(n, "uniquecomponent") === "service-1"), copies = nodes(parse(authored)).filter((n) => attr(n, "uniquecomponent") === "service-1");
+  if (!source.length || source.length !== copies.length) return false;
+  return source.every((s, i) => {
+    const copy = copies[i];
+    if (attr(copy, "data-preserve-disabled-booking") === void 0 || !nodes(copy).some((n) => attr(n, "data-preserve-service-grid") !== void 0)) return false;
+    let cards;
+    try {
+      cards = JSON.parse(attr(copy, "data-preserve-service-cards") || "");
+    } catch {
+      return false;
+    }
+    const initial = nodes(s).filter((n) => /^service-\d+$/.test(attr(n, "data-vitrisid") || ""));
+    if (!initial.length || !Array.isArray(cards) || initial.some((n) => !cards.some((c) => typeof c === "string" && c.includes(`data-vitrisid="${attr(n, "data-vitrisid")}"`)))) return false;
+    return nodes(s).every((n) => {
+      if (["script", "iframe", "object", "embed", "canvas", "form", "button", "textarea"].includes(n.tagName)) return false;
+      if (["select", "input"].includes(n.tagName)) return ["servicesPerPage", "servicesSearch"].includes(attr(n, "data-vitrisid") || "");
+      if (n.tagName === "a" && /^javascript:/i.test(attr(n, "href") || "")) return nodes(n).filter((n2) => n2.nodeName === "#text").map((n2) => n2.value).join("").trim() === "1-on-1 Services";
+      if (attr(n, "data-toggle")) return attr(n, "data-toggle") === "modal" && /^#vitrisScheduleModal/.test(attr(n, "data-target") || "");
+      return true;
+    });
+  });
+}
+function unsupportedApplicationScripts(html, sourceUrl) {
+  const origin = new URL(sourceUrl).origin;
+  return [...new Set(nodes(parse(html)).filter((n) => n.tagName === "script" && attr(n, "src")).map((n) => {
+    const url = new URL(attr(n, "src"), sourceUrl);
+    if (url.hostname === "analytics.tryvitris.com" || /(^|\.)google-analytics\.com$/.test(url.hostname) || url.hostname === "www.googletagmanager.com") return;
+    if ((/(^|\.)doubleclick\.net$/.test(url.hostname) || /(^|\.)googleadservices\.com$/.test(url.hostname)) && url.pathname.startsWith("/pagead/")) return;
+    if (url.hostname === "www.gstatic.com" && (url.pathname === "/wcm/loader.js" || url.pathname.startsWith("/call-tracking/"))) return;
+    if (url.hostname === "connect.facebook.net" && (/^\/[\w-]+\/fbevents\.js$/.test(url.pathname) || /^\/signals\/config\/\d+$/.test(url.pathname))) return;
+    if (url.hostname === "ajax.googleapis.com" && url.pathname === "/ajax/libs/webfont/1/webfont.js") return;
+    if (url.hostname === "cdn.vitris.io" && url.pathname.startsWith("/renderer-dist/")) return;
+    if (url.origin === origin && /^\/(?:runtime|polyfills|scripts|main)(?:[-.][\w-]+)*\.js$/.test(url.pathname)) return;
+    return url.href;
+  }).filter((url) => !!url))];
+}
+
+// src/preserve/hovers.ts
+async function captureButtonHovers(page, selector = ".btn") {
+  const buttons = page.locator(selector), records = [];
+  const styles = (el) => {
+    const s = globalThis.getComputedStyle(el);
+    return { color: s.color, "background-color": s.backgroundColor, "border-color": s.borderColor };
+  };
+  try {
+    for (let index = 0; index < await buttons.count(); index++) {
+      const button = buttons.nth(index);
+      if (!await button.isVisible()) continue;
+      const before = await button.evaluate(styles);
+      await button.hover();
+      await page.waitForTimeout(250);
+      const hover = await button.evaluate(styles);
+      records.push({ index, text: await button.innerText(), href: await button.getAttribute("href"), before, hover });
+      await page.mouse.move(-10, -10);
+      await page.waitForTimeout(250);
+    }
+  } finally {
+    await page.mouse.move(-10, -10);
+    await page.evaluate(() => {
+      const { window } = globalThis;
+      window.scrollTo(0, 0);
+    });
+  }
+  return records;
+}
+
+// src/preserve/capture.ts
+var hash = (value) => createHash("sha256").update(value).digest("hex");
+var attr2 = (node, key) => node.attrs.find((a) => a.name === key)?.value;
+var set = (node, key, value) => {
+  const a = node.attrs.find((a2) => a2.name === key);
+  if (a) a.value = value;
+  else node.attrs.push({ name: key, value });
+};
+var remove = (node) => {
+  if ("parentNode" in node && node.parentNode) node.parentNode.childNodes = node.parentNode.childNodes.filter((n) => n !== node);
+};
+var isDownloadPath = (path) => /\.(pdf|docx?|xlsx?|pptx?|csv|txt|rtf|odt|zip|rar|7z|jpe?g|png|gif|webp|avif|svg|ico|mp[34]|m4[av]|wav|ogg|webm|mov|css|js|woff2?|ttf|eot)$/i.test(path);
+function legacyRoutes(html, base) {
+  const react = legacyReactState(html);
+  if (react) {
+    const links = Object.keys(react.pages || {});
+    const visit = (value) => {
+      if (!value || typeof value !== "object") return;
+      if (value.type === "PAGE" && typeof value.href === "string") links.push(value.href);
+      Object.values(value).forEach(visit);
+    };
+    visit(react.navbar);
+    visit(react.footer);
+    return [...new Set(links.map((s) => new URL(s, base).href).filter((s) => new URL(s).origin === new URL(base).origin))];
+  }
+  const encoded = html.match(/<script[^>]*id="vitris-web-renderer-state"[^>]*>([\s\S]*?)<\/script>/)?.[1];
+  if (!encoded) return [];
+  const text = encoded.replace(/&(q|s|l|g|a);/g, (_m, key) => ({ q: '"', s: "'", l: "<", g: ">", a: "&" })[key]);
+  const state = JSON.parse(text);
+  return [...(state.renderableData?.navbar?.links || []).map((l) => l.url), ...Object.keys(state.renderableData?.pages || {})].filter((s) => !!s).map((s) => new URL(s, base).href).filter((s) => new URL(s).origin === new URL(base).origin);
+}
+function legacyReactState(html) {
+  const marker = /window\.__PRELOADED_STATE__\s*=\s*/.exec(html);
+  if (!marker) return;
+  const start = marker.index + marker[0].length;
+  if (html[start] !== "{") throw new Error("Invalid legacy React state");
+  let depth = 0, quoted = false, escaped = false;
+  for (let i = start; i < html.length; i++) {
+    const ch = html[i];
+    if (quoted) {
+      if (escaped) escaped = false;
+      else if (ch === "\\") escaped = true;
+      else if (ch === '"') quoted = false;
+    } else if (ch === '"') quoted = true;
+    else if (ch === "{") depth++;
+    else if (ch === "}" && --depth === 0) return JSON.parse(html.slice(start, i + 1));
+  }
+  throw new Error("Truncated legacy React state");
+}
+function elements(node) {
+  return ["tagName" in node ? node : void 0, ..."childNodes" in node ? node.childNodes.flatMap(elements) : []].filter((n) => !!n);
+}
+async function settle(page) {
+  await page.mouse.move(-10, -10);
+  await page.evaluate(async () => {
+    const { document, window } = globalThis;
+    await document.fonts.ready;
+    for (let y = 0; y < document.documentElement.scrollHeight; y += 800) {
+      window.scrollTo(0, y);
+      await new Promise((r) => setTimeout(r, 25));
+    }
+    await Promise.all([...document.images].map((i) => i.decode().catch(() => {
+    })));
+    window.scrollTo(0, 0);
+  });
+  await page.waitForTimeout(300);
+}
+async function capturePreservedSite(root, opts = {}) {
+  const config = preserveConfig(root);
+  if (opts.includeSourceErrors && (!opts.diagnostic || !opts.onlyPaths?.length)) throw Error("Source error preservation requires an explicit diagnostic route list");
+  if (config.mode !== "preserve" || !config.sourceUrl) throw new Error("Preserve capture requires launch.json mode=preserve and sourceUrl");
+  const source = new URL(config.sourceUrl);
+  if (!/^https?:$/.test(source.protocol) || source.username || source.password) throw new Error("Source must be an HTTP(S) URL without credentials");
+  if (existsSync(join(root, "preserved"))) throw new Error("Preserved source already exists; edit it in place or capture into a new site directory");
+  const captureId = randomUUID();
+  const staging = join(root, "artifacts", `preserve-capture-${captureId}`);
+  const output = join(staging, "source");
+  const references = join(root, "onboarding", `preserve-reference-${captureId}`);
+  mkdirSync(output, { recursive: true });
+  mkdirSync(references, { recursive: true });
+  const browser = await chromium.launch({ headless: true });
+  const context = await browser.newContext({ viewport: { width: PRESERVE_WIDTHS[0], height: PRESERVE_HEIGHT }, deviceScaleFactor: 1, reducedMotion: "reduce", serviceWorkers: "block" });
+  await context.route("**/*", (route) => {
+    const url = new URL(route.request().url());
+    if (url.hostname === "analytics.tryvitris.com" || /(^|\.)google-analytics\.com$/.test(url.hostname)) return route.abort();
+    return route.continue();
+  });
+  const page = await context.newPage();
+  const renderedAssets = /* @__PURE__ */ new Map();
+  const renderedTypes = /* @__PURE__ */ new Map();
+  page.on("response", (response) => {
+    if (!response.ok() || !["stylesheet", "image", "font", "media"].includes(response.request().resourceType())) return;
+    const type = response.headers()["content-type"]?.split(";")[0] || "";
+    renderedTypes.set(response.url(), type);
+    renderedAssets.set(response.url(), response.body().then((bytes) => ({ bytes: Buffer.from(bytes), type, url: response.url() })).catch(() => void 0));
+  });
+  const manifest = { version: 1, adapter: "vitris-v1", sourceUrl: source.href, capturedAt: (/* @__PURE__ */ new Date()).toISOString(), pages: [], assets: [], serviceMode: config.backendOrigin && config.forms?.length ? "vitris-forms" : "preview-only", warnings: [] };
+  const assets = /* @__PURE__ */ new Map();
+  const queue = [];
+  const asset = (raw, base, css = false) => {
+    if (!raw || /^(data:|blob:|#)/i.test(raw)) return raw;
+    const url = new URL(raw, base);
+    const fragment = url.hash;
+    url.hash = "";
+    if (!/^https?:$/.test(url.protocol) || url.username || url.password) throw new Error(`Unsupported asset URL: ${url.href}`);
+    let entry = assets.get(url.href);
+    if (!entry) {
+      const knownType = renderedTypes.get(url.href) || "";
+      const extension = css ? ".css" : { "image/avif": ".avif", "image/webp": ".webp", "image/png": ".png", "image/jpeg": ".jpg", "image/svg+xml": ".svg", "font/woff2": ".woff2" }[knownType] || extname(url.pathname).match(/^\.[a-z0-9]{1,8}$/i)?.[0] || ".bin";
+      entry = { file: `_preserve/assets/${hash(url.href).slice(0, 24)}${extension}`, css };
+      assets.set(url.href, entry);
+      queue.push(url.href);
+    }
+    return `/${entry.file}${fragment}`;
+  };
+  const cssText = (text, base) => text.replace(/@import\s+(["'])(.*?)\1/g, (_m, _q, url) => `@import "${asset(url, base, true)}"`).replace(/url\(\s*(?:"([^"]*)"|'([^']*)'|([^)]*?))\s*\)/g, (_m, a, b, c) => {
+    const raw = a ?? b ?? c;
+    if (/^(null|undefined)$/i.test(raw)) {
+      const warning = `Legacy empty background placeholder url(${raw}) normalized to none; source rendering remains the visual reference.`;
+      if (!manifest.warnings.includes(warning)) manifest.warnings.push(warning);
+      return "none";
+    }
+    return `url("${asset(raw, base, /\.css(?:[?#]|$)/i.test(raw))}")`;
+  });
+  const pending = opts.onlyPaths ? opts.onlyPaths.map((path) => new URL(path, source).href) : [new URL("/", source).href, source.href];
+  const seen = /* @__PURE__ */ new Set();
+  const outputs = /* @__PURE__ */ new Set();
+  const abort = () => {
+    void browser.close();
+  };
+  opts.signal?.addEventListener("abort", abort, { once: true });
+  try {
+    while (pending.length) {
+      opts.signal?.throwIfAborted();
+      const url = new URL(pending.shift());
+      url.hash = "";
+      if (url.pathname !== "/") url.pathname = url.pathname.replace(/\/+$/, "");
+      if (seen.has(url.href)) continue;
+      seen.add(url.href);
+      const blocked = (message) => {
+        if (!opts.diagnostic) throw new Error(message);
+        (manifest.blockers ||= []).push(`${url.pathname}: ${message}`);
+      };
+      if (opts.onlyPaths && !opts.onlyPaths.includes(url.pathname)) continue;
+      opts.onLog?.(`Preserving ${url.pathname}`);
+      let response;
+      try {
+        response = await page.goto(url.href, { waitUntil: "load", timeout: 6e4 });
+      } catch (error) {
+        if (!browser.isConnected()) throw error;
+        blocked(`Source navigation failed: ${url.href}: ${error instanceof Error ? error.message : String(error)}`);
+        continue;
+      }
+      const source404 = opts.includeSourceErrors && response?.status() === 404;
+      if (!response || !response.ok() && !source404) {
+        blocked(`Source page failed: ${url.href} (${response?.status()})`);
+        continue;
+      }
+      const sourceHtml = await response.text();
+      const react = legacyReactState(sourceHtml);
+      pending.push(...legacyRoutes(sourceHtml, source.origin + "/"));
+      if (new URL(page.url()).origin !== source.origin) {
+        blocked(`Source redirected to another origin: ${page.url()}`);
+        continue;
+      }
+      try {
+        if (!source404) await page.locator(react ? "#vcontent" : "#fullSiteRenderer").waitFor({ timeout: 15e3 });
+      } catch (error) {
+        if (!browser.isConnected()) throw error;
+        blocked(`Expected legacy renderer missing at ${url.href}`);
+        continue;
+      }
+      await settle(page);
+      const html = await page.content();
+      if (!source404 && !react && !/vitris-web-renderer|v1-full-site-renderer/.test(html)) {
+        blocked("Preserve adapters support legacy Vitris websites only; external-site adapters are not yet implemented");
+        continue;
+      }
+      if (react) manifest.adapter = "vitris-v2";
+      const soft404 = /404 Page Not Found/.test(await page.locator("body").innerText());
+      if (soft404 && !opts.includeSourceErrors) {
+        blocked(`Source returned a soft 404: ${url.href}`);
+        continue;
+      }
+      const doc = parse2(html);
+      const nodes4 = elements(doc);
+      const hoverStates = await captureButtonHovers(page);
+      const buttons = nodes4.filter((n) => (attr2(n, "class") || "").split(/\s+/).includes("btn"));
+      for (const state of hoverStates) {
+        const button = buttons[state.index];
+        if (!button || (attr2(button, "href") ?? null) !== state.href) {
+          blocked("Button inventory changed during capture; preserve its hover state explicitly");
+          continue;
+        }
+        if (JSON.stringify(state.before) !== JSON.stringify(state.hover)) set(button, "data-preserve-hover", JSON.stringify(state.hover));
+      }
+      const supported = /* @__PURE__ */ new Set(["navbar-1", "header-1", "photoGallery-1", "cards-1", "info-1", "contactForm-1", "footer-1", "html-1"]);
+      const unknown = nodes4.filter((n) => attr2(n, "uniquecomponent") && !supported.has(attr2(n, "uniquecomponent")) && !supportsStaticLegacyComponent(n)).map((n) => attr2(n, "uniquecomponent"));
+      if (unknown.length) blocked(`Legacy components need preservation support: ${[...new Set(unknown)].join(", ")}`);
+      if (react) {
+        const blocks = [...react.pages?.[url.pathname === "/" ? react.site?.homePageUrl : url.pathname.slice(1)]?.rows || [], ...react.footer?.rows || []].flatMap((r) => r.blocks || []);
+        const unsupportedBlocks = [...new Set(blocks.map((b) => b.bt).filter((bt) => !SUPPORTED_REACT_BLOCKS.has(bt)))];
+        if (unsupportedBlocks.length) blocked(`Legacy React blocks need preservation support: ${unsupportedBlocks.join(", ")}`);
+        for (const [i, toggle] of nodes4.filter((n) => (attr2(n, "class") || "").split(/\s+/).includes("navbar-toggler")).entries()) {
+          let parent = toggle.parentNode;
+          while (parent && !elements(parent).some((n) => (attr2(n, "class") || "").split(/\s+/).includes("navbar-collapse"))) parent = "parentNode" in parent ? parent.parentNode : null;
+          const target = parent && elements(parent).find((n) => (attr2(n, "class") || "").split(/\s+/).includes("navbar-collapse"));
+          if (!target) {
+            blocked("React mobile menu target missing");
+            continue;
+          }
+          const id = attr2(target, "id") || `preserve-react-nav-${i}`;
+          set(target, "id", id);
+          set(toggle, "data-toggle", "collapse");
+          set(toggle, "data-target", "#" + id);
+          set(toggle, "aria-expanded", "false");
+        }
+      }
+      const approvedEmbeds = nodes4.filter((n) => n.tagName === "iframe" && attr2(n, "srcdoc") === void 0 && readOnlyEmbedProvider(attr2(n, "src") || ""));
+      const inertFrames = nodes4.filter(isInertFrame);
+      for (const frame of inertFrames) set(frame, "src", "about:blank");
+      for (const embed of approvedEmbeds) {
+        set(embed, "src", approvedEmbedUrl(attr2(embed, "src")));
+        const warning = `Remote ${readOnlyEmbedProvider(attr2(embed, "src"))} embed retained at ${url.pathname}: ${attr2(embed, "src")}. Provider content, network availability and privacy behavior are external dependencies; the embedded application is not stored locally.`;
+        if (!manifest.warnings.includes(warning)) manifest.warnings.push(warning);
+      }
+      const unsupported = nodes4.filter((n) => ["iframe", "object", "embed", "canvas"].includes(n.tagName) && !approvedEmbeds.includes(n) && !inertFrames.includes(n) || attr2(n, "data-toggle") && !["collapse", "modal"].includes(attr2(n, "data-toggle")));
+      if (unsupported.length) blocked(`Unsupported interactive content: ${unsupported.map((n) => n.tagName + ":" + (attr2(n, "srcdoc") !== void 0 ? "srcdoc" : attr2(n, "data-toggle") || attr2(n, "src") || "")).join(", ")}. Add an adapter before publishing.`);
+      const base = new URL(nodes4.find((n) => n.tagName === "base")?.attrs.find((a) => a.name === "href")?.value || url.href, url).href;
+      for (const node of nodes4) {
+        if (unsupported.includes(node) && ["iframe", "object", "embed"].includes(node.tagName)) {
+          set(node, "data-preserve-disabled-embed", attr2(node, "src") || attr2(node, "data") || "");
+          if (attr2(node, "srcdoc") !== void 0) set(node, "data-preserve-original-srcdoc", attr2(node, "srcdoc"));
+          node.attrs = node.attrs.filter((a) => !["srcdoc", "data"].includes(a.name));
+          set(node, "src", "about:blank");
+        }
+        if (node.tagName === "script" && !["application/ld+json"].includes(attr2(node, "type") || "")) {
+          remove(node);
+          continue;
+        }
+        if (node.tagName === "noscript") {
+          remove(node);
+          continue;
+        }
+        if (node.tagName === "meta" && /^(refresh|content-security-policy)$/i.test(attr2(node, "http-equiv") || "")) {
+          remove(node);
+          continue;
+        }
+        if (node.tagName === "base") {
+          set(node, "href", "/");
+          continue;
+        }
+        if (node.tagName === "link" && /^(preconnect|dns-prefetch|modulepreload|preload)$/i.test(attr2(node, "rel") || "")) {
+          remove(node);
+          continue;
+        }
+        if (node.tagName === "style") {
+          for (const child of node.childNodes) if ("value" in child) child.value = cssText(child.value, base);
+        }
+        const style = attr2(node, "style");
+        if (style) set(node, "style", cssText(style, base));
+        if (node.tagName === "a") {
+          const href = attr2(node, "href");
+          if (href !== void 0 && !/^(tel:|mailto:|#)/i.test(href)) {
+            const target = new URL(href || "/", base);
+            if (target.origin === source.origin) {
+              if (target.search) {
+                blocked(`Query-dependent navigation needs an adapter: ${target.href}`);
+                set(node, "href", target.href);
+              } else if (isDownloadPath(target.pathname)) set(node, "href", asset(target.href, base));
+              else {
+                set(node, "href", target.pathname + target.hash);
+                target.hash = "";
+                pending.push(target.href);
+              }
+            }
+          }
+        }
+        for (const key of ["src", "poster"]) {
+          const raw = attr2(node, key);
+          if (raw && !["iframe", "object", "embed"].includes(node.tagName)) set(node, key, asset(raw, base));
+        }
+        if (node.tagName === "link" && /stylesheet|icon/i.test(attr2(node, "rel") || "")) {
+          set(node, "href", asset(attr2(node, "href"), base, attr2(node, "rel") === "stylesheet"));
+          node.attrs = node.attrs.filter((a) => !["integrity", "crossorigin"].includes(a.name));
+        }
+        const srcset = attr2(node, "srcset");
+        if (srcset) {
+          if (srcset.includes("data:")) throw new Error("Inline srcset needs explicit preservation support");
+          set(node, "srcset", srcset.split(",").map((candidate) => {
+            const [url2, ...descriptor] = candidate.trim().split(/\s+/);
+            return [asset(url2, base), ...descriptor].join(" ");
+          }).join(", "));
+        }
+        if (node.tagName === "form") {
+          const fields2 = elements(node).filter((n) => ["input", "textarea"].includes(n.tagName)).map((n) => attr2(n, "name"));
+          const contact = attr2(node, "data-lead-form") !== void 0 || elements(node).some((n) => attr2(n, "data-vitrisid") === "emailSendButton") || react && ["name", "email", "message"].every((name) => fields2.includes(name));
+          if (!contact) blocked(`Unrelated form requires an explicit preservation adapter; it cannot be routed to contact forms`);
+          if (react && contact) for (const send of elements(node).filter((n) => n.tagName === "a" && /^javascript:/i.test(attr2(n, "href") || ""))) {
+            set(send, "href", "#");
+            set(send, "data-vitrisid", "emailSendButton");
+          }
+          if (elements(node).some((n) => attr2(n, "type") === "file")) manifest.warnings.push(`Attachments unsupported at ${url.pathname}; keep this form disabled until adapted`);
+          set(node, "data-preserve-forms", "preview");
+          set(node, "action", "#");
+        }
+        node.attrs = node.attrs.filter((a) => !/^on/i.test(a.name));
+      }
+      let file;
+      try {
+        file = pageFile(url.pathname);
+      } catch (error) {
+        const decoded = decodeURIComponent(url.pathname);
+        if (!decoded.split("/").some((p) => /\.$/.test(p)) || /[\\\x00-\x1f:*?"<>|]/.test(decoded) || decoded.split("/").some((p) => p === "." || p === "..")) throw error;
+        file = `_preserve/routes/${hash(url.pathname).slice(0, 24)}/index.html`;
+      }
+      if (outputs.has(file.toLowerCase())) file = `_preserve/routes/${hash(url.pathname).slice(0, 24)}/index.html`;
+      if (outputs.has(file.toLowerCase())) throw new Error(`Routes collide on disk: ${url.pathname}`);
+      outputs.add(file.toLowerCase());
+      const captured = { url: url.href, path: url.pathname, file, references: [] };
+      if (source404 || soft404) {
+        const responseFile = `onboarding/preserve-reference-${captureId}/${manifest.pages.length}-response.html`;
+        writeFileSync(join(root, responseFile), sourceHtml, { flag: "wx" });
+        captured.sourceFailure = { status: response.status(), kind: source404 ? "http-404" : "soft-404", responseFile, responseSha256: hash(sourceHtml) };
+        manifest.warnings.push(`Unavailable original route ${url.pathname}: preserved ${source404 ? "HTTP 404 response" : "soft 404"} content. Static preview serves the captured error page with HTTP 200; business content was unavailable.`);
+      }
+      writeFileSync(join(references, `${manifest.pages.length}-rendered.html`), html, { flag: "wx" });
+      writeFileSync(join(references, `${manifest.pages.length}-hovers.json`), JSON.stringify(hoverStates, null, 2), { flag: "wx" });
+      for (const width of PRESERVE_WIDTHS) {
+        await page.setViewportSize({ width, height: PRESERVE_HEIGHT });
+        await settle(page);
+        const name = `${manifest.pages.length}-${width}.png`;
+        const screenshot = await page.screenshot({ fullPage: true, animations: "disabled", path: join(references, name) });
+        captured.references.push({ width, file: `onboarding/preserve-reference-${captureId}/${name}`, sha256: hash(screenshot) });
+      }
+      await page.setViewportSize({ width: PRESERVE_WIDTHS[0], height: PRESERVE_HEIGHT });
+      const content = serialize(doc).replace(/<\/head>/i, '<meta name="robots" content="noindex,nofollow"></head>').replace(/<\/body>/i, '<script src="/_preserve/runtime.js" defer></script></body>');
+      const path = within(output, file);
+      mkdirSync(dirname(path), { recursive: true });
+      writeFileSync(path, content);
+      manifest.pages.push(captured);
+    }
+    while (queue.length) {
+      opts.signal?.throwIfAborted();
+      const url = queue.shift();
+      const entry = assets.get(url);
+      opts.onLog?.(`Copying asset ${manifest.assets.length + 1}/${assets.size}`);
+      let captured = await renderedAssets.get(url);
+      let captureError;
+      if (!captured) {
+        try {
+          const response = await context.request.get(url, { timeout: 3e4 });
+          if (!response.ok()) captureError = `Asset failed: ${url} (${response.status()})`;
+          captured = { bytes: Buffer.from(await response.body()), type: response.headers()["content-type"] || "", url: response.url() };
+        } catch (error) {
+          if (!opts.diagnostic) throw error;
+          captureError = `Asset request failed: ${url}: ${error instanceof Error ? error.message : String(error)}`;
+          captured = { bytes: Buffer.alloc(0), type: "", url };
+        }
+      }
+      const type = captured.type;
+      if (type.includes("text/html")) captureError ||= `Asset returned HTML: ${url}`;
+      if (captureError) {
+        if (!opts.diagnostic) throw new Error(captureError);
+        (manifest.blockers ||= []).push(captureError + "; missing authored asset retained as an empty placeholder, not claimed as preserved bytes");
+      }
+      const original = captured.bytes;
+      const referenceFile = `onboarding/preserve-reference-${captureId}/assets/${hash(url).slice(0, 24)}.bin`;
+      mkdirSync(join(references, "assets"), { recursive: true });
+      writeFileSync(join(root, referenceFile), original, { flag: "wx" });
+      const bytes = captureError ? Buffer.alloc(0) : entry.css || type.includes("text/css") ? Buffer.from(cssText(Buffer.from(original).toString("utf8"), captured.url)) : original;
+      const path = within(output, entry.file);
+      mkdirSync(dirname(path), { recursive: true });
+      writeFileSync(path, bytes);
+      manifest.assets.push({ url, file: entry.file, sha256: hash(bytes), originalSha256: hash(original), referenceFile, ...captureError ? { captureError } : {} });
+    }
+    mkdirSync(join(output, "_preserve"), { recursive: true });
+    writeFileSync(join(output, "_preserve/runtime.js"), preserveRuntime);
+    manifest.warnings.push("Legacy renderer, analytics, and backend calls removed. Existing external navigation links are preserved.");
+    if (!config.forms?.length) manifest.warnings.push("Forms are preview-only until explicit form registration and frontend bindings are configured; no submissions are sent.");
+    save(join(staging, "manifest.json"), manifest);
+    renameSync(output, join(root, "preserved"));
+    save(join(root, "onboarding/preserve.json"), manifest);
+    return manifest;
+  } finally {
+    opts.signal?.removeEventListener("abort", abort);
+    await browser.close();
+  }
+}
+
+// src/preserve/verify.ts
+import { createHash as createHash2 } from "node:crypto";
+import { Buffer as Buffer2 } from "node:buffer";
+import { existsSync as existsSync2, mkdirSync as mkdirSync2, readFileSync as readFileSync2 } from "node:fs";
+import { join as join2 } from "node:path";
+import { chromium as chromium2 } from "playwright";
+
+// src/preserve/react-capabilities.ts
+import { parse as parse3 } from "parse5";
+var attr3 = (n, key) => n.attrs?.find((a) => a.name === key)?.value;
+var nodes2 = (n) => [n, ...(n.childNodes || []).flatMap(nodes2)];
+var controls = (n) => nodes2(n).filter((n2) => ["input", "textarea", "select", "button", "form", "iframe", "object", "embed", "canvas"].includes(n2.tagName) || n2.tagName === "a" && /^javascript:/i.test(attr3(n2, "href") || ""));
+var fields = (n) => nodes2(n).filter((n2) => ["input", "textarea", "select"].includes(n2.tagName)).map((n2) => [n2.tagName, attr3(n2, "type") || "text", attr3(n2, "name") || "", attr3(n2, "id") || ""].join("|")).sort().join("\n");
+function reactCapabilities(state, original, authored, path, disabledTransactions) {
+  const originalNodes = nodes2(parse3(original)), authoredNodes = nodes2(parse3(authored));
+  const blocks = (state?.pages?.[path === "/" ? state.site?.homePageUrl : path.slice(1)]?.rows || []).flatMap((r) => r.blocks || []);
+  const result = /* @__PURE__ */ new Set();
+  for (const kind of ["b", "coll", "cform", "s"]) {
+    const matches = blocks.filter((b) => b.bt === kind);
+    if (!matches.length) continue;
+    const supported = matches.every((block) => {
+      const source = originalNodes.find((n) => attr3(n, "id") === block._id), copy = authoredNodes.find((n) => attr3(n, "id") === block._id);
+      if (!source || !copy) return false;
+      if (["b", "coll"].includes(kind)) return controls(source).length === 0;
+      if (!disabledTransactions) return false;
+      if (kind === "cform") {
+        const forms = nodes2(source).filter((n) => n.tagName === "form"), copies = nodes2(copy).filter((n) => n.tagName === "form");
+        if (forms.length !== 1 || copies.length !== 1 || fields(forms[0]) !== fields(copies[0])) return false;
+        const submits = nodes2(forms[0]).filter((n) => n.tagName === "a" && /^javascript:/i.test(attr3(n, "href") || ""));
+        return submits.length === 1 && nodes2(submits[0]).filter((n) => n.nodeName === "#text").map((n) => n.value).join("").trim() === "Submit" && !controls(source).some((n) => ["button", "iframe", "object", "embed", "canvas"].includes(n.tagName)) && attr3(copies[0], "data-preserve-disabled-custom-form") !== void 0 && attr3(copies[0], "data-preserve-forms") === "preview" && attr3(copies[0], "action") === "#";
+      }
+      const calendars = nodes2(source).filter((n) => attr3(n, "id") === "select-time-parent-container");
+      if (calendars.length === 0) {
+        const links = nodes2(source).filter((n) => n.tagName === "a"), buttonText = block.c?.service?.btn?.txt;
+        return !!buttonText && links.length > 0 && controls(source).every((n) => links.includes(n)) && block.c?.d?.search === false && links.every((n) => /^javascript:/i.test(attr3(n, "href") || "") && nodes2(n).filter((n2) => n2.nodeName === "#text").map((n2) => n2.value).join("").trim() === buttonText) && attr3(copy, "data-preserve-disabled-booking") !== void 0 && nodes2(copy).filter((n) => attr3(n, "data-preserve-disabled-action") === "booking").length === links.length;
+      }
+      return calendars.length === 1 && attr3(copy, "data-preserve-disabled-booking") !== void 0 && controls(source).length === 0 && nodes2(copy).some((n) => attr3(n, "id") === "days-container") && nodes2(copy).filter((n) => attr3(n, "data-preserve-disabled-action") === "booking").length === nodes2(source).filter((n) => n.tagName === "a" || (attr3(n, "class") || "").split(/\s+/).includes("day-col")).length;
+    });
+    if (supported) result.add(kind);
+  }
+  return result;
+}
+
+// src/preserve/source-defects.ts
+import { parse as parse4 } from "parse5";
+var nodes3 = (n) => [n, ...(n.childNodes || []).flatMap(nodes3)];
+var attr4 = (n, key) => n.attrs?.find((a) => a.name === key)?.value;
+function originalMissingAnchors(original, sourceUrl, references) {
+  const result = /* @__PURE__ */ new Set(), origin = new URL(sourceUrl).origin;
+  for (const n of nodes3(parse4(original)).filter((n2) => n2.tagName === "a" && attr4(n2, "href"))) {
+    let url;
+    try {
+      url = new URL(attr4(n, "href"), sourceUrl);
+    } catch {
+      continue;
+    }
+    const target = references.get(url.pathname);
+    if (url.origin !== origin || !url.hash || !target) continue;
+    if (!nodes3(parse4(target)).some((n2) => attr4(n2, "id") === decodeURIComponent(url.hash.slice(1)))) result.add(url.pathname + url.hash);
+  }
+  return result;
+}
+function originalNullImages(manifest, originals, copies) {
+  const result = /* @__PURE__ */ new Set();
+  for (const asset of manifest.assets) {
+    const nullImage = asset.captureError?.startsWith("Asset returned HTML:") && new URL(asset.url).pathname === "/null";
+    const errorIllustration = asset.url === "https://tryvitris.com/assets/img/404-error.jpg" && asset.captureError?.endsWith("(404)") && manifest.pages?.some((p) => p.sourceFailure);
+    if (!nullImage && !errorIllustration) continue;
+    const sourceImages = originals.flatMap((h) => nodes3(parse4(h))).filter((n) => n.tagName === "img" && attr4(n, "src") && new URL(attr4(n, "src"), manifest.sourceUrl).href === asset.url);
+    const authored = copies.flatMap((h) => nodes3(parse4(h))).filter((n) => attr4(n, "src") === "/" + asset.file);
+    if (sourceImages.length > 0 && sourceImages.length === authored.length && authored.every((n) => n.tagName === "img") && !copies.some((h) => nodes3(parse4(h)).some((n) => attr4(n, "href") === "/" + asset.file))) result.add(asset.url);
+  }
+  return result;
+}
+
+// src/preserve/verify.ts
+async function compare(page, before, after) {
+  return await page.evaluate(async ({ before: before2, after: after2 }) => {
+    const { Image, document } = globalThis;
+    const read = async (data) => {
+      const i = new Image();
+      i.src = "data:image/png;base64," + data;
+      await i.decode();
+      const c = document.createElement("canvas");
+      c.width = i.width;
+      c.height = i.height;
+      const x = c.getContext("2d");
+      x.drawImage(i, 0, 0);
+      return { w: i.width, h: i.height, data: x.getImageData(0, 0, i.width, i.height).data };
+    };
+    const a = await read(before2), b = await read(after2);
+    if (a.w !== b.w || a.h !== b.h) return { dimensionsMatch: false, changedPixelRatio: 1 };
+    let changed = 0;
+    for (let i = 0; i < a.data.length; i += 4) if (Math.max(...[0, 1, 2].map((c) => Math.abs(a.data[i + c] - b.data[i + c]))) > 24) changed++;
+    return { dimensionsMatch: true, changedPixelRatio: changed / (a.w * a.h) };
+  }, { before: Buffer2.from(before).toString("base64"), after: Buffer2.from(after).toString("base64") });
+}
+async function interactions(page, backend) {
+  const failures = [];
+  for (const panel of await page.locator("[data-preserve-product-states]").all()) {
+    const states = JSON.parse(await panel.getAttribute("data-preserve-product-states"));
+    for (const state of states) {
+      for (let i = 0; i < state.values.length; i++) await panel.locator("select").nth(i).selectOption(state.values[i]);
+      const actual = await panel.locator("select").evaluateAll((els, length) => els.slice(0, length).map((el) => el.value), state.values.length);
+      if (JSON.stringify(actual) !== JSON.stringify(state.values)) failures.push("Product variant selection differs from the captured original");
+      if (state.html.includes("data-preserve-disabled-action")) {
+        const action = panel.locator("[data-preserve-disabled-action]");
+        if (!await action.count()) failures.push("Product purchase control missing after selection");
+        else {
+          await action.click();
+          if (!await page.getByText("This preview cannot place orders or accept payments. Please use the listed contact details.", { exact: true }).first().isVisible()) failures.push("Product purchase was not explicitly disabled");
+        }
+      }
+    }
+  }
+  for (const carousel of await page.locator(".carousel[data-preserve-carousel]").all()) {
+    const dots = carousel.locator(".carousel__dot"), slides = carousel.locator(".carousel__slide");
+    for (let i = 0; i < await dots.count(); i++) if (await dots.nth(i).isVisible()) {
+      if (!await dots.nth(i).isDisabled()) await dots.nth(i).click();
+      if (await slides.nth(i).getAttribute("aria-selected") !== "true") failures.push("Product carousel did not select the requested image");
+    }
+    const slider = carousel.locator(".carousel__slider");
+    await slider.focus();
+    await page.keyboard.press("ArrowRight");
+    if (await carousel.locator('.carousel__slide[aria-selected="true"]').count() !== 1) failures.push("Product carousel did not select exactly one image");
+  }
+  for (const action of await page.locator("[data-preserve-disabled-action]").all()) if (await action.isVisible() && await action.evaluate((el) => globalThis.getComputedStyle(el).pointerEvents !== "none")) {
+    await action.click();
+    const booking = await action.getAttribute("data-preserve-disabled-action") === "booking";
+    const hasCalendar = await action.evaluate((el) => !!el.closest("[data-preserve-disabled-booking]")?.querySelector("#days-container"));
+    const text = booking ? hasCalendar ? "This preview cannot book appointments. Calendar availability is a captured snapshot. Please use the listed contact details." : "This preview cannot book appointments. Please use the listed contact details." : "This preview cannot place orders or accept payments. Please use the listed contact details.";
+    const visible = await page.getByText(text, { exact: true }).first().isVisible();
+    const previousSafeNotice = booking && !hasCalendar && await page.getByText("This preview cannot book appointments. Calendar availability is a captured snapshot. Please use the listed contact details.", { exact: true }).first().isVisible();
+    if (!visible && !previousSafeNotice) failures.push("Disabled transaction notice missing");
+  }
+  const hoverButtons = page.locator("[data-preserve-hover]");
+  for (let i = 0; i < await hoverButtons.count(); i++) {
+    const button = hoverButtons.nth(i);
+    if (!await button.isVisible()) continue;
+    const before = await button.getAttribute("style"), expected = JSON.parse(await button.getAttribute("data-preserve-hover"));
+    await button.hover();
+    await page.waitForTimeout(250);
+    const actual = await button.evaluate((el) => {
+      const s = globalThis.getComputedStyle(el);
+      return { color: s.color, "background-color": s.backgroundColor, "border-color": s.borderColor };
+    });
+    if (Object.entries(expected).some(([k, v]) => actual[k] !== v)) failures.push("Button hover colors differ from the measured original");
+    await page.mouse.move(-10, -10);
+    await page.waitForTimeout(250);
+    if (await button.getAttribute("style") !== before) failures.push("Button hover did not restore its resting style");
+  }
+  const dropdowns = async () => {
+    const toggles2 = page.locator(".dropdown-toggle");
+    for (let i = 0; i < await toggles2.count(); i++) {
+      const toggle = toggles2.nth(i);
+      if (!await toggle.isVisible()) continue;
+      const menu = toggle.locator("..").locator(".dropdown-menu").first();
+      if (!await menu.count()) {
+        failures.push("Dropdown menu missing");
+        continue;
+      }
+      await toggle.click();
+      if (!await menu.isVisible() || await toggle.getAttribute("aria-expanded") !== "true") failures.push("Dropdown did not open");
+      await toggle.click();
+      if (await menu.isVisible()) failures.push("Dropdown did not close");
+    }
+  };
+  const toggles = page.locator('[data-toggle="collapse"]');
+  for (let i = 0; i < await toggles.count(); i++) {
+    const toggle = toggles.nth(i);
+    if (!await toggle.isVisible()) continue;
+    const id = await toggle.getAttribute("data-target") || await toggle.getAttribute("href");
+    if (!id?.startsWith("#")) {
+      failures.push("Menu target missing");
+      continue;
+    }
+    const initiallyOpen = await page.locator(id).evaluate((el) => el.classList.contains("show"));
+    await toggle.click();
+    if (await page.locator(id).isVisible() === initiallyOpen || await toggle.getAttribute("aria-expanded") !== String(!initiallyOpen)) failures.push("Collapse state did not change");
+    const group = await toggle.getAttribute("data-parent") || await page.locator(id).getAttribute("data-parent");
+    if (!initiallyOpen && group?.startsWith("#")) {
+      const openCount = await page.evaluate((selector) => {
+        const { document } = globalThis;
+        const parent = document.getElementById(selector.slice(1));
+        if (!parent) return 0;
+        const ids = new Set([...parent.querySelectorAll('[data-toggle="collapse"]')].filter((el) => el.getAttribute("data-parent") === selector).map((el) => (el.getAttribute("data-target") || el.getAttribute("href") || "").slice(1)));
+        return [...ids].filter((id2) => document.getElementById(id2)?.classList.contains("show")).length;
+      }, group);
+      if (openCount > 1) failures.push("Accordion siblings remained open");
+    }
+    if (!initiallyOpen) await dropdowns();
+    await toggle.click();
+  }
+  await dropdowns();
+  for (const service of await page.locator("services-general[data-preserve-service-cards]").all()) {
+    const select = service.locator('[data-vitrisid="servicesPerPage"]');
+    if (await select.isVisible()) {
+      const initial = await select.inputValue(), cards = JSON.parse(await service.getAttribute("data-preserve-service-cards"));
+      await select.selectOption({ label: "30" });
+      if (await service.locator("[data-preserve-service-grid] .card").count() !== Math.min(30, cards.length)) failures.push("Local service page does not contain all captured cards");
+      for (const button of await service.locator("[data-preserve-service-grid] [data-preserve-hover]").all()) if (await button.isVisible()) {
+        const expected = JSON.parse(await button.getAttribute("data-preserve-hover")), before = await button.getAttribute("style");
+        await button.hover();
+        await page.waitForTimeout(250);
+        const actual = await button.evaluate((el) => {
+          const s = globalThis.getComputedStyle(el);
+          return { color: s.color, "background-color": s.backgroundColor, "border-color": s.borderColor };
+        });
+        if (Object.entries(expected).some(([k, v]) => actual[k] !== v)) failures.push("Paged service button hover differs from the measured original");
+        await page.mouse.move(-10, -10);
+        await page.waitForTimeout(250);
+        if (await button.getAttribute("style") !== before) failures.push("Paged service hover did not restore its resting style");
+      }
+      await select.selectOption(initial);
+      const right = service.locator('[data-vitrisid="servicesRightArrow"]');
+      if (cards.length > Number(initial) && await right.isVisible()) {
+        const before = await service.locator("[data-preserve-service-grid]").innerText();
+        await right.click();
+        if (await service.locator("[data-preserve-service-grid]").innerText() === before) failures.push("Local service pagination did not advance");
+        await service.locator('[data-vitrisid="servicesLeftArrow"]').click();
+        if (await service.locator("[data-preserve-service-grid]").innerText() !== before) failures.push("Local service pagination did not restore its first page");
+      }
+    }
+  }
+  const galleries = page.locator('[data-toggle="modal"]');
+  for (let i = 0; i < await galleries.count(); i++) {
+    const trigger = galleries.nth(i);
+    if (!await trigger.isVisible()) continue;
+    const id = await trigger.getAttribute("data-target");
+    if (!id?.startsWith("#")) {
+      failures.push("Gallery target missing");
+      continue;
+    }
+    await trigger.click();
+    if (!await page.locator(id).isVisible()) failures.push(`Gallery did not open: ${id}`);
+    if (await trigger.evaluate((el) => !!el.closest("services-general[data-preserve-disabled-booking]")) && !await page.locator(id).getByText("This preview cannot book appointments. Please use the listed contact details.", { exact: true }).isVisible()) failures.push("Legacy booking disabled notice missing");
+    await page.keyboard.press("Escape");
+    if (await page.locator(id).isVisible()) failures.push(`Gallery did not close: ${id}`);
+  }
+  if (backend) {
+    await page.route((url) => url.origin === backend && url.pathname === "/api/leads", (route) => route.fulfill({ status: 201, contentType: "application/json", headers: { "access-control-allow-origin": new URL(page.url()).origin }, body: '{"ok":true,"mode":"test"}' }));
+    await page.route("https://challenges.cloudflare.com/turnstile/v0/api.js*", (route) => route.fulfill({ contentType: "application/javascript", body: 'window.turnstile={render:(el,opts)=>{setTimeout(()=>opts.callback("preservation-mock-token"),0);return "mock"},reset:()=>{}}' }));
+  }
+  const forms = page.locator("form[data-preserve-forms]");
+  for (let i = 0; i < await forms.count(); i++) {
+    const form = forms.nth(i);
+    if (!await form.isVisible()) continue;
+    const fields2 = form.locator("input:not([type=hidden]), textarea");
+    for (let n = 0; n < await fields2.count(); n++) {
+      const field = fields2.nth(n);
+      const type = await field.getAttribute("type");
+      if (!await field.isVisible()) continue;
+      if (type === "file") {
+        if (await form.getAttribute("data-preserve-disabled-custom-form") !== null && !await form.getAttribute("data-vitris-form")) await field.setInputFiles({ name: "preview.png", mimeType: "image/png", buffer: Buffer2.from("iVBORw0KGgoAAAANSUhEUgAAAAEAAAABCAYAAAAfFcSJAAAADUlEQVQIHWP4z8DwHwAFgAI/ScLbtAAAAABJRU5ErkJggg==", "base64") });
+        else failures.push("Unsupported form field: file");
+        continue;
+      }
+      if (type === "checkbox" || type === "radio") {
+        await field.check();
+        continue;
+      }
+      await field.fill(type === "email" ? "preview@example.com" : type === "tel" || type === "number" ? "5705550100" : "Preview verification");
+    }
+    const selects = form.locator("select");
+    for (let n = 0; n < await selects.count(); n++) {
+      const select = selects.nth(n);
+      const option = await select.locator("option").evaluateAll((options) => options.find((o) => o.value)?.value);
+      if (option) await select.selectOption(option);
+    }
+    const send = form.locator('[data-vitrisid="emailSendButton"]');
+    if (await send.count()) await send.click();
+    else await form.evaluate((form2) => form2.requestSubmit());
+    try {
+      await page.getByText(await form.getAttribute("data-vitris-form") ? "Test message accepted. No customer email will be sent." : await form.getAttribute("data-preserve-disabled-custom-form") !== null ? "This preview does not send messages or upload files. Please use the listed contact details." : "This preview does not send messages. Please use the listed contact details.", { exact: true }).first().waitFor({ timeout: 3e3 });
+    } catch {
+      failures.push("Form feedback missing");
+    }
+  }
+  return failures;
+}
+async function verifyPreservedSite(root, opts = {}) {
+  const manifest = preserveManifest(root);
+  const config = preserveConfig(root), dist = join2(root, "dist");
+  const connected = !!config.backendOrigin && !!config.forms?.length;
+  const report = { version: 1, ok: false, sourceRevision: sourceRevision(root).digest, artifactDigest: artifactManifest(dist).sha256, checkedAt: (/* @__PURE__ */ new Date()).toISOString(), remoteUrl: opts.remoteUrl, checks: [], failures: [], warnings: [...manifest.warnings.filter((w) => !w.startsWith("Forms are preview-only")), ...connected ? ["Resting-page fidelity uses unchanged reference captures. Challenge and acceptance responses are mocked here; separate service integration tests are required."] : ["Forms are preview-only; no submissions are sent."]] };
+  if (!manifest.pages.length || !manifest.pages.some((p) => p.path === "/")) throw new Error("Preservation manifest has no homepage");
+  const server = opts.remoteUrl ? void 0 : previewServer(dist);
+  if (server) await new Promise((done) => server.listen(0, "127.0.0.1", done));
+  const origin = opts.remoteUrl ? new URL(opts.remoteUrl).origin : `http://127.0.0.1:${server.address().port}`;
+  const browser = await chromium2.launch({ headless: true });
+  const comparePage = await browser.newPage();
+  const abort = () => {
+    void browser.close();
+  };
+  opts.signal?.addEventListener("abort", abort, { once: true });
+  try {
+    const screenshotDir = opts.remoteUrl ? "artifacts/preserve-remote" : "artifacts/preserve-verification";
+    const screenshots = join2(root, screenshotDir);
+    mkdirSync2(screenshots, { recursive: true });
+    const staticComponents = /* @__PURE__ */ new Map();
+    const reactComponents = /* @__PURE__ */ new Map();
+    const scriptedLimitations = [];
+    const repairedNavigation = /* @__PURE__ */ new Set();
+    const authoredPages = manifest.pages.map((p) => readFileSync2(within(dist, p.file), "utf8"));
+    const originalPages = new Map(manifest.pages.flatMap((p) => {
+      const file = p.references[0]?.file.replace(/-\d+\.png$/, "-rendered.html");
+      return file && existsSync2(within(root, file)) ? [[p.path, readFileSync2(within(root, file), "utf8")]] : [];
+    }));
+    const missingSourceAnchors = new Map(manifest.pages.map((p) => [p.path, originalMissingAnchors(originalPages.get(p.path) || "", p.url, originalPages)]));
+    const nullImages = originalNullImages(manifest, [...originalPages.values()], authoredPages);
+    const resolvedNavigationAssets = new Set(manifest.assets.filter((a) => a.captureError?.startsWith("Asset returned HTML:") && manifest.pages.some((p) => p.url === a.url) && !authoredPages.some((html) => html.includes("/" + a.file))).map((a) => a.url));
+    nullImages.forEach((url) => {
+      resolvedNavigationAssets.add(url);
+      report.warnings.push(`Original missing image ${url} retains its broken-image rendering using an inert local placeholder. No source photograph was available or invented.`);
+    });
+    for (const route of manifest.pages) {
+      const reference = route.references[0]?.file.replace(/-\d+\.png$/, "-rendered.html");
+      if (reference && existsSync2(within(root, reference))) {
+        const html = readFileSync2(within(root, reference), "utf8"), authored = readFileSync2(within(dist, route.file), "utf8");
+        staticComponents.set(route.path, staticLegacyComponents(html));
+        if (disabledLegacyServices(html, authored, !!config.previewDisabledTransactions && !connected)) staticComponents.get(route.path).add("service-1");
+        reactComponents.set(route.path, reactCapabilities(legacyReactState(html), html, authored, route.path, !!config.previewDisabledTransactions && !connected));
+        for (const path of repairedExternalNavigation(html, authored, manifest.sourceUrl)) repairedNavigation.add(path);
+        scriptedLimitations.push(...unsupportedApplicationScripts(html, manifest.sourceUrl).map((src) => `${route.path}: Unsupported scripted application removed from preview: ${src}`));
+      }
+    }
+    for (const path of repairedNavigation) report.warnings.push(`Malformed original external link repaired at ${path}; original copy and layout retained.`);
+    for (const route of manifest.pages.filter((p) => p.sourceFailure)) {
+      const proof = route.sourceFailure, response = readFileSync2(within(root, proof.responseFile));
+      if (createHash2("sha256").update(response).digest("hex") !== proof.responseSha256) throw Error("Original unavailable-route response changed");
+      const valid = originalPages.has(route.path) && (proof.kind === "http-404" ? proof.status === 404 : proof.kind === "soft-404" && proof.status === 200 && originalPages.get(route.path).includes("404 Page Not Found"));
+      if (!valid) throw Error("Invalid unavailable-route preservation evidence");
+      if ((manifest.blockers || []).some((b) => b.startsWith(route.path + ": Source " + (proof.kind === "http-404" ? "page failed:" : "returned a soft 404:")))) repairedNavigation.add(route.path);
+      report.warnings.push(`Original unavailable route ${route.path} retains its captured ${proof.kind} page. The preview returns HTTP 200 for this static error content; missing business content was not invented.`);
+    }
+    if (config.previewDisabledTransactions) report.warnings.push("Explicitly authorized preview: booking and checkout are disabled. Calendar availability is a capture-time snapshot. Custom forms and file selections remain local and never upload or notify customers.");
+    for (const [index, route] of manifest.pages.entries()) for (const width of PRESERVE_WIDTHS) {
+      opts.signal?.throwIfAborted();
+      opts.onLog?.(`Checking ${route.path} at ${width}px`);
+      const context = await browser.newContext({ viewport: { width, height: PRESERVE_HEIGHT }, deviceScaleFactor: 1, reducedMotion: "reduce", serviceWorkers: "block" });
+      const failures = [];
+      const approvedEmbeds = new Set(iframeSources(readFileSync2(within(dist, route.file), "utf8")).map(approvedEmbedUrl).filter((src) => !!src));
+      for (const src of approvedEmbeds) {
+        const warning = `Remote ${readOnlyEmbedProvider(src)} embed retained at ${route.path}: ${src}. Provider content, network availability and privacy behavior remain external dependencies.`;
+        if (!report.warnings.includes(warning)) report.warnings.push(warning);
+      }
+      await context.route("**/*", (request) => {
+        const url = request.request().url();
+        const target = new URL(url);
+        const formsBackend = connected && target.origin === config.backendOrigin && target.pathname === "/api/leads";
+        const challenge = connected && target.origin === "https://challenges.cloudflare.com" && (target.pathname === "/turnstile/v0/api.js" || target.pathname.startsWith("/cdn-cgi/challenge-platform/"));
+        const embed = isReadOnlyEmbedRequest(request.request(), approvedEmbeds);
+        if (embed && /(^|\.)vitris\.io$/.test(target.hostname) && /api|service|analytics/.test(target.pathname)) {
+          failures.push(`Legacy service in embed: ${url}`);
+          return request.abort();
+        }
+        if (target.origin !== origin && !url.startsWith("data:") && !formsBackend && !challenge && !embed) {
+          failures.push(`External dependency: ${url}`);
+          return request.abort();
+        }
+        return request.continue();
+      });
+      const page = await context.newPage();
+      page.on("pageerror", (error) => failures.push(error.message));
+      page.on("console", (message) => {
+        if (message.type() === "error") {
+          if (providerConsoleWarning(message.text(), message.location().url, approvedEmbeds)) {
+            const warning = "YouTube provider attempted compute-pressure telemetry; the browser denied this permission. Playback and the original frame permissions remain unchanged.";
+            if (!report.warnings.includes(warning)) report.warnings.push(warning);
+          } else failures.push(`Browser console: ${message.text()}`);
+        }
+      });
+      page.on("requestfailed", (request) => {
+        if (cancelledReviewTelemetry(request, request.failure()?.errorText, approvedEmbeds)) {
+          const warning = "MassageBook reviews provider conversion telemetry was cancelled by the browser. The external provider retains its own privacy behavior; review assets and functional requests still pass strict browser and visual checks.";
+          if (!report.warnings.includes(warning)) report.warnings.push(warning);
+        } else failures.push(`Resource failed: ${request.url()}: ${request.failure()?.errorText}`);
+      });
+      page.on("response", (response2) => {
+        if (response2.status() >= 400) failures.push(`HTTP ${response2.status()}: ${response2.url()}`);
+      });
+      const response = await page.goto(origin + route.path, { waitUntil: "load" });
+      if (!response?.ok()) failures.push(`Route failed: ${route.path}`);
+      if (opts.remoteUrl && response) {
+        const headers = response.headers();
+        if (!/noindex/i.test(headers["x-robots-tag"] || "")) failures.push("Hosted noindex header missing");
+        if (!(headers["content-security-policy"] || "").includes("default-src 'self'")) failures.push("Hosted preservation CSP missing");
+      }
+      await settle(page);
+      const screenshot = `${screenshotDir}/${index}-${width}.png`;
+      const actual = await page.screenshot({ fullPage: true, animations: "disabled", path: join2(root, screenshot) });
+      const reference = route.references.find((r) => r.width === width);
+      if (!reference) throw new Error(`Missing ${width}px reference for ${route.path}`);
+      const bytes = readFileSync2(within(root, reference.file));
+      if (createHash2("sha256").update(bytes).digest("hex") !== reference.sha256) throw new Error(`Reference capture changed: ${reference.file}`);
+      const diff = await compare(comparePage, bytes, actual);
+      const overflow = await page.evaluate(() => {
+        const { document, window } = globalThis;
+        return document.documentElement.scrollWidth > window.innerWidth + 1;
+      });
+      const referenceWidth = bytes[16] * 16777216 + bytes[17] * 65536 + bytes[18] * 256 + bytes[19];
+      if (overflow && referenceWidth <= width) failures.push("New horizontal overflow compared with the original");
+      else if (overflow) {
+        const warning = `Original horizontal overflow retained at ${route.path} (${width}px); no layout redesign applied.`;
+        if (!report.warnings.includes(warning)) report.warnings.push(warning);
+      }
+      if (!diff.dimensionsMatch || diff.changedPixelRatio > 5e-3) failures.push(`Visual difference ${(100 * diff.changedPixelRatio).toFixed(3)}% (limit 0.5%); dimensions ${diff.dimensionsMatch ? "match" : "differ"}`);
+      const broken = await page.locator("img").evaluateAll((images) => images.filter((i) => i.getAttribute("src") && !i.naturalWidth).map((i) => i.getAttribute("src")));
+      const newBroken = broken.filter((src) => !manifest.assets.some((a) => src === "/" + a.file && nullImages.has(a.url)));
+      if (newBroken.length) failures.push(`Broken images: ${newBroken.join(", ")}`);
+      const links = await page.locator("a[href]").evaluateAll((anchors) => anchors.map((a) => a.href));
+      if (links.some((href) => /^javascript:/i.test(href))) failures.push("Unadapted JavaScript link remains");
+      if (await page.locator("[data-preserve-disabled-custom-form][data-vitris-form]").count()) failures.push("Disabled custom form has a live service binding");
+      for (const href of links) {
+        const url = new URL(href);
+        if (url.origin !== origin) continue;
+        const target = manifest.pages.find((p) => p.path === url.pathname);
+        if (!target && !existsSync2(within(dist, "." + decodeURIComponent(url.pathname)))) failures.push(`Uncaptured internal link: ${url.pathname}`);
+        if (url.hash && target) {
+          const html = readFileSync2(within(dist, target.file), "utf8");
+          if (!html.includes(`id="${decodeURIComponent(url.hash.slice(1))}"`)) {
+            if (missingSourceAnchors.get(route.path).has(url.pathname + url.hash)) {
+              const warning = `Original missing anchor retained: ${url.pathname}${url.hash}. The source link already lacked its destination section.`;
+              if (!report.warnings.includes(warning)) report.warnings.push(warning);
+            } else failures.push(`Missing anchor: ${url.pathname}${url.hash}`);
+          }
+        }
+      }
+      failures.push(...await interactions(page, connected ? config.backendOrigin : void 0));
+      report.checks.push({ path: route.path, width, ...diff, screenshot, failures: [...new Set(failures)] });
+      await context.close();
+    }
+    report.failures = [...unresolvedCaptureBlockers(manifest, staticComponents, resolvedNavigationAssets, reactComponents, repairedNavigation), ...scriptedLimitations, ...report.checks.flatMap((c) => c.failures.map((f) => `${c.path} (${c.width}px): ${f}`))];
+    report.assetChecks = [];
+    let nextAsset = 0;
+    await Promise.all(Array.from({ length: 4 }, async () => {
+      while (nextAsset < manifest.assets.length) {
+        const asset = manifest.assets[nextAsset++];
+        try {
+          if (asset.referenceFile && asset.originalSha256 && createHash2("sha256").update(readFileSync2(within(root, asset.referenceFile))).digest("hex") !== asset.originalSha256) throw new Error("Original asset reference changed");
+          const expected = readFileSync2(within(dist, asset.file));
+          const response = await comparePage.request.get(origin + "/" + asset.file, { timeout: 3e4 });
+          if (!response.ok()) throw new Error(`HTTP ${response.status()}`);
+          const bytes = await response.body();
+          if (createHash2("sha256").update(bytes).digest("hex") !== createHash2("sha256").update(expected).digest("hex")) throw new Error("Served bytes differ from the authored build");
+          report.assetChecks.push({ file: asset.file, ok: true });
+        } catch (error) {
+          const message = error instanceof Error ? error.message : String(error);
+          report.assetChecks.push({ file: asset.file, ok: false, error: message });
+          report.failures.push(`Asset ${asset.file}: ${message}`);
+        }
+      }
+    }));
+    if (sourceRevision(root).digest !== report.sourceRevision || artifactManifest(dist).sha256 !== report.artifactDigest) report.failures.push("Source or build changed during verification");
+    report.ok = !report.failures.length;
+    save(join2(root, opts.remoteUrl ? "agent/reviews/preserve-remote.json" : "agent/reviews/preserve.json"), report);
+    return report;
+  } finally {
+    opts.signal?.removeEventListener("abort", abort);
+    await browser.close();
+    if (server) await new Promise((done) => server.close(() => done()));
+  }
+}
+
+export {
+  capturePreservedSite,
+  verifyPreservedSite
+};