@koda-sl/baker-cli 0.531.0 → 0.532.0

package/dist/scrape-FDBYU3TU.js

@@ -0,0 +1,2241 @@
+import {
+  INSPIRATION_HINTS
+} from "./chunk-JNSRQQDP.js";
+import {
+  perceptualHash
+} from "./chunk-DGCUPJZD.js";
+import "./chunk-CIW3Q7B2.js";
+import "./chunk-O7AMKMII.js";
+import {
+  captureBudgetMs,
+  captureProxyCredentials,
+  isProxyFailure,
+  nextPlannedRoute,
+  plannedRoutes,
+  refuseNonPublicUrl,
+  shouldEscalate
+} from "./chunk-VPF5A7CM.js";
+import {
+  registerSchema,
+  writeJson
+} from "./chunk-HZPTQRX6.js";
+import "./chunk-YQSBHWOI.js";
+
+// src/commands/landing/inspiration/scrape.ts
+import { defineCommand } from "citty";
+
+// src/engine/landing-library/proxyFailure.ts
+var PROXY_STATUS = 407;
+var PROXY_NET_ERRORS = [
+  "ERR_TUNNEL_CONNECTION_FAILED",
+  "ERR_PROXY_CONNECTION_FAILED",
+  "ERR_PROXY_AUTH_REQUESTED",
+  "ERR_PROXY_CERTIFICATE_INVALID",
+  "ERR_UNEXPECTED_PROXY_AUTH",
+  "ERR_MANDATORY_PROXY_CONFIGURATION_FAILED",
+  "ERR_HTTPS_PROXY_TUNNEL_RESPONSE_REDIRECT"
+];
+var PROXY_UNAVAILABLE_MESSAGE = "We couldn't reach this page just now. Please try adding it again.";
+function describeProxyFailure(error) {
+  const raw = error instanceof Error ? error.message : typeof error === "string" ? error : "";
+  if (!raw) return null;
+  const netError = /net::(ERR_[A-Z0-9_]+)/.exec(raw)?.[1];
+  if (!netError || !PROXY_NET_ERRORS.includes(netError)) return null;
+  return { code: "PROXY_UNAVAILABLE", message: PROXY_UNAVAILABLE_MESSAGE };
+}
+
+// src/engine/landing-library/unreachable.ts
+var NET_ERROR_REASONS = [
+  {
+    prefixes: ["ERR_NAME_NOT_RESOLVED", "ERR_NAME_RESOLUTION_FAILED"],
+    message: "We couldn't find this site \u2014 check the address is spelled right."
+  },
+  {
+    prefixes: ["ERR_SSL_", "ERR_CERT_", "ERR_TLS_", "ERR_BAD_SSL_"],
+    message: "This site's secure connection is broken, so no browser can open it \u2014 including ours. That's a fault on their side, not something you can fix here."
+  },
+  {
+    prefixes: ["ERR_TOO_MANY_REDIRECTS"],
+    message: "This site kept redirecting us and never settled on a page."
+  },
+  {
+    prefixes: ["ERR_BLOCKED_BY_", "ERR_ACCESS_DENIED"],
+    message: "This site refused our visit, so we couldn't read the page."
+  },
+  {
+    prefixes: [
+      "ERR_CONNECTION_",
+      "ERR_ADDRESS_UNREACHABLE",
+      "ERR_EMPTY_RESPONSE",
+      "ERR_NETWORK_CHANGED",
+      "ERR_INTERNET_DISCONNECTED",
+      "ERR_SOCKET_NOT_CONNECTED",
+      "ERR_TIMED_OUT"
+    ],
+    // No "try again later" here. This resolves to `SITE_UNREACHABLE`, which the
+    // corpus files as not worth re-running, so inviting a retry would promise
+    // something the retry surface then declines to do.
+    message: "This site didn't respond, so we couldn't read the page."
+  }
+];
+var GENERIC_UNREACHABLE = "We couldn't open this site, so there was no page to study.";
+var TOO_SLOW = "This site took too long to load, so we stopped waiting. Try again later.";
+function describeUnreachableSite(error) {
+  const raw = error instanceof Error ? error.message : typeof error === "string" ? error : "";
+  if (!raw) return null;
+  const netError = /net::(ERR_[A-Z0-9_]+)/.exec(raw)?.[1];
+  if (netError) {
+    const reason = NET_ERROR_REASONS.find(
+      (candidate) => candidate.prefixes.some((prefix) => netError.startsWith(prefix))
+    );
+    return { code: "SITE_UNREACHABLE", message: reason?.message ?? GENERIC_UNREACHABLE };
+  }
+  if (/Timeout \d+ms exceeded/.test(raw) || raw.includes("page.goto: Timeout")) {
+    return { code: "SITE_TOO_SLOW", message: TOO_SLOW };
+  }
+  return null;
+}
+function netErrorName(error) {
+  const raw = error instanceof Error ? error.message : typeof error === "string" ? error : "";
+  return raw ? /net::(ERR_[A-Z0-9_]+)/.exec(raw)?.[1] ?? null : null;
+}
+
+// src/engine/landing-library/blocked.ts
+var CHALLENGE_PHRASES = [
+  "just a moment",
+  "attention required",
+  "verify you are human",
+  "checking your browser",
+  "enable javascript and cookies to continue",
+  "unusual traffic",
+  "access denied",
+  "you have been blocked",
+  "request unsuccessful",
+  "are you a robot",
+  "security check",
+  "ddos protection",
+  "captcha"
+];
+var CHALLENGE_MARKERS = ["cf-browser-verification", "cf_chl_", "px-captcha", "_incapsula_", "distil_r_captcha"];
+function detectBlockedPage(page) {
+  if (page.status === PROXY_STATUS) {
+    return { code: "PROXY_UNAVAILABLE", message: PROXY_UNAVAILABLE_MESSAGE };
+  }
+  if (page.status !== null && page.status >= 400) {
+    return {
+      code: "HTTP_ERROR",
+      message: `The site returned ${page.status} instead of the page \u2014 it may be blocking automated visits.`
+    };
+  }
+  const haystack = `${page.title}
+${page.bodyText.slice(0, 2e3)}`.toLowerCase();
+  const phrase = CHALLENGE_PHRASES.find((candidate) => haystack.includes(candidate));
+  if (phrase) {
+    return { code: "BOT_CHALLENGE", message: "The site showed a security check instead of the page." };
+  }
+  const html = page.html?.toLowerCase() ?? "";
+  if (CHALLENGE_MARKERS.some((marker) => html.includes(marker))) {
+    return { code: "BOT_CHALLENGE", message: "The site showed a security check instead of the page." };
+  }
+  return null;
+}
+var BlockedPageError = class extends Error {
+  code;
+  constructor(blocked) {
+    super(blocked.message);
+    this.name = "BlockedPageError";
+    this.code = blocked.code;
+  }
+};
+var CaptureFailureError = class extends Error {
+  failure;
+  /**
+   * Which rungs were tried, and what each of them said.
+   *
+   * Carried out of the engine because nothing downstream could otherwise tell a
+   * page refused from three different addresses apart from one refused once —
+   * and those two call for opposite conclusions about whether to try again.
+   *
+   * It is also the only way to see the rollout fail silently. The E2B image
+   * installs the CLI at build time, so until the template is rebuilt a Runtime
+   * runs an older binary that ignores the credentials Convex hands it. That
+   * capture returns an envelope with **no rungs at all** — indistinguishable,
+   * from the outside, from a page that simply was not worth escalating.
+   *
+   * Deliberately thin: tier names and status codes only, so nothing here can
+   * carry a credential or the raw browser text that once reached a user.
+   */
+  rungs;
+  constructor(failure, rungs = []) {
+    super(failure.message);
+    this.name = "CaptureFailureError";
+    this.failure = failure;
+    this.rungs = rungs;
+  }
+};
+var LOCAL_ADDRESS_REFUSAL = "That address only opens from inside your own network, so there is nothing there for us to read. A reference page has to be live on the web.";
+var NODE_LEVEL_UNREACHABLE = ["econnrefused", "enotfound", "getaddrinfo"];
+var UNREACHABLE_MESSAGE = "We couldn't reach this page \u2014 the site didn't answer, or its security certificate isn't one we can read.";
+var TOO_SLOW_MESSAGE = "This page took too long to load, so we stopped waiting for it.";
+var CAPTURE_FAILED_MESSAGE = "We couldn't read this page.";
+function classifyCaptureFailure(error) {
+  if (error instanceof CaptureFailureError) return error.failure;
+  if (error instanceof BlockedPageError) {
+    return { code: error.code, message: error.message };
+  }
+  const proxyFailure = describeProxyFailure(error);
+  if (proxyFailure) return proxyFailure;
+  const unreachable = describeUnreachableSite(error);
+  if (unreachable) return unreachable;
+  const message = (error instanceof Error ? error.message : String(error)).toLowerCase();
+  if (NODE_LEVEL_UNREACHABLE.some((marker) => message.includes(marker))) {
+    return { code: "SITE_UNREACHABLE", message: UNREACHABLE_MESSAGE };
+  }
+  if (message.includes("timeout") && message.includes("exceeded")) {
+    return { code: "SITE_TOO_SLOW", message: TOO_SLOW_MESSAGE };
+  }
+  return { code: "CAPTURE_FAILED", message: CAPTURE_FAILED_MESSAGE };
+}
+
+// src/engine/landing-library/run.ts
+import { mkdir, writeFile as writeFile2 } from "fs/promises";
+import path2 from "path";
+
+// ../proxy/src/preflight.ts
+import http from "http";
+function classifyPreflightStatus(status) {
+  if (status === 200) return { usable: true };
+  if (status === 407) return { usable: false, problem: "auth" };
+  return { usable: false, problem: "unreachable" };
+}
+async function preflightProxyRoute(route, options = {}) {
+  if (route.kind !== "proxy") return { usable: true };
+  const timeoutMs = options.timeoutMs ?? 8e3;
+  const target = options.target ?? "example.com:443";
+  const endpoint = new URL(route.server);
+  const auth = Buffer.from(`${route.username}:${route.password}`).toString("base64");
+  return await new Promise((resolve) => {
+    const settle = (result) => {
+      request.destroy();
+      resolve(result);
+    };
+    const request = http.request({
+      host: endpoint.hostname,
+      port: Number(endpoint.port),
+      method: "CONNECT",
+      path: target,
+      headers: { "Proxy-Authorization": `Basic ${auth}`, Host: target },
+      timeout: timeoutMs
+    });
+    request.on("connect", (response, socket) => {
+      socket.destroy();
+      settle(classifyPreflightStatus(response.statusCode));
+    });
+    request.on("response", (response) => {
+      response.destroy();
+      settle(classifyPreflightStatus(response.statusCode));
+    });
+    request.on("timeout", () => settle({ usable: false, problem: "timeout" }));
+    request.on("error", () => settle({ usable: false, problem: "unreachable" }));
+    request.end();
+  });
+}
+
+// src/engine/landing-library/browser.ts
+import { createRequire } from "module";
+var require_ = createRequire(import.meta.url);
+var pwSpecifier = ["play", "wright"].join("");
+var DESKTOP_VIEWPORT = { width: 1440, height: 900 };
+var MOBILE_VIEWPORT = { width: 390, height: 844 };
+var DEVICE_SCALE_FACTOR = 2;
+async function launchBrowser(route = { kind: "direct" }) {
+  const playwright = require_(pwSpecifier);
+  return await playwright.chromium.launch({
+    headless: true,
+    args: ["--hide-scrollbars", "--disable-blink-features=AutomationControlled", "--mute-audio"],
+    ...route.kind === "proxy" ? { proxy: { server: route.server, username: route.username, password: route.password } } : {}
+  });
+}
+async function newPage(browser, viewport, opts = { motion: false }) {
+  const context = await browser.newContext({
+    viewport,
+    deviceScaleFactor: DEVICE_SCALE_FACTOR,
+    // We read third-party marketing pages and send them nothing — no cookies we
+    // own, no credentials, no form posts — so the usual reason to refuse a bad
+    // certificate (an attacker between us and a session we care about) does not
+    // apply. Refusing one instead makes a whole class of real sites permanently
+    // uncapturable: `growthspree.com` and `arcus.so` both fail the handshake,
+    // and `inspiration scrape` is the escalation the whole repo points agents at
+    // when `WebFetch` fails, so it inheriting the same blind spot means there is
+    // no route to those pages at all. Every capture therefore records that the
+    // certificate was not validated — see `PrepareResult.security`.
+    ignoreHTTPSErrors: true,
+    // Still captures freeze motion so screenshots are reproducible; the motion
+    // pass re-opens a context with animation enabled.
+    reducedMotion: opts.motion ? "no-preference" : "reduce",
+    userAgent: viewport.width < 500 ? "Mozilla/5.0 (iPhone; CPU iPhone OS 17_0 like Mac OS X) AppleWebKit/605.1.15 (KHTML, like Gecko) Version/17.0 Mobile/15E148 Safari/604.1" : "Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/141.0.0.0 Safari/537.36"
+  });
+  const page = await context.newPage();
+  return { context, page };
+}
+
+// src/engine/landing-library/usedCss.ts
+async function collectUsedCss(page, selector) {
+  const collected = await page.evaluate(inPageCollectUsedCss, selector);
+  const extra = [];
+  for (const href of collected.unreadableHrefs) {
+    const text = await fetchStylesheet(page, href);
+    if (text) extra.push(`/* ${href} */
+${text}`);
+  }
+  return { ...collected, css: [collected.css, ...extra].filter(Boolean).join("\n\n") };
+}
+async function fetchStylesheet(page, href) {
+  try {
+    const response = await page.request.get(href, { timeout: 1e4 });
+    if (!response.ok()) return null;
+    return await response.text();
+  } catch {
+    return null;
+  }
+}
+var inPageCollectUsedCss = (selector) => {
+  const root = document.querySelector(selector);
+  const empty = {
+    css: "",
+    variables: "",
+    inheritedSeed: "",
+    unreadableHrefs: [],
+    stats: { totalRules: 0, keptRules: 0, fontFaces: 0, keyframes: 0 }
+  };
+  if (!root) return empty;
+  const INHERITED = [
+    "color",
+    "font-family",
+    "font-size",
+    "font-weight",
+    "line-height",
+    "letter-spacing",
+    "text-align",
+    "background-color",
+    "-webkit-font-smoothing"
+  ];
+  const unreadableHrefs = [];
+  const kept = [];
+  const fontFaces = [];
+  const keyframesByName = /* @__PURE__ */ new Map();
+  let totalRules = 0;
+  let keptStyleRules = 0;
+  const matchesInSection = (selectorText) => {
+    for (const part of selectorText.split(",")) {
+      const base = part.replace(/::[a-zA-Z-]+(\([^)]*\))?/g, "").replace(/:(hover|focus|focus-visible|focus-within|active|visited|target|checked|disabled)\b/g, "").trim();
+      if (!base) continue;
+      try {
+        if (root.matches(base) || root.querySelector(base)) return true;
+      } catch {
+        return true;
+      }
+    }
+    return false;
+  };
+  const walk = (rules, sink) => {
+    for (const rule of Array.from(rules)) {
+      totalRules++;
+      if (rule instanceof CSSStyleRule) {
+        if (matchesInSection(rule.selectorText)) {
+          sink.push(rule.cssText);
+          keptStyleRules++;
+        }
+        continue;
+      }
+      if (rule instanceof CSSFontFaceRule) {
+        fontFaces.push(rule.cssText);
+        continue;
+      }
+      if (rule instanceof CSSKeyframesRule) {
+        keyframesByName.set(rule.name, rule.cssText);
+        continue;
+      }
+      const grouping = rule instanceof CSSMediaRule || rule instanceof CSSSupportsRule || typeof CSSLayerBlockRule !== "undefined" && rule instanceof CSSLayerBlockRule || typeof CSSContainerRule !== "undefined" && rule instanceof CSSContainerRule;
+      if (grouping) {
+        const inner = [];
+        walk(rule.cssRules, inner);
+        if (inner.length === 0) continue;
+        const condition = rule.conditionText ?? "";
+        const prelude = rule instanceof CSSMediaRule ? `@media ${condition}` : rule.cssText.split("{")[0]?.trim();
+        sink.push(`${prelude} {
+${inner.join("\n")}
+}`);
+      }
+    }
+  };
+  for (const sheet of Array.from(document.styleSheets)) {
+    const owner = sheet.ownerNode;
+    if (owner?.hasAttribute?.("data-baker-freeze")) continue;
+    try {
+      walk(sheet.cssRules, kept);
+    } catch {
+      if (sheet.href) unreadableHrefs.push(sheet.href);
+    }
+  }
+  const keptText = kept.join("\n");
+  const usedKeyframes = [];
+  for (const [name, text] of keyframesByName) {
+    if (new RegExp(`(^|[\\s:,])${name}([\\s;,}]|$)`).test(keptText)) usedKeyframes.push(text);
+  }
+  const rootStyle = getComputedStyle(root);
+  const variableDeclarations = [];
+  for (const property of Array.from(rootStyle)) {
+    if (!property.startsWith("--")) continue;
+    const value = rootStyle.getPropertyValue(property).trim();
+    if (value) variableDeclarations.push(`  ${property}: ${value};`);
+  }
+  const seed = INHERITED.map((property) => `  ${property}: ${rootStyle.getPropertyValue(property)};`).join("\n");
+  return {
+    css: [...fontFaces, ...usedKeyframes, ...kept].join("\n"),
+    variables: variableDeclarations.length ? `:root {
+${variableDeclarations.join("\n")}
+}` : "",
+    inheritedSeed: seed,
+    unreadableHrefs,
+    stats: {
+      totalRules,
+      keptRules: keptStyleRules,
+      fontFaces: fontFaces.length,
+      keyframes: usedKeyframes.length
+    }
+  };
+};
+
+// src/engine/landing-library/bundle.ts
+async function buildSectionBundle(page, selector, pageUrl) {
+  const used = await collectUsedCss(page, selector);
+  const extracted = await page.evaluate(inPageExtractMarkup, {
+    selector,
+    pageUrl,
+    rootAttribute: SECTION_ROOT_ATTRIBUTE
+  });
+  const css = [
+    "*, *::before, *::after { box-sizing: border-box; }",
+    "html, body { margin: 0; padding: 0; }",
+    used.variables,
+    `body {
+${used.inheritedSeed}
+}`,
+    used.css
+  ].filter(Boolean).join("\n\n");
+  const html = `<!doctype html>
+<html ${extracted.rootAttributes}>
+<head>
+<meta charset="utf-8">
+<meta name="viewport" content="width=device-width, initial-scale=1">
+<title>Section from ${escapeHtml(extracted.host)}</title>
+<style>
+${css}
+</style>
+</head>
+<body ${extracted.bodyAttributes}>
+${wrapInLayoutContext(extracted.html, extracted.layoutContext)}
+</body>
+</html>
+`;
+  return { html, css, assetUrls: extracted.assetUrls, stats: used.stats };
+}
+function escapeHtml(value) {
+  return value.replace(/[&<>"]/g, (c) => ({ "&": "&amp;", "<": "&lt;", ">": "&gt;", '"': "&quot;" })[c] ?? c);
+}
+var SECTION_ROOT_ATTRIBUTE = "data-baker-section-root";
+function wrapInLayoutContext(html, context) {
+  let wrapped = context.width > 0 && context.width < context.viewportWidth ? `<div style="width:${context.width}px;margin:0 auto;">
+${html}
+</div>` : html;
+  for (const ancestor of [...context.ancestors].reverse()) {
+    const attributes = ancestor.attributes ? ` ${ancestor.attributes}` : "";
+    const container = ancestor.containerType && ancestor.containerType !== "normal" ? `container-type:${ancestor.containerType};${ancestor.containerName && ancestor.containerName !== "none" ? `container-name:${ancestor.containerName};` : ""}` : "";
+    wrapped = `<${ancestor.tag}${attributes} style="${NEUTRALIZED_ANCESTOR_STYLE}${container}">
+${wrapped}
+</${ancestor.tag}>`;
+  }
+  return wrapped;
+}
+var NEUTRALIZED_ANCESTOR_STYLE = [
+  "display:block !important",
+  "position:static !important",
+  "margin:0 !important",
+  "padding:0 !important",
+  "border:0 !important",
+  "width:auto !important",
+  "min-width:0 !important",
+  "max-width:none !important",
+  "height:auto !important",
+  "min-height:0 !important",
+  "max-height:none !important",
+  "transform:none !important",
+  "overflow:visible !important",
+  ""
+].join(";");
+var inPageExtractMarkup = ({
+  selector,
+  pageUrl,
+  rootAttribute
+}) => {
+  const root = document.querySelector(selector);
+  const emptyContext = { ancestors: [], width: 0, viewportWidth: 0 };
+  const serializeAttributes = (element) => {
+    if (!element) return "";
+    return Array.from(element.attributes).filter((attribute) => attribute.name !== "style").map((attribute) => `${attribute.name}="${attribute.value.replace(/"/g, "&quot;")}"`).join(" ");
+  };
+  const rootAttributes = serializeAttributes(document.documentElement) || 'lang="en"';
+  const bodyAttributes = serializeAttributes(document.body);
+  if (!root) {
+    return {
+      html: "",
+      assetUrls: [],
+      host: "",
+      layoutContext: emptyContext,
+      rootAttributes,
+      bodyAttributes
+    };
+  }
+  const ancestors = [];
+  for (let ancestor = root.parentElement; ancestor && ancestor !== document.body; ) {
+    const style = getComputedStyle(ancestor);
+    ancestors.unshift({
+      tag: /^[a-zA-Z][a-zA-Z0-9-]*$/.test(ancestor.tagName) ? ancestor.tagName.toLowerCase() : "div",
+      attributes: Array.from(ancestor.attributes).filter((a) => a.name === "class" || a.name === "id" || a.name.startsWith("data-")).map((a) => `${a.name}="${a.value.replace(/"/g, "&quot;")}"`).join(" "),
+      containerType: style.containerType,
+      containerName: style.containerName
+    });
+    ancestor = ancestor.parentElement;
+  }
+  const layoutContext = {
+    ancestors,
+    width: Math.round(root.getBoundingClientRect().width),
+    viewportWidth: window.innerWidth
+  };
+  const absolute = (value) => {
+    try {
+      return new URL(value, pageUrl).href;
+    } catch {
+      return value;
+    }
+  };
+  const clone = root.cloneNode(true);
+  clone.setAttribute(rootAttribute, "");
+  const assetUrls = /* @__PURE__ */ new Set();
+  for (const element of [clone, ...Array.from(clone.querySelectorAll("*"))]) {
+    for (const attribute of ["src", "href", "poster"]) {
+      const value = element.getAttribute(attribute);
+      if (!value || value.startsWith("data:") || value.startsWith("#")) continue;
+      const url = absolute(value);
+      element.setAttribute(attribute, url);
+      if (attribute !== "href" || element.tagName === "LINK") assetUrls.add(url);
+    }
+    const srcset = element.getAttribute("srcset");
+    if (srcset) {
+      element.setAttribute(
+        "srcset",
+        srcset.split(",").map((candidate) => {
+          const [url, descriptor] = candidate.trim().split(/\s+/, 2);
+          if (!url) return candidate;
+          const resolved = absolute(url);
+          assetUrls.add(resolved);
+          return descriptor ? `${resolved} ${descriptor}` : resolved;
+        }).join(", ")
+      );
+    }
+    const style = element.getAttribute("style");
+    if (style?.includes("url(")) {
+      element.setAttribute(
+        "style",
+        style.replace(/url\((['"]?)([^'")]+)\1\)/g, (_match, quote, url) => {
+          if (url.startsWith("data:")) return `url(${quote}${url}${quote})`;
+          const resolved = absolute(url);
+          assetUrls.add(resolved);
+          return `url(${quote}${resolved}${quote})`;
+        })
+      );
+    }
+  }
+  return {
+    html: clone.outerHTML,
+    assetUrls: Array.from(assetUrls),
+    host: location.host,
+    layoutContext,
+    rootAttributes,
+    bodyAttributes
+  };
+};
+
+// src/engine/landing-library/capture.ts
+async function captureSection(page, section) {
+  const locator = page.locator(section.selector).first();
+  if (await locator.count().catch(() => 0)) {
+    const shot = await locator.screenshot({ type: "png", timeout: 15e3 }).catch(() => null);
+    if (shot) return shot;
+  }
+  const doc = await page.evaluate(() => ({
+    width: Math.max(document.documentElement.scrollWidth, document.body?.scrollWidth ?? 0),
+    height: Math.max(document.documentElement.scrollHeight, document.body?.scrollHeight ?? 0)
+  }));
+  const width = Math.min(section.rect.width, doc.width - section.rect.left);
+  const height = Math.min(section.rect.height, doc.height - section.rect.top);
+  if (width <= 0 || height <= 0) return null;
+  return await page.screenshot({
+    type: "png",
+    clip: { x: section.rect.left, y: section.rect.top, width, height },
+    timeout: 15e3
+  }).catch(() => null);
+}
+async function captureSectionOnMobile(page, section) {
+  const locator = page.locator(section.selector).first();
+  if (!await locator.count().catch(() => 0)) return null;
+  if (!await locator.isVisible().catch(() => false)) return null;
+  return await locator.screenshot({ type: "png", timeout: 15e3 }).catch(() => null);
+}
+
+// src/engine/landing-library/escalation.ts
+var CAPTURE_RESERVE_MS = 18e4;
+function attemptSignal(outcome) {
+  const code = outcome.failure.code;
+  return {
+    challenge: code === "BOT_CHALLENGE",
+    status: outcome.status,
+    netError: outcome.netError,
+    timedOut: code === "SITE_TOO_SLOW"
+  };
+}
+function ambiguousProxyTimeout(outcome) {
+  return outcome.route.kind === "proxy" && outcome.failure.code === "SITE_TOO_SLOW" && outcome.status === null && outcome.netError === null;
+}
+function asProxyFailure(outcome, problem) {
+  return {
+    ...outcome,
+    failure: { code: "PROXY_UNAVAILABLE", message: PROXY_UNAVAILABLE_MESSAGE },
+    // Borrowing Chromium's own vocabulary so `isProxyFailure` recognises this
+    // without having to learn a second way of being told the same thing.
+    netError: problem === "auth" ? "ERR_PROXY_AUTH_REQUESTED" : "ERR_PROXY_CONNECTION_FAILED"
+  };
+}
+function nextRoute(args) {
+  const last = args.attempts[args.attempts.length - 1];
+  if (!last) return { next: null, reason: "ladder_exhausted" };
+  const brokenProxy = isProxyFailure(attemptSignal(last));
+  if (!brokenProxy && !shouldEscalate(attemptSignal(last))) {
+    return { next: null, reason: "site_fault_is_final" };
+  }
+  const next = nextPlannedRoute(
+    args.routes,
+    args.attempts.map((attempt) => ({
+      tier: attempt.route.kind === "proxy" ? attempt.route.tier : "direct",
+      proxyFailure: isProxyFailure(attemptSignal(attempt))
+    }))
+  );
+  if (!next) return { next: null, reason: args.routes.length === 1 ? "not_configured" : "ladder_exhausted" };
+  if (args.remainingMs < args.reserveMs + args.navTimeoutMs) {
+    return { next: null, reason: "out_of_budget" };
+  }
+  return { next, reason: "escalate" };
+}
+function reportableFailure(attempts) {
+  const siteVerdicts = attempts.filter((attempt) => !isProxyFailure(attemptSignal(attempt)));
+  const chosen = siteVerdicts.find((attempt) => attempt.status !== null) ?? siteVerdicts[siteVerdicts.length - 1] ?? attempts[attempts.length - 1];
+  if (!chosen) throw new Error("reportableFailure called with no attempts");
+  return chosen.failure;
+}
+
+// src/engine/landing-library/fidelity.ts
+import sharp from "sharp";
+var COMPARISON_SIZE = 32;
+function pixelSimilarity(a, b) {
+  const length = Math.min(a.length, b.length);
+  if (length === 0) return 0;
+  let total = 0;
+  for (let i = 0; i < length; i++) {
+    total += Math.abs((a[i] ?? 0) - (b[i] ?? 0));
+  }
+  return 1 - total / (length * 255);
+}
+async function scoreFidelity(live, rendered) {
+  const [liveMeta, renderedMeta] = await Promise.all([sharp(live).metadata(), sharp(rendered).metadata()]);
+  const liveSize = { width: liveMeta.width ?? 0, height: liveMeta.height ?? 0 };
+  const renderedSize = { width: renderedMeta.width ?? 0, height: renderedMeta.height ?? 0 };
+  const [livePixels, renderedPixels] = await Promise.all([toGreyGrid(live), toGreyGrid(rendered)]);
+  const score = pixelSimilarity(livePixels, renderedPixels);
+  const heightRatio = liveSize.height > 0 && renderedSize.height > 0 ? Math.min(liveSize.height, renderedSize.height) / Math.max(liveSize.height, renderedSize.height) : 0;
+  return {
+    score,
+    liveSize,
+    renderedSize,
+    ...heightRatio < 0.8 ? { note: `height differs by ${Math.round((1 - heightRatio) * 100)}% \u2014 the bundle reflowed` } : {}
+  };
+}
+async function toGreyGrid(image) {
+  const raw = await sharp(image).greyscale().resize(COMPARISON_SIZE, COMPARISON_SIZE, { fit: "fill" }).raw().toBuffer();
+  return new Uint8Array(raw);
+}
+
+// src/engine/landing-library/motion.ts
+var EMPTY_MOTION = {
+  hasMotion: false,
+  // `none` rather than "no motion": it is the `MOTION_KINDS` member for this,
+  // so a section with no movement is findable by the same facet as everything
+  // else instead of being a special case only prose describes.
+  summary: "none",
+  entrance: [],
+  hover: [],
+  scroll: [],
+  loop: [],
+  libraries: [],
+  respectsReducedMotion: false
+};
+function isWorthFilming(motion) {
+  return motion.entrance.length + motion.scroll.length + motion.loop.length > 0;
+}
+async function collectMotion(page, selector) {
+  const raw = await page.evaluate(inPageCollectMotion, selector).catch(() => null);
+  if (!raw) return EMPTY_MOTION;
+  return { ...raw, summary: summarizeMotion(raw) };
+}
+var HOVER_TRANSFORMS = /* @__PURE__ */ new Set(["lift", "grow", "tilt", "shift", "spin", "shadow", "animate"]);
+var KEYFRAME_PATTERNS = [
+  [/marquee|ticker|scroll(ing)?-?(x|left|right)/, "marquee"],
+  [/parallax/, "parallax"],
+  [/sticky|pin(ned)?/, "sticky-pin"],
+  [/count(er|up)/, "counter"],
+  [/zoom|scale|pulse|grow/, "zoom"],
+  [/fade|opacity|appear/, "fade"],
+  [/slide|translate|in-?(left|right|up|down)/, "slide-in"]
+];
+function toMotionKinds(kind, channel) {
+  if (channel === "hover") return [HOVER_TRANSFORMS.has(kind) ? "hover-lift" : "fade"];
+  const name = kind.toLowerCase();
+  const matched = KEYFRAME_PATTERNS.filter(([pattern]) => pattern.test(name)).map(([, motionKind]) => motionKind);
+  if (matched.length > 0) return matched;
+  return [channel === "loop" ? "marquee" : "scroll-reveal"];
+}
+function motionKindsOf(motion) {
+  const kinds = /* @__PURE__ */ new Set();
+  const collect = (effects, channel) => {
+    for (const effect of effects) {
+      for (const kind of toMotionKinds(effect.kind, channel)) kinds.add(kind);
+    }
+  };
+  collect(motion.entrance, "entrance");
+  collect(motion.hover, "hover");
+  collect(motion.scroll, "scroll");
+  collect(motion.loop, "loop");
+  const delays = new Set(motion.entrance.map((effect) => effect.delayMs ?? 0).filter((ms) => ms > 0));
+  if (delays.size > 1) kinds.add("stagger");
+  return [...kinds];
+}
+function summarizeMotion(motion) {
+  const kinds = motionKindsOf(motion);
+  if (kinds.length === 0 && motion.libraries.length === 0) return "none";
+  const parts = [...kinds];
+  if (motion.libraries.length > 0) parts.push(`via ${motion.libraries.join("/")}`);
+  return parts.join(", ") + (motion.respectsReducedMotion ? "" : " (ignores reduced-motion)");
+}
+var inPageCollectMotion = (selector) => {
+  const root = document.querySelector(selector);
+  const empty = {
+    hasMotion: false,
+    entrance: [],
+    hover: [],
+    scroll: [],
+    loop: [],
+    libraries: [],
+    respectsReducedMotion: false
+  };
+  if (!root) return empty;
+  const entrance = [];
+  const hover = [];
+  const scroll = [];
+  const loop = [];
+  const keyframesByName = /* @__PURE__ */ new Map();
+  let respectsReducedMotion = false;
+  const inSection = (selectorText) => {
+    for (const part of selectorText.split(",")) {
+      const base = part.replace(/::[a-zA-Z-]+(\([^)]*\))?/g, "").replace(/:(hover|focus|focus-visible|focus-within|active|visited|target|checked|disabled)\b/g, "").trim();
+      if (!base) continue;
+      try {
+        if (root.matches(base) || root.querySelector(base)) return true;
+      } catch {
+        return true;
+      }
+    }
+    return false;
+  };
+  const toMs = (value) => {
+    const first = value.split(",")[0]?.trim() ?? "";
+    if (first.endsWith("ms")) return Number.parseFloat(first);
+    if (first.endsWith("s")) return Number.parseFloat(first) * 1e3;
+    return void 0;
+  };
+  const classifyKeyframes = (body) => {
+    const text = body.toLowerCase();
+    const fades = /opacity\s*:\s*0(\.0+)?\s*[;}]/.test(text);
+    if (/translatey\(\s*-?\d/.test(text)) {
+      const upward = /translatey\(\s*(\d|\.)/.test(text);
+      return fades ? upward ? "fade-up" : "fade-down" : upward ? "slide-up" : "slide-down";
+    }
+    if (/translatex\(\s*-?\d/.test(text)) return fades ? "fade-in-x" : "slide-in-x";
+    if (/scale\(/.test(text)) return fades ? "fade-zoom" : "zoom";
+    if (/rotate\(/.test(text)) return "spin";
+    if (fades) return "fade";
+    return "animate";
+  };
+  const classifyHover = (style) => {
+    const transform = style.transform ?? "";
+    if (/translatey\(\s*-/i.test(transform)) return "lift";
+    if (/scale\(\s*(1\.\d|[2-9])/i.test(transform)) return "grow";
+    if (/rotate\(/i.test(transform)) return "tilt";
+    if (transform && transform !== "none") return "shift";
+    if (style.boxShadow) return "shadow";
+    if (style.opacity) return "dim";
+    if (style.backgroundColor || style.color) return "recolor";
+    return null;
+  };
+  const readStyleRule = (rule, insideScrollTimeline) => {
+    const style = rule.style;
+    const isHover = /:hover\b/.test(rule.selectorText);
+    if (isHover) {
+      const kind = classifyHover(style);
+      if (!kind || !inSection(rule.selectorText)) return;
+      hover.push({
+        kind,
+        selector: rule.selectorText.slice(0, 120),
+        durationMs: toMs(style.transitionDuration ?? ""),
+        easing: style.transitionTimingFunction || void 0
+      });
+      return;
+    }
+    const animationName = style.animationName;
+    if (!animationName || animationName === "none") return;
+    if (!inSection(rule.selectorText)) return;
+    const effect = {
+      kind: animationName,
+      selector: rule.selectorText.slice(0, 120),
+      durationMs: toMs(style.animationDuration ?? ""),
+      delayMs: toMs(style.animationDelay ?? ""),
+      easing: style.animationTimingFunction || void 0
+    };
+    const infinite = (style.animationIterationCount ?? "").includes("infinite");
+    const scrollDriven = insideScrollTimeline || Boolean(style.getPropertyValue("animation-timeline"));
+    if (scrollDriven) scroll.push(effect);
+    else if (infinite) loop.push(effect);
+    else entrance.push(effect);
+  };
+  const walk = (rules, insideScrollTimeline) => {
+    for (const rule of Array.from(rules)) {
+      if (rule instanceof CSSKeyframesRule) {
+        keyframesByName.set(rule.name, rule.cssText);
+        continue;
+      }
+      if (rule instanceof CSSStyleRule) {
+        try {
+          readStyleRule(rule, insideScrollTimeline);
+        } catch {
+        }
+        continue;
+      }
+      if (rule instanceof CSSMediaRule) {
+        if (rule.conditionText.includes("prefers-reduced-motion")) {
+          respectsReducedMotion = true;
+          continue;
+        }
+        walk(rule.cssRules, insideScrollTimeline);
+        continue;
+      }
+      const grouping = rule;
+      if (grouping.cssRules) walk(grouping.cssRules, insideScrollTimeline);
+    }
+  };
+  for (const sheet of Array.from(document.styleSheets)) {
+    if (sheet.ownerNode?.hasAttribute?.("data-baker-freeze")) continue;
+    try {
+      walk(sheet.cssRules, false);
+    } catch {
+    }
+  }
+  for (const effect of [...entrance, ...loop, ...scroll]) {
+    const body = keyframesByName.get(effect.kind);
+    if (!body) continue;
+    const classified = classifyKeyframes(body);
+    effect.kind = loop.includes(effect) && classified.startsWith("slide") ? "marquee" : classified;
+  }
+  const libraries = [];
+  const scoped = window ?? {};
+  if (scoped.gsap || document.querySelector("[data-gsap]")) libraries.push("gsap");
+  if (document.querySelector("[data-framer-name], [data-projection-id]")) libraries.push("framer-motion");
+  if (document.querySelector("[data-aos]")) libraries.push("aos");
+  if (scoped.Lenis || document.querySelector("[data-lenis]")) libraries.push("lenis");
+  if (document.querySelector("[data-scroll], [data-scroll-container]")) libraries.push("locomotive");
+  return {
+    hasMotion: entrance.length + hover.length + scroll.length + loop.length + libraries.length > 0,
+    entrance: entrance.slice(0, 12),
+    hover: hover.slice(0, 12),
+    scroll: scroll.slice(0, 12),
+    loop: loop.slice(0, 12),
+    libraries,
+    respectsReducedMotion
+  };
+};
+
+// src/engine/landing-library/motionTake.ts
+import sharp2 from "sharp";
+
+// src/engine/landing-library/certificate.ts
+function formatDate(unixSeconds) {
+  return new Date(unixSeconds * 1e3).toLocaleDateString("en-GB", {
+    day: "numeric",
+    month: "long",
+    year: "numeric"
+  });
+}
+function describeCapturedCertificate(details, now = Date.now()) {
+  if (!details) {
+    return {
+      certificateValidated: false,
+      certificate: null,
+      certificateNotes: ["This page was served over an unencrypted connection, so nothing about it could be verified."]
+    };
+  }
+  const notes = [];
+  if (details.validTo !== void 0 && details.validTo * 1e3 < now) {
+    notes.push(`The site's security certificate expired on ${formatDate(details.validTo)}.`);
+  }
+  if (details.validFrom !== void 0 && details.validFrom * 1e3 > now) {
+    notes.push(`The site's security certificate is not valid until ${formatDate(details.validFrom)}.`);
+  }
+  return { certificateValidated: false, certificate: details, certificateNotes: notes };
+}
+
+// src/engine/landing-library/prepare.ts
+function isNavigationTeardown(error) {
+  const message = error instanceof Error ? error.message : typeof error === "string" ? error : "";
+  return message.includes("Execution context was destroyed") || message.includes("Cannot find context with specified id") || message.includes("frame was detached") || message.includes("has been closed");
+}
+var CONSENT_SELECTORS = [
+  "#onetrust-accept-btn-handler",
+  "#CybotCookiebotDialogBodyLevelButtonLevelOptinAllowAll",
+  "button#didomi-notice-agree-button",
+  "[aria-label='Accept all']",
+  "[data-testid='uc-accept-all-button']",
+  ".cc-allow",
+  ".cookie-accept"
+];
+var CONSENT_TEXTS = ["Accept all", "Accept All", "Allow all", "I agree", "Got it", "Aceptar todo"];
+var CONSENT_HOSTS = [
+  "transcend-cdn.com",
+  "cookielaw.org",
+  "onetrust.com",
+  "cookiebot.com",
+  "osano.com",
+  "trustarc.com",
+  "truste.com",
+  "usercentrics.eu",
+  "didomi.io",
+  "privacy-center.org",
+  "iubenda.com",
+  "termly.io",
+  "cookieyes.com",
+  "sp-prod.net",
+  "quantcast.com",
+  "consensu.org",
+  "ketch.com",
+  "secureprivacy.ai",
+  "civicuk.com"
+];
+async function blockConsentManagers(page) {
+  await page.route("**/*", (route) => {
+    let host = "";
+    try {
+      host = new URL(route.request().url()).host;
+    } catch {
+      return route.continue();
+    }
+    const isConsentVendor = CONSENT_HOSTS.some((vendor) => host === vendor || host.endsWith(`.${vendor}`));
+    return isConsentVendor ? route.abort() : route.continue();
+  });
+}
+var ignore = () => void 0;
+async function preparePage(page, url, timeoutMs) {
+  const documentStatus = trackMainDocumentStatus(page);
+  try {
+    const response = await page.goto(url, { waitUntil: "domcontentloaded", timeout: timeoutMs });
+    await settleNavigation(page);
+    await page.waitForLoadState("networkidle", { timeout: 8e3 }).catch(ignore);
+    await dismissConsent(page, 4e3);
+    await scrollThroughPage(page);
+    await dismissConsent(page, 1e3);
+    await acrossNavigation(
+      page,
+      () => page.evaluate(async () => {
+        await document.fonts.ready;
+      })
+    );
+    await freezeMotion(page);
+    await unpinOverlays(page);
+    const measured = await acrossNavigation(
+      page,
+      () => page.evaluate(() => ({
+        finalUrl: location.href,
+        title: document.title,
+        documentHeight: Math.max(document.documentElement.scrollHeight, document.body?.scrollHeight ?? 0),
+        bodyText: (document.body?.innerText ?? "").slice(0, 2e3)
+      }))
+    );
+    const served = documentStatus.lastResponse() ?? response;
+    const certificate = await served?.securityDetails().catch(() => null);
+    return {
+      ...measured,
+      status: documentStatus.last() ?? response?.status() ?? null,
+      security: describeCapturedCertificate(certificate)
+    };
+  } finally {
+    documentStatus.stop();
+  }
+}
+function trackMainDocumentStatus(page) {
+  let status = null;
+  let last = null;
+  const onResponse = (response) => {
+    const request = response.request();
+    if (request.resourceType() !== "document" || request.frame() !== page.mainFrame()) return;
+    const code = response.status();
+    if (code >= 300 && code < 400) return;
+    status = code;
+    last = response;
+  };
+  page.on("response", onResponse);
+  return { last: () => status, lastResponse: () => last, stop: () => page.off("response", onResponse) };
+}
+var NAVIGATION_QUIET_MS = 1500;
+var NAVIGATION_SETTLE_BUDGET_MS = 2e4;
+async function settleNavigation(page, budgetMs = NAVIGATION_SETTLE_BUDGET_MS) {
+  let lastNavigatedAt = Date.now();
+  const onNavigated = (frame) => {
+    if (frame === page.mainFrame()) lastNavigatedAt = Date.now();
+  };
+  page.on("framenavigated", onNavigated);
+  try {
+    const deadline = Date.now() + budgetMs;
+    while (Date.now() < deadline && Date.now() - lastNavigatedAt < NAVIGATION_QUIET_MS) {
+      await page.waitForTimeout(250);
+    }
+  } finally {
+    page.off("framenavigated", onNavigated);
+  }
+}
+async function acrossNavigation(page, run) {
+  try {
+    return await run();
+  } catch (error) {
+    if (!isNavigationTeardown(error)) throw error;
+    await settleNavigation(page);
+    return await run();
+  }
+}
+async function settleConsent(page) {
+  await dismissConsent(page, 4e3);
+  await page.mouse.wheel(0, 400).catch(ignore);
+  await page.waitForTimeout(1500);
+  await dismissConsent(page, 2e3);
+  await page.evaluate(() => window.scrollTo(0, 0)).catch(ignore);
+}
+async function dismissConsent(page, waitForBannerMs) {
+  await page.locator(CONSENT_SELECTORS.join(", ")).first().waitFor({ state: "attached", timeout: waitForBannerMs }).catch(ignore);
+  for (const selector of CONSENT_SELECTORS) {
+    const found = page.locator(selector).first();
+    if (!await found.count().catch(() => 0)) continue;
+    await found.click({ timeout: 2e3, force: true }).catch(ignore);
+    await page.waitForTimeout(400);
+    return;
+  }
+  for (const text of CONSENT_TEXTS) {
+    const button = page.getByRole("button", { name: text, exact: false }).first();
+    if (!await button.count().catch(() => 0)) continue;
+    if (!await button.isVisible().catch(() => false)) continue;
+    await button.click({ timeout: 2e3, force: true }).catch(ignore);
+    await page.waitForTimeout(400);
+    return;
+  }
+}
+async function scrollThroughPage(page) {
+  await acrossNavigation(
+    page,
+    () => page.evaluate(async () => {
+      const step = 600;
+      const pause = () => new Promise((resolve) => setTimeout(resolve, 250));
+      for (let i = 0; i < 40; i++) {
+        window.scrollBy(0, step);
+        await pause();
+        const reachedBottom = window.scrollY + window.innerHeight >= document.documentElement.scrollHeight - 2;
+        if (reachedBottom) break;
+      }
+      window.scrollTo(0, 0);
+      await pause();
+    })
+  );
+  await page.waitForTimeout(500);
+}
+var MAX_HEADER_HEIGHT = 220;
+function inPageUnpinOverlays(maxHeaderHeight) {
+  window.scrollTo(0, 0);
+  for (const element of Array.from(document.querySelectorAll("*"))) {
+    const position = getComputedStyle(element).position;
+    if (position === "sticky") {
+      element.style.setProperty("position", "static", "important");
+      continue;
+    }
+    if (position !== "fixed") continue;
+    const rect = element.getBoundingClientRect();
+    const isTopAnchoredHeader = rect.top <= 8 && rect.height > 0 && rect.height <= maxHeaderHeight;
+    if (isTopAnchoredHeader) {
+      element.style.setProperty("position", "absolute", "important");
+      element.style.setProperty("bottom", "auto", "important");
+    } else {
+      element.style.setProperty("display", "none", "important");
+    }
+  }
+}
+async function unpinOverlays(page) {
+  await acrossNavigation(page, () => page.evaluate(inPageUnpinOverlays, MAX_HEADER_HEIGHT));
+  await page.waitForTimeout(250);
+}
+async function freezeMotion(page) {
+  await acrossNavigation(
+    page,
+    () => page.evaluate(() => {
+      const highestTimer = window.setTimeout(() => void 0, 0);
+      for (let id = 1; id <= highestTimer; id++) window.clearInterval(id);
+      const style = document.createElement("style");
+      style.setAttribute("data-baker-freeze", "true");
+      style.textContent = `*, *::before, *::after {
+      animation-play-state: paused !important;
+      animation-delay: 0s !important;
+      transition: none !important;
+    }`;
+      document.head.appendChild(style);
+      for (const video of Array.from(document.querySelectorAll("video"))) {
+        video.pause();
+      }
+    })
+  );
+  await page.waitForTimeout(250);
+}
+
+// src/engine/landing-library/geometry.ts
+function adaptiveGapThreshold(bands) {
+  const sorted = [...bands].sort((a, b) => a.top - b.top);
+  const gaps = [];
+  for (let i = 0; i < sorted.length - 1; i++) {
+    const current = sorted[i];
+    const next = sorted[i + 1];
+    if (!current || !next) continue;
+    if (next.top > current.bottom) {
+      const gap = next.top - current.bottom;
+      if (gap < 200) gaps.push(gap);
+    }
+  }
+  gaps.sort((a, b) => a - b);
+  const p75 = gaps[Math.floor(gaps.length * 0.75)];
+  if (p75 === void 0) return 15;
+  return Math.max(10, Math.min(50, p75));
+}
+function bandsCollide(a, b, margin, maxGap) {
+  const shrunkA = { top: a.top + margin, bottom: a.bottom - margin };
+  const shrunkB = { top: b.top + margin, bottom: b.bottom - margin };
+  const overlaps = shrunkA.top <= shrunkB.bottom && shrunkA.bottom >= shrunkB.top || shrunkB.top <= shrunkA.bottom && shrunkB.bottom >= shrunkA.top;
+  if (overlaps) return true;
+  const gap = Math.min(Math.abs(shrunkA.bottom - shrunkB.top), Math.abs(shrunkB.bottom - shrunkA.top));
+  return gap <= maxGap;
+}
+function shouldPromoteToParent(group) {
+  const isRunt = group.childCount < 3 || group.height < 80;
+  return isRunt && group.parentHeight < 1600;
+}
+
+// src/engine/landing-library/segment.ts
+async function installPageRuntime(page) {
+  await page.addInitScript({
+    content: `
+      window.__name = window.__name || function (target) { return target; };
+      window.__bakerGeom = {
+        adaptiveGapThreshold: ${adaptiveGapThreshold.toString()},
+        bandsCollide: ${bandsCollide.toString()},
+        shouldPromoteToParent: ${shouldPromoteToParent.toString()},
+      };`
+  });
+}
+async function segmentPage(page, options) {
+  return await page.evaluate(inPageSegment, options);
+}
+var inPageSegment = (options) => {
+  const geom = window.__bakerGeom;
+  const scrollX = window.scrollX;
+  const scrollY = window.scrollY;
+  const docWidth = Math.max(document.documentElement.scrollWidth, document.body?.scrollWidth ?? 0);
+  const docHeight = Math.max(document.documentElement.scrollHeight, document.body?.scrollHeight ?? 0);
+  const rectOf = (element) => {
+    const r = element.getBoundingClientRect();
+    const top = Math.max(0, Math.round(r.top + scrollY));
+    const left = Math.max(0, Math.round(r.left + scrollX));
+    return {
+      top,
+      left,
+      bottom: Math.min(docHeight, Math.round(r.bottom + scrollY)),
+      right: Math.min(docWidth, Math.round(r.right + scrollX))
+    };
+  };
+  const syntheticRect = (element) => {
+    const children = Array.from(element.children);
+    if (children.length === 0) return null;
+    let top = Number.POSITIVE_INFINITY;
+    let left = Number.POSITIVE_INFINITY;
+    let bottom = Number.NEGATIVE_INFINITY;
+    let right = Number.NEGATIVE_INFINITY;
+    for (const child of children) {
+      const r = rectOf(child);
+      if (r.bottom - r.top <= 0 && r.right - r.left <= 0) continue;
+      top = Math.min(top, r.top);
+      left = Math.min(left, r.left);
+      bottom = Math.max(bottom, r.bottom);
+      right = Math.max(right, r.right);
+    }
+    if (!Number.isFinite(top) || !Number.isFinite(bottom)) return null;
+    return { top, left, bottom, right };
+  };
+  const boxOf = (element) => {
+    const style = getComputedStyle(element);
+    const r = style.display === "contents" ? syntheticRect(element) : rectOf(element);
+    if (!r) return null;
+    return { ...r, height: r.bottom - r.top, width: r.right - r.left };
+  };
+  const hasHiddenAncestor = (element) => {
+    let current = element;
+    while (current && current !== document.documentElement) {
+      const style = getComputedStyle(current);
+      if (style.display === "none" || style.visibility === "hidden" || Number(style.opacity) === 0) return true;
+      current = current.parentElement;
+    }
+    return false;
+  };
+  const isClippedByAncestor = (element, box) => {
+    let parent = element.parentElement;
+    while (parent && parent !== document.documentElement) {
+      const style = getComputedStyle(parent);
+      const clips = style.overflow === "hidden" || style.overflowX === "hidden" || style.overflowY === "hidden" || style.overflow === "clip";
+      if (clips) {
+        const p = rectOf(parent);
+        const intersects = box.left < p.right && box.right > p.left && box.top < p.bottom && box.bottom > p.top;
+        if (!intersects) return true;
+      }
+      parent = parent.parentElement;
+    }
+    return false;
+  };
+  const directText = (element) => {
+    let text = "";
+    for (const node of Array.from(element.childNodes)) {
+      if (node.nodeType === 3) text += node.textContent ?? "";
+    }
+    return text.trim();
+  };
+  const NON_COPY_TAGS = /* @__PURE__ */ new Set(["SCRIPT", "STYLE", "NOSCRIPT", "TEMPLATE"]);
+  const visibleText = (root) => {
+    let text = "";
+    const hiddenCache = /* @__PURE__ */ new Map();
+    const isHidden = (element) => {
+      const cached = hiddenCache.get(element);
+      if (cached !== void 0) return cached;
+      const style = getComputedStyle(element);
+      const hidden = style.display === "none" || style.visibility === "hidden";
+      hiddenCache.set(element, hidden);
+      return hidden;
+    };
+    const walker = document.createTreeWalker(root, NodeFilter.SHOW_TEXT, {
+      acceptNode: (node) => {
+        let parent = node.parentElement;
+        while (parent) {
+          if (NON_COPY_TAGS.has(parent.tagName) || isHidden(parent)) return NodeFilter.FILTER_REJECT;
+          if (parent === root) break;
+          parent = parent.parentElement;
+        }
+        return NodeFilter.FILTER_ACCEPT;
+      }
+    });
+    while (walker.nextNode() && text.length < 400) {
+      text += ` ${walker.currentNode.textContent ?? ""}`;
+    }
+    return text.replace(/\s+/g, " ").trim();
+  };
+  const GRAPHIC_TAGS = /* @__PURE__ */ new Set(["img", "svg", "video", "picture", "canvas", "iframe"]);
+  const hasBackgroundImage = (element) => {
+    const bg = getComputedStyle(element).backgroundImage;
+    return Boolean(bg) && bg !== "none" && bg.includes("url(");
+  };
+  const isContentLeaf = (element) => {
+    const tag = element.tagName.toLowerCase();
+    if (GRAPHIC_TAGS.has(tag)) return true;
+    if (directText(element).length > 0) return true;
+    return hasBackgroundImage(element);
+  };
+  const selectorFor = (element) => {
+    const parts = [];
+    let current = element;
+    while (current && current !== document.documentElement) {
+      const tag = current.tagName.toLowerCase();
+      if (tag === "body") {
+        parts.unshift("body");
+        break;
+      }
+      const parent = current.parentElement;
+      if (!parent) {
+        parts.unshift(tag);
+        break;
+      }
+      const sameTag = Array.from(parent.children).filter((c) => c.tagName === current?.tagName);
+      const position = sameTag.indexOf(current) + 1;
+      parts.unshift(sameTag.length > 1 ? `${tag}:nth-of-type(${position})` : tag);
+      current = parent;
+    }
+    return parts.join(" > ");
+  };
+  const leaves = [];
+  const all = document.querySelectorAll("*");
+  const limit = Math.min(all.length, options.maxElements);
+  for (let i = 0; i < limit; i++) {
+    const element = all[i];
+    if (!element) continue;
+    const tag = element.tagName.toLowerCase();
+    if (tag === "script" || tag === "style" || tag === "noscript" || tag === "link" || tag === "head") continue;
+    if (!isContentLeaf(element)) continue;
+    const box = boxOf(element);
+    if (!box || box.height <= 0 || box.width <= 0) continue;
+    if (box.height > options.maxSectionHeight) continue;
+    if (hasHiddenAncestor(element)) continue;
+    if (isClippedByAncestor(element, box)) continue;
+    leaves.push({
+      element,
+      top: box.top,
+      bottom: box.bottom,
+      left: box.left,
+      right: box.right,
+      height: box.height
+    });
+  }
+  if (leaves.length === 0) return [];
+  const gapThreshold = geom.adaptiveGapThreshold(leaves.map((l) => ({ top: l.top, bottom: l.bottom })));
+  const commonAncestor = (elements) => {
+    let ancestor = elements[0] ?? null;
+    while (ancestor && !elements.every((e) => ancestor?.contains(e))) {
+      ancestor = ancestor.parentElement;
+    }
+    return ancestor;
+  };
+  const abandon = (members) => members.map((m) => ({ ...m, sealed: true }));
+  const findCoveringAncestor = (start, bounds) => {
+    let element = start;
+    while (element) {
+      const box = boxOf(element);
+      if (!box) return null;
+      if (box.height > options.maxSectionHeight) return null;
+      const covers = box.top <= bounds.top && box.bottom >= bounds.bottom && box.left <= bounds.left && box.right >= bounds.right;
+      if (covers) return { element, box };
+      if (!element.parentElement || element.parentElement === document.documentElement) return null;
+      element = element.parentElement;
+    }
+    return null;
+  };
+  const mergeBucket = (members) => {
+    const bounds = {
+      top: Math.min(...members.map((m) => m.top)),
+      bottom: Math.max(...members.map((m) => m.bottom)),
+      left: Math.min(...members.map((m) => m.left)),
+      right: Math.max(...members.map((m) => m.right))
+    };
+    const covering = findCoveringAncestor(commonAncestor(members.map((m) => m.root)), bounds);
+    if (!covering) return abandon(members);
+    return [
+      {
+        root: covering.element,
+        top: covering.box.top,
+        bottom: covering.box.bottom,
+        left: covering.box.left,
+        right: covering.box.right,
+        height: covering.box.height,
+        leaves: members.flatMap((m) => m.leaves),
+        sealed: false
+      }
+    ];
+  };
+  const clusterOnce = (groups2) => {
+    const buckets = [];
+    for (const group of groups2) {
+      if (group.sealed) {
+        buckets.push([group]);
+        continue;
+      }
+      const target = buckets.find(
+        (bucket) => bucket.some(
+          (member) => !member.sealed && geom.bandsCollide(
+            { top: member.top, bottom: member.bottom },
+            { top: group.top, bottom: group.bottom },
+            options.collisionMargin,
+            gapThreshold
+          )
+        )
+      );
+      if (target) target.push(group);
+      else buckets.push([group]);
+    }
+    if (buckets.length === groups2.length) return groups2;
+    return buckets.flatMap((bucket) => bucket.length === 1 ? [bucket[0]] : mergeBucket(bucket));
+  };
+  let groups = leaves.map((leaf) => ({
+    root: leaf.element,
+    top: leaf.top,
+    bottom: leaf.bottom,
+    left: leaf.left,
+    right: leaf.right,
+    height: leaf.height,
+    leaves: [leaf],
+    sealed: false
+  }));
+  for (let pass = 0; pass < 40; pass++) {
+    const next = clusterOnce(groups);
+    if (next.length === groups.length) break;
+    groups = next;
+  }
+  for (let pass = 0; pass < 10; pass++) {
+    let promoted = false;
+    groups = groups.map((group) => {
+      const parent = group.root.parentElement;
+      if (!parent || parent === document.documentElement || parent === document.body) return group;
+      const parentBox = boxOf(parent);
+      if (!parentBox) return group;
+      if (!geom.shouldPromoteToParent({
+        childCount: group.leaves.length,
+        height: group.height,
+        parentHeight: parentBox.height
+      })) {
+        return group;
+      }
+      promoted = true;
+      return {
+        ...group,
+        root: parent,
+        top: parentBox.top,
+        bottom: parentBox.bottom,
+        left: parentBox.left,
+        right: parentBox.right,
+        height: parentBox.height
+      };
+    });
+    if (!promoted) break;
+    groups = clusterOnce(groups);
+  }
+  const sameBox = (a, b) => Math.abs(a.top - b.top) <= 4 && Math.abs(a.bottom - b.bottom) <= 4 && Math.abs(a.left - b.left) <= 4 && Math.abs(a.right - b.right) <= 4;
+  const containsBox = (outer, inner) => outer.top - 4 <= inner.top && outer.bottom + 4 >= inner.bottom && outer.left - 4 <= inner.left && outer.right + 4 >= inner.right;
+  const deduped = [];
+  const area = (g) => (g.right - g.left) * g.height;
+  for (const group of groups.slice().sort((a, b) => area(b) - area(a) || b.leaves.length - a.leaves.length)) {
+    const duplicate = deduped.some(
+      (kept) => kept.root === group.root || kept.root.contains(group.root) || sameBox(kept, group) || containsBox(kept, group)
+    );
+    if (!duplicate) deduped.push(group);
+  }
+  return deduped.filter((group) => group.height > 0 && group.right - group.left > 0).sort((a, b) => a.top - b.top).map((group, index) => ({
+    index,
+    selector: selectorFor(group.root),
+    rect: {
+      top: group.top,
+      left: group.left,
+      width: group.right - group.left,
+      height: group.height
+    },
+    leafCount: group.leaves.length,
+    textPreview: visibleText(group.root).slice(0, 200)
+  }));
+};
+
+// src/engine/landing-library/motionTake.ts
+var FRAME_TIMES_MS = [0, 120, 260, 450, 800, 1400];
+var FRAME_WIDTH = 460;
+var GRID_COLUMNS = 3;
+var LABEL_HEIGHT = 22;
+var FRAME_MARGIN_PX = 16;
+function clampToViewport(box, viewport) {
+  const left = Math.max(0, Math.min(box.left, viewport.width));
+  const top = Math.max(0, Math.min(box.top, viewport.height));
+  const width = Math.min(box.width - (left - box.left), viewport.width - left);
+  const height = Math.min(box.height - (top - box.top), viewport.height - top);
+  if (width < 1 || height < 1) return null;
+  return { left, top, width, height };
+}
+async function captureMotionTake(browser, url, selector, timeoutMs = 45e3) {
+  const { context, page } = await newPage(browser, DESKTOP_VIEWPORT, { motion: true });
+  try {
+    await blockConsentManagers(page);
+    await installPageRuntime(page);
+    await page.goto(url, { waitUntil: "domcontentloaded", timeout: timeoutMs });
+    await settleNavigation(page);
+    await page.waitForLoadState("networkidle", { timeout: 8e3 }).catch(() => void 0);
+    await settleConsent(page);
+    const target = page.locator(selector).first();
+    if (!await target.count().catch(() => 0)) return null;
+    await page.evaluate((sectionSelector) => {
+      const element = document.querySelector(sectionSelector);
+      if (!element) return;
+      const top = element.getBoundingClientRect().top + window.scrollY;
+      window.scrollTo({ top: Math.max(0, top - window.innerHeight - 200), behavior: "instant" });
+    }, selector);
+    await page.waitForTimeout(600);
+    const clip = await aimAtSection(page, selector);
+    if (!clip) return null;
+    await hideFloatingFurniture(page, selector);
+    const frames = [];
+    let previous = 0;
+    for (const time of FRAME_TIMES_MS) {
+      await page.waitForTimeout(Math.max(0, time - previous));
+      previous = time;
+      const shot = await page.screenshot({
+        type: "png",
+        timeout: 1e4,
+        clip: { x: clip.left, y: clip.top, width: clip.width, height: clip.height }
+      }).catch(() => null);
+      if (shot) frames.push(shot);
+    }
+    if (frames.length === 0) return null;
+    return { filmstrip: await composeFilmstrip(frames), frameCount: frames.length };
+  } catch {
+    return null;
+  } finally {
+    await context.close();
+  }
+}
+async function aimAtSection(page, selector) {
+  const box = await page.evaluate(
+    ([sectionSelector, margin]) => {
+      const element = document.querySelector(sectionSelector);
+      if (!element) return null;
+      const before = element.getBoundingClientRect();
+      window.scrollTo({ top: Math.max(0, before.top + window.scrollY - margin), behavior: "instant" });
+      const after = element.getBoundingClientRect();
+      return {
+        left: after.left,
+        top: after.top - margin,
+        width: after.width,
+        height: after.height + margin,
+        viewport: { width: window.innerWidth, height: window.innerHeight }
+      };
+    },
+    [selector, FRAME_MARGIN_PX]
+  );
+  if (!box) return null;
+  return clampToViewport(box, box.viewport);
+}
+async function hideFloatingFurniture(page, selector) {
+  await page.evaluate((sectionSelector) => {
+    const target = document.querySelector(sectionSelector);
+    if (!target) return;
+    for (const element of Array.from(document.querySelectorAll("*"))) {
+      const position = getComputedStyle(element).position;
+      if (position !== "fixed" && position !== "sticky") continue;
+      if (element.contains(target) || target.contains(element) || element === target) continue;
+      element.style.setProperty("visibility", "hidden", "important");
+    }
+  }, selector);
+}
+async function composeFilmstrip(frames) {
+  const scaled = await Promise.all(frames.map((frame) => sharp2(frame).resize({ width: FRAME_WIDTH }).png().toBuffer()));
+  const first = await sharp2(scaled[0]).metadata();
+  const frameHeight = first.height ?? 300;
+  const cellHeight = frameHeight + LABEL_HEIGHT;
+  const rows = Math.ceil(scaled.length / GRID_COLUMNS);
+  const width = FRAME_WIDTH * Math.min(GRID_COLUMNS, scaled.length);
+  const composites = scaled.flatMap((frame, index) => {
+    const column = index % GRID_COLUMNS;
+    const row = Math.floor(index / GRID_COLUMNS);
+    const label = Buffer.from(
+      `<svg width="${FRAME_WIDTH}" height="${LABEL_HEIGHT}">
+         <rect width="100%" height="100%" fill="#111827"/>
+         <text x="8" y="15" font-family="monospace" font-size="12" fill="#f9fafb">+${FRAME_TIMES_MS[index] ?? 0}ms</text>
+       </svg>`
+    );
+    return [
+      { input: label, left: column * FRAME_WIDTH, top: row * cellHeight },
+      { input: frame, left: column * FRAME_WIDTH, top: row * cellHeight + LABEL_HEIGHT }
+    ];
+  });
+  return await sharp2({
+    create: {
+      width,
+      height: cellHeight * rows,
+      channels: 3,
+      background: { r: 17, g: 24, b: 39 }
+    }
+  }).composite(composites).png().toBuffer();
+}
+
+// src/engine/landing-library/renderBundle.ts
+var SETTLE_ANIMATIONS_CSS = `*, *::before, *::after {
+  animation-play-state: running !important;
+  animation-delay: 0s !important;
+  animation-duration: 1ms !important;
+  animation-iteration-count: 1 !important;
+  animation-fill-mode: forwards !important;
+  transition: none !important;
+}`;
+async function renderBundleToPng(browser, html, viewportWidth, options = {}) {
+  const { wholePage = false, timeoutMs = 2e4 } = options;
+  const { context, page } = await newPage(browser, { width: viewportWidth, height: 900 });
+  try {
+    await page.setContent(html, { waitUntil: "load", timeout: timeoutMs });
+    await page.addStyleTag({ content: SETTLE_ANIMATIONS_CSS });
+    await page.evaluate(async () => {
+      await document.fonts.ready;
+    });
+    await page.waitForTimeout(300);
+    if (!wholePage) {
+      for (const selector of [`[${SECTION_ROOT_ATTRIBUTE}]`, "body > *"]) {
+        const target = page.locator(selector).first();
+        if (!await target.count()) continue;
+        const shot = await target.screenshot({ type: "png", timeout: timeoutMs }).catch(() => null);
+        if (shot) return shot;
+      }
+    }
+    return await page.screenshot({ type: "png", fullPage: true }).catch(() => null);
+  } catch {
+    return null;
+  } finally {
+    await context.close();
+  }
+}
+
+// src/engine/landing-library/report.ts
+import { writeFile } from "fs/promises";
+import path from "path";
+async function writeCaptureReport(manifest, outDir) {
+  const file = path.join(outDir, "report.html");
+  await writeFile(file, renderReport(manifest));
+  return file;
+}
+function escapeHtml2(value) {
+  return value.replace(
+    /[&<>"']/g,
+    (character) => ({ "&": "&amp;", "<": "&lt;", ">": "&gt;", '"': "&quot;", "'": "&#39;" })[character] ?? character
+  );
+}
+function fidelityTone(fidelity) {
+  if (fidelity === null) return "unknown";
+  if (fidelity >= 0.95) return "good";
+  if (fidelity >= 0.85) return "fair";
+  return "poor";
+}
+function medianFidelity(sections) {
+  const scored = sections.map((section) => section.fidelity).filter((value) => value !== null).sort((a, b) => a - b);
+  return scored.length === 0 ? null : scored[Math.floor(scored.length / 2)] ?? null;
+}
+function formatFidelity(fidelity) {
+  return fidelity === null ? "\u2014" : fidelity.toFixed(2);
+}
+function renderSection(section) {
+  const tone = fidelityTone(section.fidelity);
+  const rendered = section.bundle ? section.bundle.replace(/section\.html$/, "section-rendered.png") : null;
+  const shot = (label, src, note) => {
+    if (!src) return `<figure class="shot empty"><figcaption>${label} \u2014 none</figcaption></figure>`;
+    return `<figure class="shot">
+        <figcaption>${label}${note ? ` <span class="note">${escapeHtml2(note)}</span>` : ""}</figcaption>
+        <a href="${escapeHtml2(src)}" target="_blank" rel="noopener"><img src="${escapeHtml2(src)}" alt="" loading="lazy"></a>
+      </figure>`;
+  };
+  return `<section class="card">
+    <header>
+      <h2><span class="index">${String(section.index).padStart(2, "0")}</span> ${section.rect.width}\xD7${section.rect.height}</h2>
+      <span class="badge ${tone}">fidelity ${formatFidelity(section.fidelity)}</span>
+      ${section.fidelityNote ? `<span class="badge warn">${escapeHtml2(section.fidelityNote)}</span>` : ""}
+      ${section.motion.hasMotion ? `<span class="badge motion">${escapeHtml2(section.motion.summary)}</span>` : ""}
+    </header>
+    <p class="preview">${escapeHtml2(section.textPreview.slice(0, 220)) || "<em>no text</em>"}</p>
+    <div class="shots">
+      ${shot("Live", section.desktopShot)}
+      ${shot("Reproduction", rendered, "rendered from the extracted bundle")}
+      ${shot("Mobile", section.mobileShot)}
+    </div>
+    ${section.motionFilmstrip ? `<div class="filmstrip">${shot("Motion \u2014 six frames, left to right", section.motionFilmstrip)}</div>` : ""}
+    <footer>
+      <code>${escapeHtml2(section.selector)}</code>
+      ${section.bundle ? `<a href="${escapeHtml2(section.bundle)}" target="_blank" rel="noopener">open the standalone bundle \u2192</a>` : ""}
+    </footer>
+  </section>`;
+}
+function renderReport(manifest) {
+  const median = medianFidelity(manifest.sections);
+  const moving = manifest.sections.filter((section) => section.motionFilmstrip !== null).length;
+  return `<!doctype html>
+<html lang="en">
+<head>
+<meta charset="utf-8">
+<meta name="viewport" content="width=device-width, initial-scale=1">
+<title>Capture report \u2014 ${escapeHtml2(manifest.title || manifest.url)}</title>
+<style>
+  :root { color-scheme: light dark; --line: #e5e7eb; --muted: #6b7280; --bg: #fafafa; --card: #fff; }
+  @media (prefers-color-scheme: dark) {
+    :root { --line: #27272a; --muted: #a1a1aa; --bg: #09090b; --card: #131316; }
+  }
+  * { box-sizing: border-box; }
+  body { margin: 0; padding: 24px; background: var(--bg);
+         font: 14px/1.5 ui-sans-serif, system-ui, -apple-system, "Segoe UI", sans-serif; }
+  h1 { margin: 0 0 4px; font-size: 20px; }
+  a { color: inherit; }
+  .sub { color: var(--muted); margin: 0 0 20px; }
+  .stats { display: flex; flex-wrap: wrap; gap: 8px; margin-bottom: 24px; }
+  .stat { border: 1px solid var(--line); border-radius: 10px; padding: 8px 12px; background: var(--card); }
+  .stat b { display: block; font-size: 18px; }
+  .stat span { color: var(--muted); font-size: 12px; }
+  .card { border: 1px solid var(--line); border-radius: 12px; background: var(--card);
+          padding: 16px; margin-bottom: 16px; }
+  .card header { display: flex; align-items: center; flex-wrap: wrap; gap: 8px; margin-bottom: 8px; }
+  .card h2 { font-size: 15px; margin: 0; font-weight: 600; }
+  .index { display: inline-block; min-width: 26px; color: var(--muted); }
+  .badge { font-size: 12px; padding: 2px 8px; border-radius: 999px; border: 1px solid var(--line); }
+  .badge.good { background: #dcfce7; color: #166534; border-color: #bbf7d0; }
+  .badge.fair { background: #fef3c7; color: #92400e; border-color: #fde68a; }
+  .badge.poor { background: #fee2e2; color: #991b1b; border-color: #fecaca; }
+  .badge.warn { background: #fee2e2; color: #991b1b; border-color: #fecaca; }
+  .badge.motion { background: #ede9fe; color: #5b21b6; border-color: #ddd6fe; }
+  .preview { color: var(--muted); margin: 0 0 12px; font-size: 13px; }
+  .shots { display: grid; grid-template-columns: repeat(auto-fit, minmax(260px, 1fr)); gap: 12px; align-items: start; }
+  .filmstrip { margin-top: 12px; }
+  figure { margin: 0; }
+  figcaption { font-size: 12px; color: var(--muted); margin-bottom: 4px; }
+  figcaption .note { opacity: .75; }
+  .shot img { width: 100%; height: auto; border: 1px solid var(--line); border-radius: 8px;
+              background: #fff; display: block; }
+  .shot.empty { border: 1px dashed var(--line); border-radius: 8px; padding: 20px; text-align: center; }
+  .card footer { display: flex; justify-content: space-between; gap: 12px; margin-top: 12px;
+                 font-size: 12px; color: var(--muted); }
+  code { font: 12px ui-monospace, SFMono-Regular, Menlo, monospace; word-break: break-all; }
+</style>
+</head>
+<body>
+<h1>${escapeHtml2(manifest.title || "Capture report")}</h1>
+<p class="sub"><a href="${escapeHtml2(manifest.finalUrl)}" target="_blank" rel="noopener">${escapeHtml2(manifest.finalUrl)}</a> \xB7 captured ${escapeHtml2(manifest.capturedAt)}</p>
+
+<div class="stats">
+  <div class="stat"><b>${manifest.sections.length}</b><span>sections</span></div>
+  <div class="stat"><b>${formatFidelity(median)}</b><span>median fidelity</span></div>
+  <div class="stat"><b>${formatFidelity(manifest.page.fidelity)}</b><span>whole page</span></div>
+  <div class="stat"><b>${moving}</b><span>filmed moving</span></div>
+  <div class="stat"><b>${manifest.documentHeight}px</b><span>page height</span></div>
+</div>
+
+<section class="card">
+  <header>
+    <h2>Whole page</h2>
+    <span class="badge ${fidelityTone(manifest.page.fidelity)}">fidelity ${formatFidelity(manifest.page.fidelity)}</span>
+  </header>
+  <p class="preview">The same extractor rooted at &lt;body&gt; \u2014 one standalone file that should render like the original.</p>
+  <div class="shots">
+    <figure class="shot"><figcaption>Live</figcaption><a href="full-page.png" target="_blank" rel="noopener"><img src="full-page.png" alt="" loading="lazy"></a></figure>
+    ${manifest.page.bundle ? `<figure class="shot"><figcaption>Reproduction <span class="note">from page.html</span></figcaption><a href="page-rendered.png" target="_blank" rel="noopener"><img src="page-rendered.png" alt="" loading="lazy"></a></figure>` : `<figure class="shot empty"><figcaption>Reproduction \u2014 none</figcaption></figure>`}
+  </div>
+</section>
+
+${manifest.sections.map(renderSection).join("\n")}
+</body>
+</html>
+`;
+}
+
+// src/engine/landing-library/types.ts
+var DEFAULT_SEGMENT_OPTIONS = {
+  maxSectionHeight: 2160,
+  collisionMargin: 2,
+  maxElements: 15e3
+};
+
+// src/engine/landing-library/run.ts
+async function reproducePage(args) {
+  const { browser, page, outDir, pageUrl, livePageShot } = args;
+  const built = await buildSectionBundle(page, "body", pageUrl).catch(() => null);
+  if (!built) return { bundle: null, fidelity: null };
+  await writeFile2(path2.join(outDir, "page.html"), built.html);
+  const rendered = await renderBundleToPng(browser, built.html, DESKTOP_VIEWPORT.width, {
+    wholePage: true,
+    timeoutMs: 6e4
+  });
+  if (!rendered || !livePageShot) return { bundle: "page.html", fidelity: null };
+  await writeFile2(path2.join(outDir, "page-rendered.png"), rendered);
+  const { score, note } = await scoreFidelity(livePageShot, rendered);
+  return { bundle: "page.html", fidelity: score, ...note ? { fidelityNote: note } : {} };
+}
+async function captureOneSection(args) {
+  const { browser, page, candidate, sectionsDir, outDir, pageUrl, withCode } = args;
+  const dir = path2.join(sectionsDir, String(candidate.index).padStart(2, "0"));
+  await mkdir(dir, { recursive: true });
+  const desktop = await captureSection(page, candidate);
+  if (desktop) await writeFile2(path2.join(dir, "desktop.png"), desktop);
+  const visualHash = desktop ? await perceptualHash(desktop) : null;
+  const motion = await collectMotion(page, candidate.selector);
+  const built = withCode ? await buildSectionBundle(page, candidate.selector, pageUrl) : null;
+  let fidelity = null;
+  let fidelityNote;
+  if (built) {
+    await writeFile2(path2.join(dir, "section.html"), built.html);
+    const rendered = await renderBundleToPng(browser, built.html, DESKTOP_VIEWPORT.width);
+    if (rendered && desktop) {
+      await writeFile2(path2.join(dir, "section-rendered.png"), rendered);
+      const result = await scoreFidelity(desktop, rendered);
+      fidelity = result.score;
+      fidelityNote = result.note;
+    }
+  }
+  return {
+    ...candidate,
+    desktopShot: desktop ? path2.relative(outDir, path2.join(dir, "desktop.png")) : null,
+    mobileShot: null,
+    bundle: built ? path2.relative(outDir, path2.join(dir, "section.html")) : null,
+    fidelity,
+    ...fidelityNote ? { fidelityNote } : {},
+    ...built ? { cssStats: built.stats } : {},
+    motion,
+    motionFilmstrip: null,
+    visualHash
+  };
+}
+async function captureMobileShots(args) {
+  const { browser, sections, sectionsDir, outDir, pageUrl, timeoutMs } = args;
+  const mobile = await newPage(browser, MOBILE_VIEWPORT);
+  try {
+    await blockConsentManagers(mobile.page);
+    await installPageRuntime(mobile.page);
+    await preparePage(mobile.page, pageUrl, timeoutMs);
+    for (const section of sections) {
+      const shot = await captureSectionOnMobile(mobile.page, section);
+      if (!shot) continue;
+      const file = path2.join(sectionsDir, String(section.index).padStart(2, "0"), "mobile.png");
+      await writeFile2(file, shot);
+      section.mobileShot = path2.relative(outDir, file);
+    }
+  } finally {
+    await mobile.context.close();
+  }
+}
+var MOTION_CONCURRENCY = 3;
+async function captureMotionTakes(args) {
+  const { browser, sections, sectionsDir, outDir, pageUrl, log } = args;
+  const moving = sections.filter((section) => isWorthFilming(section.motion));
+  if (moving.length === 0) return;
+  log(`filming ${moving.length} moving sections`);
+  const filmOne = async (section) => {
+    const take = await captureMotionTake(browser, pageUrl, section.selector).catch(() => null);
+    if (!take) return;
+    const dir = path2.join(sectionsDir, String(section.index).padStart(2, "0"));
+    const file = path2.join(dir, "motion-filmstrip.png");
+    await writeFile2(file, take.filmstrip);
+    section.motionFilmstrip = path2.relative(outDir, file);
+    log(`  [${section.index}] ${section.motion.summary}`);
+  };
+  const queue = [...moving];
+  await Promise.all(
+    Array.from({ length: Math.min(MOTION_CONCURRENCY, queue.length) }, async () => {
+      for (let next = queue.shift(); next; next = queue.shift()) {
+        await filmOne(next);
+      }
+    })
+  );
+}
+async function openPageVia(route, url, timeoutMs) {
+  const startedAt = Date.now();
+  const browser = await launchBrowser(route);
+  let status = null;
+  try {
+    const { context, page } = await newPage(browser, DESKTOP_VIEWPORT);
+    await blockConsentManagers(page);
+    await installPageRuntime(page);
+    const prepared = await preparePage(page, url, timeoutMs);
+    status = prepared.status;
+    const blocked = detectBlockedPage({
+      status: prepared.status,
+      title: prepared.title,
+      bodyText: prepared.bodyText,
+      html: await page.content().catch(() => "")
+    });
+    if (blocked) throw new BlockedPageError(blocked);
+    return { ok: true, browser, context, page, prepared };
+  } catch (error) {
+    await browser.close().catch(() => void 0);
+    return {
+      ok: false,
+      outcome: {
+        route,
+        failure: classifyCaptureFailure(error),
+        status,
+        netError: netErrorName(error),
+        elapsedMs: Date.now() - startedAt
+      }
+    };
+  }
+}
+async function captureAlternateViews(args) {
+  const { browser, sections, sectionsDir, outDir, pageUrl, timeoutMs, withMobile, withMotion, log } = args;
+  if (withMobile) {
+    log("capturing mobile");
+    await captureMobileShots({ browser, sections, sectionsDir, outDir, pageUrl, timeoutMs });
+  }
+  if (withMotion) {
+    await captureMotionTakes({ browser, sections, sectionsDir, outDir, pageUrl, log });
+  }
+}
+async function reproduceWholePage(args) {
+  const { browser, page, outDir, pageUrl, withCode, log } = args;
+  const fullPage = await page.screenshot({ type: "png", fullPage: true }).catch(() => null);
+  if (fullPage) await writeFile2(path2.join(outDir, "full-page.png"), fullPage);
+  if (!withCode) return { bundle: null, fidelity: null };
+  const reproduction = await reproducePage({ browser, page, outDir, pageUrl, livePageShot: fullPage });
+  log(`page reproduction: ${reproduction.fidelity === null ? "unavailable" : reproduction.fidelity.toFixed(2)}`);
+  return reproduction;
+}
+async function captureSections(args) {
+  const { browser, page, sectionsDir, outDir, pageUrl, withCode, log } = args;
+  log("segmenting");
+  const candidates = await segmentPage(page, DEFAULT_SEGMENT_OPTIONS);
+  log(`found ${candidates.length} sections`);
+  const sections = [];
+  for (const candidate of candidates) {
+    const section = await captureOneSection({
+      browser,
+      page,
+      candidate,
+      sectionsDir,
+      outDir,
+      pageUrl,
+      withCode
+    });
+    sections.push(section);
+    log(
+      `  [${candidate.index}] ${candidate.rect.width}x${candidate.rect.height}${section.fidelity === null ? "" : ` fidelity=${section.fidelity.toFixed(2)}`} \u2014 ${candidate.textPreview.slice(0, 50)}`
+    );
+  }
+  return sections;
+}
+function rungReport(outcome) {
+  return {
+    tier: outcome.route.kind === "proxy" ? outcome.route.tier : "direct",
+    code: outcome.failure.code,
+    status: outcome.status
+  };
+}
+async function resolveAmbiguousTimeout(outcome, log) {
+  if (!ambiguousProxyTimeout(outcome)) return outcome;
+  const verdict = await preflightProxyRoute(outcome.route).catch(() => null);
+  if (!verdict || verdict.usable) return outcome;
+  log(`that timeout was our own route, not the site (${verdict.problem}) \u2014 carrying on up the ladder`);
+  return asProxyFailure(outcome, verdict.problem);
+}
+async function openViaLadder(args) {
+  const { url, routes, timeoutMs, deadline, log } = args;
+  const attempts = [];
+  for (let route = routes[0] ?? { kind: "direct" }; route; ) {
+    log(`loading ${url}${route.kind === "proxy" ? ` (retrying via ${route.tier})` : ""}`);
+    const attempt = await openPageVia(route, url, timeoutMs);
+    if (attempt.ok) {
+      return { opened: attempt, attempts, tier: route.kind === "proxy" ? route.tier : "direct" };
+    }
+    attempts.push(await resolveAmbiguousTimeout(attempt.outcome, log));
+    const decision = nextRoute({
+      routes,
+      attempts,
+      remainingMs: deadline ? deadline - Date.now() : Number.POSITIVE_INFINITY,
+      reserveMs: CAPTURE_RESERVE_MS,
+      navTimeoutMs: timeoutMs
+    });
+    if (!decision.next) {
+      log(`giving up after ${attempts.length} attempt(s) \u2014 ${decision.reason}`);
+      break;
+    }
+    route = decision.next;
+  }
+  throw new CaptureFailureError(reportableFailure(attempts), attempts.map(rungReport));
+}
+async function scrapeLanding(options) {
+  const timeoutMs = options.timeoutMs ?? 45e3;
+  const log = options.onProgress ?? (() => void 0);
+  const sectionsDir = path2.join(options.outDir, "sections");
+  const nonPublic = refuseNonPublicUrl(options.url);
+  if (nonPublic) {
+    throw new BlockedPageError({
+      code: "HTTP_ERROR",
+      message: nonPublic === "unparseable" ? "That doesn't look like a web address we can open." : LOCAL_ADDRESS_REFUSAL
+    });
+  }
+  const { opened, attempts, tier } = await openViaLadder({
+    url: options.url,
+    routes: plannedRoutes(options.url, options.proxyCredentials ?? {}),
+    timeoutMs,
+    deadline: options.budgetMs ? Date.now() + options.budgetMs : null,
+    log
+  });
+  const { browser, context, page, prepared } = opened;
+  const escalated = attempts.length > 0;
+  const withMotion = options.motion !== false && !escalated;
+  const renderBrowser = options.code === false ? null : await launchBrowser();
+  try {
+    await mkdir(sectionsDir, { recursive: true });
+    const sections = await captureSections({
+      browser: renderBrowser ?? browser,
+      page,
+      sectionsDir,
+      outDir: options.outDir,
+      pageUrl: prepared.finalUrl,
+      withCode: options.code !== false,
+      log
+    });
+    const reproduction = await reproduceWholePage({
+      browser: renderBrowser ?? browser,
+      page,
+      outDir: options.outDir,
+      pageUrl: prepared.finalUrl,
+      withCode: options.code !== false,
+      log
+    });
+    await context.close();
+    await captureAlternateViews({
+      browser,
+      sections,
+      sectionsDir,
+      outDir: options.outDir,
+      pageUrl: prepared.finalUrl,
+      timeoutMs,
+      withMobile: options.mobile !== false,
+      withMotion,
+      log
+    });
+    const manifest = {
+      url: options.url,
+      finalUrl: prepared.finalUrl,
+      title: prepared.title,
+      documentHeight: prepared.documentHeight,
+      viewport: DESKTOP_VIEWPORT,
+      capturedAt: (/* @__PURE__ */ new Date()).toISOString(),
+      sections,
+      page: reproduction,
+      security: prepared.security,
+      captureTier: tier
+    };
+    await writeFile2(path2.join(options.outDir, "manifest.json"), `${JSON.stringify(manifest, null, 2)}
+`);
+    if (options.report !== false) {
+      const reportPath = await writeCaptureReport(manifest, options.outDir);
+      log(`report: ${reportPath}`);
+    }
+    return manifest;
+  } finally {
+    await browser.close();
+    if (renderBrowser) await renderBrowser.close();
+  }
+}
+
+// src/commands/landing/inspiration/captureOut.ts
+import { existsSync } from "fs";
+import path3 from "path";
+var SCRATCH_DIR = ".baker";
+function isWithin(parent, target) {
+  const relative = path3.relative(parent, target);
+  return relative === "" || !relative.startsWith("..") && !path3.isAbsolute(relative);
+}
+function findRepoRoot(from) {
+  let dir = path3.resolve(from);
+  for (; ; ) {
+    if (existsSync(path3.join(dir, ".git"))) return dir;
+    const parent = path3.dirname(dir);
+    if (parent === dir) return null;
+    dir = parent;
+  }
+}
+function checkCaptureOut(out, options) {
+  const { cwd, repoRoot } = options;
+  const resolved = path3.resolve(cwd, out);
+  if (repoRoot === null || !isWithin(repoRoot, resolved)) return { ok: true };
+  const scratch = path3.join(repoRoot, SCRATCH_DIR);
+  if (isWithin(scratch, resolved)) return { ok: true };
+  const suggestion = path3.posix.join(SCRATCH_DIR, "teardowns", path3.basename(resolved) || "capture");
+  return {
+    ok: false,
+    error: {
+      code: "CAPTURE_OUT_NOT_SCRATCH",
+      message: `A capture has to be written to ${SCRATCH_DIR}/ inside this workspace. It is reference material for this turn, and anywhere else it becomes a permanent part of the client's files.`,
+      fix: {
+        action: "retry_with_changes",
+        explanation: `Re-run with --out ${suggestion}.`
+      },
+      retryable: false
+    }
+  };
+}
+
+// src/commands/landing/inspiration/scrape.ts
+var RETRYABLE_FAILURES = /* @__PURE__ */ new Set([
+  "SITE_TOO_SLOW",
+  "CAPTURE_FAILED",
+  // Ours, not the site's. Filing it as final is exactly how a mistyped password
+  // would blacklist a page that was never actually judged.
+  "PROXY_UNAVAILABLE"
+]);
+function captureHints(args) {
+  const { manifest, outDir, report } = args;
+  const shots = manifest.sections.filter((section) => section.desktopShot !== null).length;
+  const anyScored = manifest.sections.some((section) => section.fidelity !== null);
+  const hints = [];
+  if (manifest.security.certificateNotes.length > 0) {
+    hints.push(
+      `Captured anyway, but this site's certificate did not check out: ${manifest.security.certificateNotes.join(" ")} Treat the page as a design reference only \u2014 do not repeat its claims, prices or customer names.`
+    );
+  }
+  if (shots === 0) {
+    hints.push(
+      `No section screenshots were produced, so there is nothing to look at in ${outDir}/sections/. Treat this capture as unusable rather than designing from the counts.`
+    );
+  } else {
+    hints.push(
+      report ? `Read ${outDir}/report.html \u2014 every section side by side${anyScored ? " with its fidelity score" : ""}.` : `Read the section screenshots in ${outDir}/sections/*/desktop.png before you design.`,
+      `${shots} of ${manifest.sections.length} sections captured to ${outDir}/sections/ \u2014 look at them, then decide which the client's page actually needs.`
+    );
+  }
+  hints.push(INSPIRATION_HINTS.structureNotCopy, INSPIRATION_HINTS.adapt);
+  return hints;
+}
+registerSchema({
+  command: "landing.inspiration.scrape",
+  description: "Start here when the user points at a specific page and wants it now: capture one landing page into a directory of section screenshots, standalone HTML bundles, a whole-page reproduction and motion filmstrips. Returns when the capture is done, unlike `add`. Read the screenshots.",
+  args: {
+    url: { type: "string", description: "Page to capture", required: true },
+    out: { type: "string", description: "Output directory under .baker/", required: true },
+    mobile: { type: "boolean", description: "Phone-viewport pass. `--no-mobile` to skip", required: false },
+    code: {
+      type: "boolean",
+      description: "Standalone HTML+CSS bundles and fidelity scores. `--no-code` to segment and screenshot only",
+      required: false
+    },
+    motion: {
+      type: "boolean",
+      description: "Film sections that move. `--no-motion` to skip \u2014 the single biggest lever on runtime",
+      required: false
+    },
+    report: { type: "boolean", description: "Write report.html. `--no-report` to skip", required: false }
+  }
+});
+var scrapeCommand = defineCommand({
+  meta: {
+    name: "scrape",
+    description: "Capture a landing page to a directory, now. Example: baker landing inspiration scrape https://linear.app --out .baker/inspiration/linear.app"
+  },
+  args: {
+    url: { type: "positional", description: "Page to capture", required: true },
+    out: { type: "string", description: "Output directory, under .baker/", required: true },
+    mobile: {
+      type: "boolean",
+      description: "Phone-viewport pass (--no-mobile to skip)",
+      required: false,
+      default: true
+    },
+    code: { type: "boolean", description: "Bundles + fidelity (--no-code to skip)", required: false, default: true },
+    motion: {
+      type: "boolean",
+      description: "Film moving sections (--no-motion to skip)",
+      required: false,
+      default: true
+    },
+    report: { type: "boolean", description: "Write report.html (--no-report to skip)", required: false, default: true }
+  },
+  run: async ({ args }) => {
+    const location2 = checkCaptureOut(args.out, {
+      cwd: process.cwd(),
+      repoRoot: findRepoRoot(process.cwd())
+    });
+    if (!location2.ok) {
+      writeJson({ ok: false, error: location2.error });
+      process.exit(1);
+    }
+    try {
+      const manifest = await scrapeLanding({
+        url: args.url,
+        outDir: args.out,
+        mobile: args.mobile,
+        code: args.code,
+        motion: args.motion,
+        report: args.report,
+        // Both come from the environment, never from a flag — see their docs in
+        // `src/env.ts`. Absent credentials this is the direct route only, which
+        // is exactly the behaviour that shipped before the ladder existed.
+        proxyCredentials: captureProxyCredentials(),
+        budgetMs: captureBudgetMs() ?? void 0,
+        // Progress goes to stderr so stdout stays a clean JSON envelope.
+        onProgress: (message) => process.stderr.write(`${message}
+`)
+      });
+      const scored = manifest.sections.map((section) => section.fidelity).filter((value) => value !== null).sort((a, b) => a - b);
+      writeJson({
+        ok: true,
+        data: {
+          title: manifest.title,
+          sections: manifest.sections.length,
+          medianFidelity: scored.length > 0 ? scored[Math.floor(scored.length / 2)] : null,
+          pageFidelity: manifest.page.fidelity,
+          out: args.out,
+          report: args.report ? `${args.out}/report.html` : null,
+          // Never omitted, and that is the point: an envelope without it is a
+          // capture that ran a build predating the ladder, which is otherwise
+          // indistinguishable from one that took the direct route and is the
+          // exact silence the E2B template rebuild is easy to forget about.
+          capture_tier: manifest.captureTier,
+          // Compact by default, but never omitted: a capture that could not
+          // verify who served the page is worth less as evidence, and the
+          // reader has to be told without going looking for it.
+          certificate_verified: false,
+          ...manifest.security.certificateNotes.length > 0 ? { certificate_notes: manifest.security.certificateNotes } : {}
+        },
+        hints: captureHints({ manifest, outDir: args.out, report: args.report })
+      });
+    } catch (error) {
+      const failure = classifyCaptureFailure(error);
+      process.stderr.write(`[landing.inspiration.scrape] ${failure.code}: ${String(error)}
+`);
+      writeJson({
+        ok: false,
+        error: {
+          code: failure.code,
+          message: failure.message,
+          // Which addresses were tried and what each was told. One rung means
+          // the failure was final wherever we stood; three mean the page turned
+          // us away from three different places, which is a fact about the page.
+          // **Absent** means this Runtime is running a CLI that predates the
+          // ladder — the one way the rollout fails without anything looking
+          // wrong.
+          ...error instanceof CaptureFailureError && error.rungs.length > 0 ? { rungs: error.rungs } : {},
+          // Degrade, don't abort: one unreadable reference is never a reason to
+          // abandon the job it was research for. `retryable` is the decision
+          // the agent would otherwise have to guess at.
+          fix: RETRYABLE_FAILURES.has(failure.code) ? {
+            action: "Retry once with --no-motion, which is roughly half the work.",
+            explanation: "This looks temporary. If the second attempt fails too, carry on with the references you can reach and tell the user this one page was unavailable.",
+            retryable: true
+          } : {
+            action: "Do not retry this page \u2014 work from the references you can reach.",
+            explanation: "This page cannot be read by an automated reader, and running it again will fail the same way. Tell the user this one page was unavailable and continue with the rest.",
+            retryable: false
+          }
+        }
+      });
+      process.exit(1);
+    }
+  }
+});
+export {
+  scrapeCommand
+};
+//# sourceMappingURL=scrape-FDBYU3TU.js.map