mcp-scraper 0.51.2 → 0.52.0

package/dist/{server-KAEHVDY7.js → server-7EXEDKAU.js}

@@ -1,10 +1,12 @@
 import {
   SITE_EXTRACT_ARTIFACT_PREFIX,
   cleanupExpiredSiteExtractArtifacts,
+  discoverStaticMedia,
   harvestPageMedia,
   readOwnedSiteExtractArtifactBuffer,
-  renewSiteExtractArtifactDownload
-} from "./chunk-27FMOD6S.js";
+  renewSiteExtractArtifactDownload,
+  typeFromMime
+} from "./chunk-SG2PEHR3.js";
 import {
   REQUIRED_LOCATION_STATE_CODES,
   importHostedCensusPlacesCsv,
@@ -100,7 +102,7 @@ import {
   resolveKernelProxyId,
   serpArrivalUrl,
   withRuntimeUserAgent
-} from "./chunk-GOZIG6HD.js";
+} from "./chunk-TVZD37SE.js";
 import {
   ApiErrorResponseSchema,
   ArtifactTemplatePresetKeySchema,
@@ -158,7 +160,7 @@ import {
   resolveDeploymentProfile,
   resolveLocalSourcebookSchemaType,
   transcribeMediaUrl
-} from "./chunk-FCZ3QCZP.js";
+} from "./chunk-OT2AF7SH.js";
 import {
   auditImageUrls,
   auditImages,
@@ -196,7 +198,7 @@ import {
   workflowOutputBaseDir,
   workflowStepCount,
   workflowSupportsSteps
-} from "./chunk-ZSJHRZY5.js";
+} from "./chunk-J7TH5KU7.js";
 import {
   csvRecords,
   parseCsv,
@@ -211,10 +213,10 @@ import {
   RawMapsHoursRowSchema,
   RawMapsOverviewSchema,
   RawMapsReviewStatsSchema
-} from "./chunk-3ZUBQQPQ.js";
+} from "./chunk-V7CEOUBF.js";
 import {
   PACKAGE_VERSION
-} from "./chunk-JNRSR5ZJ.js";
+} from "./chunk-VIAXQTZK.js";
 import {
   abandonExtractSettlement,
   countSuccessfulPages,
@@ -3813,39 +3815,135 @@ async function readResponseTextWithLimit(response, maxBytes, label) {
 }
 
 // src/api/kernel-fetch.ts
-async function fetchWithKernel(url) {
-  const checked = await validatePublicHttpUrl(url, { field: "browser URL" });
-  if (checked.error || !checked.parsed) throw new Error(checked.error ?? "Browser URL was rejected");
-  const auditedUrl = checked.parsed.href;
-  const apiKey = browserServiceApiKey();
-  if (!apiKey) throw new Error("Browser backend API key not set");
-  const client2 = new Kernel({ apiKey });
+var CHALLENGE_PATTERNS = [
+  { reason: "cloudflare_title", pattern: /<title[^>]*>\s*just a moment(?:\.\.\.)?\s*<\/title>/i },
+  { reason: "cloudflare_challenge_platform", pattern: /(?:cdn-cgi\/challenge-platform|challenge-platform\/h\/|cf-chl-|cf_chl_)/i },
+  { reason: "cloudflare_browser_verification", pattern: /(?:cf-browser-verification|checking your browser before accessing)/i },
+  { reason: "cloudflare_cookie_message", pattern: /enable javascript and cookies to continue/i },
+  { reason: "generic_security_check", pattern: /performing security verification|verify you are human/i }
+];
+function detectBrowserChallenge(input) {
+  if (input.status === 403 || input.status === 429) {
+    return { detected: true, reason: `http_${input.status}` };
+  }
+  const sample = `${input.title ?? ""}
+${input.html ?? ""}`.slice(0, 25e4);
+  for (const candidate of CHALLENGE_PATTERNS) {
+    if (candidate.pattern.test(sample)) return { detected: true, reason: candidate.reason };
+  }
+  return { detected: false, reason: null };
+}
+async function runKernelAttempt(client2, auditedUrl, mode) {
   const openedAtMs = Date.now();
-  const useHeadless = currentCostContext()?.forceHeadful !== true;
-  const kb = await client2.browsers.create({ stealth: true, ...useHeadless ? { headless: true } : {}, timeout_seconds: 60 });
+  const headlessSent = mode === "stealth_headless" ? true : null;
+  const kb = await client2.browsers.create({
+    stealth: true,
+    ...headlessSent ? { headless: true } : {},
+    timeout_seconds: 60
+  });
   const browser = await chromium.connectOverCDP(kb.cdp_ws_url);
+  let attemptError = null;
   try {
     const runtimeUserAgent = await detectRuntimeUserAgent(browser);
-    const context = await browser.newContext(withRuntimeUserAgent({
-      serviceWorkers: "block"
-    }, runtimeUserAgent));
+    const context = await browser.newContext(withRuntimeUserAgent({ serviceWorkers: "block" }, runtimeUserAgent));
     const page = context.pages()[0] ?? await context.newPage();
     const guard = await installBrowserRequestGuard(page, auditedUrl);
-    await page.goto(auditedUrl, { waitUntil: "domcontentloaded", timeout: 3e4 });
+    const response = await page.goto(auditedUrl, { waitUntil: "domcontentloaded", timeout: 3e4 });
     if (guard.blockedReason && page.url() === "about:blank") throw new Error(guard.blockedReason);
     await page.waitForTimeout(2500);
-    return await page.evaluate((maxBytes) => {
-      const value = document.documentElement?.outerHTML ?? "";
-      if (new TextEncoder().encode(value).byteLength > maxBytes) throw new Error(`Browser HTML exceeds ${maxBytes} byte limit`);
-      return value;
-    }, MAX_PAGE_HTML_BYTES);
+    let status = response?.status() ?? null;
+    let title = await page.title().catch(() => "");
+    let html = await page.content();
+    let challenge = detectBrowserChallenge({ status, title, html });
+    if (challenge.detected && mode === "stealth_headful") {
+      const deadline = Date.now() + 2e4;
+      while (challenge.detected && Date.now() < deadline) {
+        await page.waitForTimeout(1e3);
+        title = await page.title().catch(() => "");
+        html = await page.content();
+        challenge = detectBrowserChallenge({ status, title, html });
+      }
+      status = response?.status() ?? status;
+    }
+    const byteLength2 = new TextEncoder().encode(html).byteLength;
+    if (byteLength2 > MAX_PAGE_HTML_BYTES) throw new Error(`Browser HTML exceeds ${MAX_PAGE_HTML_BYTES} byte limit`);
+    return { html, status, challenge, durationMs: Date.now() - openedAtMs };
+  } catch (error) {
+    attemptError = error instanceof Error ? error.message : String(error);
+    throw error;
   } finally {
     await browser.close().catch(() => {
     });
     await client2.browsers.deleteByID(kb.session_id).catch(() => {
     });
-    void recordKernelSession({ kernelSessionId: kb.session_id, source: "kernel_fetch", stealth: typeof kb.stealth === "boolean" ? kb.stealth : null, headlessSent: useHeadless, proxyUsed: typeof kb.proxy_id === "string" ? Boolean(kb.proxy_id) : null, fallback: true, openedAtMs, closedAtMs: Date.now() });
+    void recordKernelSession({
+      kernelSessionId: kb.session_id,
+      source: "kernel_fetch",
+      stealth: typeof kb.stealth === "boolean" ? kb.stealth : null,
+      headlessSent,
+      proxyUsed: typeof kb.proxy_id === "string" ? Boolean(kb.proxy_id) : null,
+      fallback: true,
+      openedAtMs,
+      closedAtMs: Date.now(),
+      error: attemptError
+    });
+  }
+}
+async function fetchWithKernelDetailed(url) {
+  const checked = await validatePublicHttpUrl(url, { field: "browser URL" });
+  if (checked.error || !checked.parsed) throw new Error(checked.error ?? "Browser URL was rejected");
+  const auditedUrl = checked.parsed.href;
+  const apiKey = browserServiceApiKey();
+  if (!apiKey) throw new Error("Browser backend API key not set");
+  const client2 = new Kernel({ apiKey });
+  const startsHeadful = currentCostContext()?.forceHeadful === true;
+  const modes = startsHeadful ? ["stealth_headful"] : ["stealth_headless", "stealth_headful"];
+  const attempts = [];
+  for (const mode of modes) {
+    const result = await runKernelAttempt(client2, auditedUrl, mode);
+    if (result.challenge.detected) {
+      const completion = mode === "stealth_headful" ? "challenge_unresolved" : "challenge_detected";
+      attempts.push({
+        mode,
+        status: result.status,
+        challengeDetected: true,
+        challengeReason: result.challenge.reason,
+        completion,
+        durationMs: result.durationMs
+      });
+      if (mode === "stealth_headful") {
+        const error = new Error(`browser_challenge_unresolved: ${result.challenge.reason ?? "challenge page remained after bounded wait"}`);
+        error.code = "browser_challenge_unresolved";
+        error.attempts = attempts;
+        throw error;
+      }
+      continue;
+    }
+    if (result.status != null && (result.status < 200 || result.status >= 400)) {
+      attempts.push({
+        mode,
+        status: result.status,
+        challengeDetected: false,
+        challengeReason: null,
+        completion: "http_error",
+        durationMs: result.durationMs
+      });
+      throw new Error(`browser_http_${result.status}: Browser fetch returned HTTP ${result.status}`);
+    }
+    attempts.push({
+      mode,
+      status: result.status,
+      challengeDetected: false,
+      challengeReason: null,
+      completion: "usable_page",
+      durationMs: result.durationMs
+    });
+    return { html: result.html, mode, attempts };
   }
+  throw new Error("browser_challenge_unresolved: no usable browser response");
+}
+async function fetchWithKernel(url) {
+  return (await fetchWithKernelDetailed(url)).html;
 }
 
 // src/lib/http-user-agent.ts
@@ -3875,6 +3973,8 @@ async function extractKpo(opts) {
         }
         if (!res.ok) return null;
         const text2 = await res.text();
+        const title2 = text2.match(/<title[^>]*>([\s\S]*?)<\/title>/i)?.[1] ?? null;
+        if (detectBrowserChallenge({ status: res.status, title: title2, html: text2 }).detected) return null;
         if (text2.length < 2e3) return null;
         const stripped = text2.replace(/<(script|style|noscript|svg|iframe|canvas)[^>]*>[\s\S]*?<\/\1>/gi, "").replace(/<(nav|header|footer|aside)[^>]*>[\s\S]*?<\/\1>/gi, "");
         const contentBlock = stripped.match(/<main[^>]*>([\s\S]*?)<\/main>/i)?.[1] ?? stripped.match(/<article[^>]*>([\s\S]*?)<\/article>/i)?.[1] ?? stripped.match(/<body[^>]*>([\s\S]*?)<\/body>/i)?.[1] ?? "";
@@ -3889,13 +3989,16 @@ async function extractKpo(opts) {
   };
   let html;
   let fetchedVia = "fetch";
+  let browserFetch;
   const plainFetchStart = Date.now();
   const plainHtml = await tryPlainFetch();
   const plainFetchMs = Date.now() - plainFetchStart;
   if (plainHtml) {
     html = plainHtml;
   } else if (opts.kernelApiKey) {
-    html = await fetchWithKernel(parsed.href);
+    const browserResult = await fetchWithKernelDetailed(parsed.href);
+    html = browserResult.html;
+    browserFetch = { mode: browserResult.mode, attempts: browserResult.attempts };
     fetchedVia = "headless";
   } else {
     throw new Error("Fetch failed: site blocked plain HTTP and no headless browser backend is configured");
@@ -4195,6 +4298,7 @@ async function extractKpo(opts) {
   return {
     url: parsed.href,
     fetchedVia,
+    browserFetch,
     durationMs,
     plainFetchMs,
     title,
@@ -4212,13 +4316,47 @@ import { chromium as chromium2 } from "playwright";
 import Kernel2 from "@onkernel/sdk";
 
 // src/lib/branding-extractor.ts
-function rgbToHex(rgb) {
-  const m = rgb.match(/rgba?\((\d+),\s*(\d+),\s*(\d+)/);
-  if (!m) return null;
-  const r = parseInt(m[1], 10);
-  const g = parseInt(m[2], 10);
-  const b = parseInt(m[3], 10);
-  return "#" + [r, g, b].map((v) => v.toString(16).padStart(2, "0")).join("");
+function selectRankedLogoCandidates(candidates) {
+  const ranked = candidates.filter((candidate) => {
+    if (!/^https?:\/\//i.test(candidate.url) || !Number.isFinite(candidate.score) || candidate.region === "body") return false;
+    if (candidate.region === "json_ld" || candidate.region === "favicon") return true;
+    return candidate.evidence.includes("links_to_homepage") || candidate.evidence.includes("site_identity_marker");
+  }).map((candidate) => ({
+    ...candidate,
+    confidence: candidate.score >= 85 ? "high" : candidate.score >= 60 ? "medium" : "low",
+    evidence: [...new Set(candidate.evidence)]
+  })).sort((a, b) => b.score - a.score || a.url.localeCompare(b.url)).slice(0, 20);
+  const primary = ranked.find((candidate) => candidate.score >= 55 && candidate.region !== "favicon") ?? null;
+  return {
+    primary,
+    variants: primary ? ranked.filter((candidate) => candidate.url !== primary.url && candidate.score >= 55 && candidate.region !== "favicon" && logoFamilyKey(candidate.url) === logoFamilyKey(primary.url)).slice(0, 5).map((candidate) => candidate.url) : [],
+    candidates: ranked,
+    selectionReason: primary?.evidence.join(", ") ?? null
+  };
+}
+function logoFamilyKey(value) {
+  try {
+    const url = new URL(value);
+    const host2 = url.hostname.replace(/^www\./, "").toLowerCase();
+    const path5 = decodeURIComponent(url.pathname).toLowerCase().replace(/-\d+x\d+(?=\.[a-z0-9]+$)/, "");
+    return `${host2}${path5}`;
+  } catch {
+    return value.toLowerCase();
+  }
+}
+function selectProofImages(candidates) {
+  const byUrl = /* @__PURE__ */ new Map();
+  for (const candidate of candidates) {
+    if (!/^https?:\/\//i.test(candidate.url) || !Number.isFinite(candidate.score) || candidate.score < 45) continue;
+    const normalized = {
+      ...candidate,
+      confidence: candidate.score >= 85 ? "high" : candidate.score >= 60 ? "medium" : "low",
+      evidence: [...new Set(candidate.evidence)]
+    };
+    const existing = byUrl.get(normalized.url);
+    if (!existing || normalized.score > existing.score) byUrl.set(normalized.url, normalized);
+  }
+  return [...byUrl.values()].sort((a, b) => b.score - a.score || a.url.localeCompare(b.url)).slice(0, 20);
 }
 function luminance(hex) {
   const m = hex.match(/^#([0-9a-f]{2})([0-9a-f]{2})([0-9a-f]{2})$/i);
@@ -4232,6 +4370,12 @@ function isTransparentOrWhite(hex) {
   const lum = luminance(hex);
   return lum > 240;
 }
+function isChromatic(hex) {
+  const match = hex?.match(/^#([0-9a-f]{2})([0-9a-f]{2})([0-9a-f]{2})$/i);
+  if (!match) return false;
+  const channels = [parseInt(match[1], 16), parseInt(match[2], 16), parseInt(match[3], 16)];
+  return Math.max(...channels) - Math.min(...channels) >= 24 && luminance(hex) > 18;
+}
 function firstFont(fontFamily) {
   if (!fontFamily) return null;
   const first = fontFamily.split(",")[0].trim().replace(/['"]/g, "");
@@ -4240,14 +4384,34 @@ function firstFont(fontFamily) {
 function dominantColor(freq) {
   return Object.entries(freq).filter(([hex]) => !isTransparentOrWhite(hex) && hex !== "#000000" && hex !== "#020101").sort((a, b) => b[1] - a[1])[0]?.[0] ?? null;
 }
+function dominantChromaticColor(freq) {
+  return Object.entries(freq).filter(([hex]) => isChromatic(hex)).sort((a, b) => b[1] - a[1])[0]?.[0] ?? null;
+}
 async function extractBrandingFromPage(page) {
+  const challenge = detectBrowserChallenge({
+    title: await page.title().catch(() => ""),
+    html: await page.content().catch(() => "")
+  });
+  if (challenge.detected) {
+    const error = new Error(`browser_challenge_unresolved: ${challenge.reason ?? "challenge page is not branding evidence"}`);
+    error.code = "browser_challenge_unresolved";
+    throw error;
+  }
   const evalScript = `
     (function() {
       function cs(el) { return el ? window.getComputedStyle(el) : null; }
-      function toHex(rgb) {
-        var m = rgb && rgb.match(/rgba?\\((\\d+),\\s*(\\d+),\\s*(\\d+)/);
-        if (!m) return null;
-        return '#' + [m[1],m[2],m[3]].map(function(v){ return ('0'+parseInt(v).toString(16)).slice(-2); }).join('');
+      var colorCanvas = document.createElement('canvas');
+      colorCanvas.width = 1; colorCanvas.height = 1;
+      var colorContext = colorCanvas.getContext('2d', { willReadFrequently: true });
+      function toHex(value) {
+        if (!value || !colorContext) return null;
+        colorContext.clearRect(0, 0, 1, 1);
+        colorContext.fillStyle = 'rgba(1, 2, 3, 0.001)';
+        colorContext.fillStyle = value;
+        colorContext.fillRect(0, 0, 1, 1);
+        var data = colorContext.getImageData(0, 0, 1, 1).data;
+        if (data[3] < 64) return null;
+        return '#' + [data[0], data[1], data[2]].map(function(v){ return ('0'+v.toString(16)).slice(-2); }).join('');
       }
       function isUsable(hex) {
         if (!hex) return false;
@@ -4256,30 +4420,63 @@ async function extractBrandingFromPage(page) {
         return (0.2126*r + 0.7152*g + 0.0722*b) <= 230;
       }
 
+      function isChromatic(hex) {
+        if (!hex) return false;
+        var r=parseInt(hex.slice(1,3),16), g=parseInt(hex.slice(3,5),16), b=parseInt(hex.slice(5,7),16);
+        return Math.max(r,g,b) - Math.min(r,g,b) >= 24 && (0.2126*r + 0.7152*g + 0.0722*b) > 18;
+      }
+
+      function visibleRect(el) {
+        if (!el) return null;
+        var style = cs(el);
+        var rect = el.getBoundingClientRect();
+        if (!style || style.display === 'none' || style.visibility === 'hidden' || parseFloat(style.opacity || '1') <= 0 || rect.width < 2 || rect.height < 2) return null;
+        return rect;
+      }
+
       var navEl  = document.querySelector('nav, header, [role="banner"]');
       var bodyEl = document.body;
       var h1El   = document.querySelector('h1');
-      var btnEl  = document.querySelector(
-        'a.btn-primary, button.btn-primary, .btn-primary, .cta-btn,' +
-        'a.button--primary, button.button--primary, [class*="btn-cta"],' +
-        '[class*="cta-button"], .wp-block-button__link, [class*="hero"] a,' +
-        '.elementor-button, .elementor-button-link,' +
-        '.et_pb_button,' +
-        '.fl-button,' +
-        '.vc_btn,' +
-        '[class*="cta"][href], [class*="get-started"], [class*="contact-btn"]'
-      );
+      var btnEl = null;
+      var btnScore = -Infinity;
+      var interactive = document.querySelectorAll('a[href], button, [role="button"]');
+      for (var bi = 0; bi < interactive.length; bi++) {
+        var candidateButton = interactive[bi];
+        var buttonRect = visibleRect(candidateButton);
+        if (!buttonRect || buttonRect.width < 44 || buttonRect.height < 20) continue;
+        if (buttonRect.bottom < 0 || buttonRect.top > window.innerHeight) continue;
+        var buttonStyle = cs(candidateButton);
+        var buttonBg = buttonStyle ? toHex(buttonStyle.backgroundColor) : null;
+        if (!buttonBg) continue;
+        var buttonDescriptor = [candidateButton.textContent, candidateButton.id, candidateButton.className, candidateButton.getAttribute('aria-label')].join(' ');
+        if (/\\b(?:skip|screen-reader|sr-only|visually-hidden)\\b/i.test(buttonDescriptor)) continue;
+        var buttonText = String(candidateButton.textContent || candidateButton.getAttribute('aria-label') || '').replace(/\\s+/g, ' ').trim();
+        var explicitButtonEvidence = /\\b(?:btn[-_ ]?primary|button[-_ ]?primary|cta|call[-_ ]?to[-_ ]?action)\\b/i.test(buttonDescriptor);
+        var actionTextEvidence = /\\b(?:get started|start|try|book|contact|schedule|request|sign up|join|buy|shop|call|quote|estimate|verify)\\b/i.test(buttonDescriptor);
+        if (!explicitButtonEvidence && !actionTextEvidence && (buttonRect.height > 100 || buttonText.length > 80)) continue;
+        var score = 0;
+        if (isChromatic(buttonBg)) score += 35;
+        if (explicitButtonEvidence) score += 30;
+        if (actionTextEvidence) score += 20;
+        if (candidateButton.closest('main, [role="main"], [class*="hero"]')) score += 12;
+        if (candidateButton.closest('header, nav, [role="banner"]')) score += 4;
+        score += Math.min(10, Math.round((buttonRect.width * buttonRect.height) / 5000));
+        if (score > btnScore) { btnEl = candidateButton; btnScore = score; }
+      }
       var navStyle  = cs(navEl);
       var bodyStyle = cs(bodyEl);
       var h1Style   = cs(h1El);
       var btnStyle  = cs(btnEl);
 
       var svgFreq = {};
-      var svgScope = navEl || document.querySelector('header, [role="banner"]');
+      var svgScope = document;
       if (svgScope) {
-        var svgEls = svgScope.querySelectorAll('svg *, [fill], path, circle, rect, polygon, polyline');
+        var svgEls = svgScope.querySelectorAll('svg *, svg[fill], svg path, svg circle, svg rect, svg polygon, svg polyline');
         for (var si = 0; si < svgEls.length; si++) {
           var svgEl = svgEls[si];
+          var owningSvg = svgEl.closest('svg');
+          var owningRect = owningSvg ? owningSvg.getBoundingClientRect() : null;
+          if (!owningRect || owningRect.bottom < 0 || owningRect.top > 300 || owningRect.width < 12 || owningRect.height < 12) continue;
           var fillComp = cs(svgEl) ? cs(svgEl).fill : null;
           var fillAttr = svgEl.getAttribute('fill');
           var fillHex = null;
@@ -4301,55 +4498,251 @@ async function extractBrandingFromPage(page) {
         }
       }
 
+      var cssPrimaryCandidates = [];
+      var cssAccentCandidates = [];
+      var rootStyle = cs(document.documentElement);
+      if (rootStyle) {
+        for (var ci = 0; ci < rootStyle.length; ci++) {
+          var propertyName = rootStyle[ci];
+          if (!propertyName || propertyName.indexOf('--') !== 0) continue;
+          var normalizedName = propertyName.toLowerCase();
+          if (!/(?:^|[-_])(?:brand|primary|accent)(?:$|[-_])/.test(normalizedName)) continue;
+          if (/(?:on[-_]?primary|primary[-_]?(?:text|foreground)|accent[-_]?(?:text|foreground))/.test(normalizedName)) continue;
+          var propertyValue = rootStyle.getPropertyValue(propertyName).trim();
+          var propertyHex = toHex(propertyValue);
+          if (!propertyHex || !isChromatic(propertyHex)) continue;
+          var item = { hex: propertyHex, name: propertyName };
+          if (/(?:^|[-_])primary(?:$|[-_])|brand/.test(normalizedName)) cssPrimaryCandidates.push(item);
+          if (/(?:^|[-_])accent(?:$|[-_])/.test(normalizedName)) cssAccentCandidates.push(item);
+        }
+      }
+
+      var themeColorEl = document.querySelector('meta[name="theme-color"]');
+      var themeColor = themeColorEl ? toHex(themeColorEl.getAttribute('content')) : null;
+
+      var visibleBgFreq = {};
+      var topBgFreq = {};
+      var visibleElements = document.querySelectorAll('body *');
+      for (var vi = 0; vi < visibleElements.length && vi < 1500; vi++) {
+        var visibleElement = visibleElements[vi];
+        var visibleElementRect = visibleRect(visibleElement);
+        if (!visibleElementRect || visibleElementRect.width < 20 || visibleElementRect.height < 12) continue;
+        var visibleStyle = cs(visibleElement);
+        var visibleHex = visibleStyle ? toHex(visibleStyle.backgroundColor) : null;
+        if (!visibleHex || !isChromatic(visibleHex)) continue;
+        var areaWeight = Math.max(1, Math.min(20, Math.round(Math.sqrt(visibleElementRect.width * visibleElementRect.height) / 40)));
+        visibleBgFreq[visibleHex] = (visibleBgFreq[visibleHex] || 0) + areaWeight;
+        if (visibleElementRect.top < 300 && visibleElementRect.bottom > 0 && visibleElementRect.width >= window.innerWidth * 0.5) {
+          topBgFreq[visibleHex] = (topBgFreq[visibleHex] || 0) + areaWeight;
+        }
+      }
+
       var pageHost = window.location.hostname.replace(/^www\\./, '');
       function isSameDomain(src) {
-        try { return new URL(src).hostname.replace(/^www\\./, '').endsWith(pageHost); } catch { return false; }
+        try {
+          var host = new URL(src).hostname.replace(/^www\\./, '');
+          return host === pageHost || host.endsWith('.' + pageHost);
+        } catch { return false; }
       }
-      var logoSelectors = [
-        'header img[class*="logo"]', 'nav img[class*="logo"]',
-        'img[class*="site-logo"]', 'img[class*="brand-logo"]',
-        'img[alt*="logo" i]', '.logo img', '#logo img',
-        'header img:first-of-type', 'nav img:first-of-type'
-      ];
-      var logoSrc = null;
-      for (var i = 0; i < logoSelectors.length; i++) {
-        var el = document.querySelector(logoSelectors[i]);
-        if (el && el.src && isSameDomain(el.src)) { logoSrc = el.src; break; }
-      }
-      if (!logoSrc) {
-        for (var j = 0; j < logoSelectors.length; j++) {
-          var el2 = document.querySelector(logoSelectors[j]);
-          if (el2 && el2.src) { logoSrc = el2.src; break; }
+      var logoCandidates = {};
+      function addLogo(raw, region, evidence, score, alt, width, height) {
+        if (!raw || raw.startsWith('data:') || raw.startsWith('blob:')) return;
+        var url;
+        try { url = new URL(raw, document.baseURI); } catch (_) { return; }
+        if (url.protocol !== 'http:' && url.protocol !== 'https:') return;
+        url.hash = '';
+        var key = url.href;
+        var existing = logoCandidates[key] || {
+          url: key, score: 0, region: region, evidence: [], alt: null, width: null, height: null
+        };
+        existing.score = Math.max(existing.score, score);
+        existing.evidence = Array.from(new Set(existing.evidence.concat(evidence)));
+        if (region === 'json_ld' || (existing.region === 'body' && region !== 'body')) existing.region = region;
+        if (alt && !existing.alt) existing.alt = alt.replace(/\\s+/g, ' ').trim().slice(0, 300) || null;
+        if ((width || 0) * (height || 0) > (existing.width || 0) * (existing.height || 0)) {
+          existing.width = width || null; existing.height = height || null;
+        }
+        logoCandidates[key] = existing;
+      }
+
+      function jsonLogo(value) {
+        if (typeof value === 'string') return value;
+        if (!value || typeof value !== 'object') return null;
+        return typeof value.url === 'string' ? value.url : typeof value.contentUrl === 'string' ? value.contentUrl : null;
+      }
+      var jsonScripts = document.querySelectorAll('script[type="application/ld+json"]');
+      for (var ji = 0; ji < jsonScripts.length; ji++) {
+        try {
+          var parsed = JSON.parse(jsonScripts[ji].textContent || 'null');
+          var stack = Array.isArray(parsed) ? parsed.slice() : [parsed];
+          var visited = 0;
+          while (stack.length && visited++ < 1000) {
+            var node = stack.pop();
+            if (!node || typeof node !== 'object') continue;
+            var types = Array.isArray(node['@type']) ? node['@type'] : [node['@type']];
+            var entity = types.some(function(t) { return /^(Organization|Corporation|LocalBusiness|WebSite|Brand)$/i.test(String(t || '')); });
+            var logo = entity ? jsonLogo(node.logo) : null;
+            if (logo) addLogo(logo, 'json_ld', ['json_ld_logo'], 100, null, null, null);
+            Object.keys(node).forEach(function(key) {
+              if (key === '@context') return;
+              var child = node[key];
+              if (Array.isArray(child)) stack = stack.concat(child.filter(function(value) { return value && typeof value === 'object'; }));
+              else if (child && typeof child === 'object') stack.push(child);
+            });
+          }
+        } catch (_) {}
+      }
+
+      var proofCandidates = {};
+      var pageHeadings = Array.from(document.querySelectorAll('h1,h2,h3,h4,h5,h6'));
+      function nearestHeadingText(element) {
+        var nearest = null;
+        for (var hi = 0; hi < pageHeadings.length; hi++) {
+          if (pageHeadings[hi].compareDocumentPosition(element) & 4) nearest = pageHeadings[hi];
+          else break;
+        }
+        return nearest && nearest.textContent ? nearest.textContent.replace(/\\s+/g, ' ').trim().slice(0, 300) : null;
+      }
+      function proofTypeFor(descriptor, context) {
+        if (/\\b(?:joint[-_ ]commission|accredit(?:ed|ation))\\b/i.test(descriptor)) return 'accreditation';
+        if (/\\b(?:certifi(?:ed|cation)|compliance|legitscript|hipaa)\\b/i.test(descriptor)) return 'certification';
+        if (/\\b(?:award|winner|best of|top[-_ ]?rated)\\b/i.test(descriptor)) return 'award';
+        if (/\\b(?:member|membership|association|professionals?)\\b/i.test(descriptor)) return 'membership';
+        if (/\\b(?:press|featured|as seen|mentioned)\\b/i.test(descriptor)) return 'press_mention';
+        if (/\\b(?:partner|customer|client|trusted by|used by|works with)\\b/i.test(descriptor)) return 'partner_or_customer';
+        if (/\\b(?:joint[-_ ]commission|accredit(?:ed|ation))\\b/i.test(context || '')) return 'accreditation';
+        if (/\\b(?:certifi(?:ed|cation)|compliance)\\b/i.test(context || '')) return 'certification';
+        if (/\\b(?:award|winner|best of|top[-_ ]?rated)\\b/i.test(context || '')) return 'award';
+        if (/\\b(?:member|membership|association)\\b/i.test(context || '')) return 'membership';
+        if (/\\b(?:press|featured|as seen|mentioned)\\b/i.test(context || '')) return 'press_mention';
+        if (/\\b(?:partner|customer|client|trusted by|used by|works with)\\b/i.test(context || '')) return 'partner_or_customer';
+        return 'trust_mark';
+      }
+      function addProof(raw, proofType, score, evidence, alt, context, width, height) {
+        if (!raw || raw.startsWith('data:') || raw.startsWith('blob:')) return;
+        var url;
+        try { url = new URL(raw, document.baseURI); } catch (_) { return; }
+        if (url.protocol !== 'http:' && url.protocol !== 'https:') return;
+        url.hash = '';
+        var key = url.href;
+        var existing = proofCandidates[key];
+        if (!existing || score > existing.score) {
+          proofCandidates[key] = {
+            url: key, proofType: proofType, score: score, confidence: 'low',
+            evidence: Array.from(new Set(evidence)), alt: alt || null, context: context || null,
+            width: width || null, height: height || null
+          };
+        }
+      }
+
+      var imageEls = document.querySelectorAll('img');
+      for (var li = 0; li < imageEls.length; li++) {
+        var image = imageEls[li];
+        var src = image.currentSrc || image.src || image.getAttribute('data-src') || image.getAttribute('data-lazy-src');
+        if (!src) continue;
+        var header = image.closest('header,[role="banner"]');
+        var nav = image.closest('nav,[role="navigation"]');
+        var footer = image.closest('footer,[role="contentinfo"]');
+        var region = header ? 'header' : nav ? 'nav' : footer ? 'footer' : 'body';
+        var evidence = [];
+        var score = 0;
+        if (header) { score += 35; evidence.push('header_or_banner'); }
+        else if (nav) { score += 28; evidence.push('navigation'); }
+        else if (footer) { score += 18; evidence.push('footer_or_contentinfo'); }
+        var descriptor = [src, image.id, image.className, image.alt, image.getAttribute('itemprop'), image.parentElement && image.parentElement.className].join(' ');
+        var identityDescriptor = [image.id, image.className, image.getAttribute('itemprop'), image.parentElement && image.parentElement.className].join(' ');
+        if (/\\b(?:site[-_ ]?logo|brand[-_ ]?logo|custom-logo|navbar[-_ ]?brand|site[-_ ]?branding|site[-_ ]?identity|logo[-_ ]?link)\\b/i.test(identityDescriptor)) { score += 30; evidence.push('site_identity_marker'); }
+        else if (/\\blogo\\b/i.test(descriptor)) { score += 12; evidence.push('generic_logo_marker'); }
+        var anchor = image.closest('a[href]');
+        if (anchor) {
+          try {
+            var destination = new URL(anchor.href, document.baseURI);
+            if (destination.origin === location.origin && destination.pathname.replace(/\\/+$/, '') === '') {
+              score += 22; evidence.push('links_to_homepage');
+            }
+          } catch (_) {}
+        }
+        if (isSameDomain(src)) { score += 8; evidence.push('same_domain'); }
+        var style = cs(image);
+        var visible = !!style && style.display !== 'none' && style.visibility !== 'hidden' && parseFloat(style.opacity || '1') > 0;
+        if (visible) { score += 5; evidence.push('visible'); }
+        var width = image.naturalWidth || image.width || null;
+        var height = image.naturalHeight || image.height || null;
+        if (width && height && width >= 80 && height >= 24) { score += 5; evidence.push('plausible_logo_dimensions'); }
+        if ((width && width < 32) || (height && height < 16)) { score -= 45; evidence.push('tiny_asset_penalty'); }
+        if (/\\b(?:icon|avatar|profile|search|menu|hamburger|social|badge)\\b/i.test(descriptor)) { score -= 35; evidence.push('icon_or_avatar_penalty'); }
+        addLogo(src, region, evidence, score, image.alt || null, width, height);
+
+        if (region === 'body' && visible && width && height && width >= 80 && height >= 40) {
+          var context = nearestHeadingText(image);
+          var proofDescriptor = [src, image.alt, image.getAttribute('title')].filter(Boolean).join(' ');
+          var proofEvidence = [];
+          var proofScore = 0;
+          var commercialContext = !!context && /\\b(?:insurances?|payment|financing|we accept|accepted health)\\b/i.test(context);
+          if (/\\b(?:logo|seal|trust[-_ ]?mark|certification[-_ ]?mark)\\b/i.test(proofDescriptor)) { proofScore += 30; proofEvidence.push('proof_asset_marker'); }
+          if (/\\b(?:joint[-_ ]commission|accredit(?:ed|ation)|certifi(?:ed|cation)|compliance|legitscript|hipaa|award|winner|best of|top[-_ ]?rated|member|membership|association|professionals?|press|featured|as seen|mentioned|partner|customer|client|trusted by|used by|works with)\\b/i.test(proofDescriptor)) { proofScore += 30; proofEvidence.push('proof_descriptor'); }
+          if (context && /\\b(?:recognized|accredit(?:ed|ation)|certifi(?:ed|cation)|award|winner|member|membership|association|featured|as seen|mentioned|partner|customer|client|trusted|trust)\\b/i.test(context)) { proofScore += 25; proofEvidence.push('proof_section_context'); }
+          if (commercialContext) { proofScore -= 100; proofEvidence.push('commercial_acceptance_context_exclusion'); }
+          proofScore += 10; proofEvidence.push('proof_dimensions');
+          proofScore += 5; proofEvidence.push('visible');
+          if (isSameDomain(src)) { proofScore += 5; proofEvidence.push('same_domain'); }
+          else { proofScore += 3; proofEvidence.push('external_asset_domain'); }
+          if (!commercialContext && proofScore >= 45) addProof(src, proofTypeFor(proofDescriptor, context), proofScore, proofEvidence, image.alt || null, context, width, height);
         }
       }
       var faviconEl = document.querySelector(
         'link[rel~="icon"], link[rel="shortcut icon"], link[rel="apple-touch-icon"]'
       );
+      if (faviconEl && faviconEl.href) addLogo(faviconEl.href, 'favicon', ['favicon_fallback_only'], 10, null, null, null);
+      var rankedLogos = Object.values(logoCandidates).filter(function(candidate) { return candidate.region !== 'body'; }).sort(function(a, b) { return b.score - a.score || a.url.localeCompare(b.url); }).slice(0, 20);
+      for (var ri = 0; ri < rankedLogos.length; ri++) {
+        rankedLogos[ri].confidence = rankedLogos[ri].score >= 85 ? 'high' : rankedLogos[ri].score >= 60 ? 'medium' : 'low';
+      }
+      var primaryLogo = rankedLogos.length && rankedLogos[0].score >= 55 && rankedLogos[0].region !== 'favicon' ? rankedLogos[0] : null;
       return {
-        navBg:          navStyle  ? navStyle.backgroundColor  : null,
-        bodyBg:         bodyStyle ? bodyStyle.backgroundColor : null,
-        bodyColor:      bodyStyle ? bodyStyle.color           : null,
-        h1Color:        h1Style   ? h1Style.color             : null,
-        btnBg:          btnStyle  ? btnStyle.backgroundColor  : null,
+        navBg:          navStyle  ? toHex(navStyle.backgroundColor)  : null,
+        bodyBg:         (bodyStyle ? toHex(bodyStyle.backgroundColor) : null) || (cs(document.documentElement) ? toHex(cs(document.documentElement).backgroundColor) : null) || '#ffffff',
+        bodyColor:      bodyStyle ? toHex(bodyStyle.color)           : null,
+        h1Color:        h1Style   ? toHex(h1Style.color)             : null,
+        btnBg:          btnStyle  ? toHex(btnStyle.backgroundColor)  : null,
+        btnDetail:      btnEl ? String(btnEl.textContent || btnEl.getAttribute('aria-label') || '').replace(/\\s+/g, ' ').trim().slice(0, 120) : null,
         bodyFont:       bodyStyle ? bodyStyle.fontFamily      : null,
         h1Font:         h1Style   ? h1Style.fontFamily        : null,
-        logoSrc:        logoSrc,
+        logoSrc:        primaryLogo ? primaryLogo.url : null,
+        logoConfidence: primaryLogo ? primaryLogo.confidence : null,
+        logoSelectionReason: primaryLogo ? primaryLogo.evidence.join(', ') : null,
+        logoCandidates: rankedLogos,
+        proofCandidates: Object.values(proofCandidates),
         faviconHref:    faviconEl ? faviconEl.href            : null,
         svgFreq:        svgFreq,
         navChildBgFreq: navChildBgFreq,
+        visibleBgFreq:  visibleBgFreq,
+        topBgFreq: topBgFreq,
+        cssPrimaryCandidates: cssPrimaryCandidates,
+        cssAccentCandidates: cssAccentCandidates,
+        themeColor: themeColor,
       };
     })()
   `;
   const raw = await page.evaluate(evalScript);
-  const navBgHex = rgbToHex(raw.navBg ?? "");
-  const bodyBgHex = rgbToHex(raw.bodyBg ?? "");
+  const logoSelection = selectRankedLogoCandidates(raw.logoCandidates ?? []);
+  const navBgHex = raw.navBg;
+  const bodyBgHex = raw.bodyBg;
   const navBgUsable = navBgHex && !isTransparentOrWhite(navBgHex) && navBgHex !== "#000000" && navBgHex !== "#020101" ? navBgHex : null;
-  const svgPrimary = dominantColor(raw.svgFreq ?? {});
+  const svgPrimary = dominantChromaticColor(raw.svgFreq ?? {});
   const navChildBg = dominantColor(raw.navChildBgFreq ?? {});
-  const primary = navBgUsable ?? svgPrimary ?? navChildBg ?? bodyBgHex;
-  const accent = rgbToHex(raw.btnBg ?? "");
-  const text2 = rgbToHex(raw.bodyColor ?? "");
-  const heading = rgbToHex(raw.h1Color ?? "");
+  const visibleBg = dominantColor(raw.visibleBgFreq ?? {});
+  const topBg = dominantColor(raw.topBgFreq ?? {});
+  const cssPrimary = raw.cssPrimaryCandidates?.[0] ?? null;
+  const cssAccent = raw.cssAccentCandidates?.[0] ?? null;
+  const themeColor = isChromatic(raw.themeColor) ? raw.themeColor : null;
+  const ctaColor = isChromatic(raw.btnBg) ? raw.btnBg : null;
+  const primaryChoice = cssPrimary ? { value: cssPrimary.hex, source: "css_variable", confidence: "high", detail: cssPrimary.name } : themeColor ? { value: themeColor, source: "theme_color", confidence: "high", detail: 'meta[name="theme-color"]' } : navBgUsable && isChromatic(navBgUsable) ? { value: navBgUsable, source: "navigation_background", confidence: "medium", detail: "nav, header, or banner computed background" } : topBg && isChromatic(topBg) ? { value: topBg, source: "navigation_background", confidence: "medium", detail: "dominant wide rendered background near the top of the page" } : svgPrimary && isChromatic(svgPrimary) ? { value: svgPrimary, source: "header_svg", confidence: "medium", detail: "dominant rendered identity SVG fill near the top of the page" } : navChildBg && isChromatic(navChildBg) ? { value: navChildBg, source: "navigation_background", confidence: "medium", detail: "dominant rendered navigation child background" } : ctaColor ? { value: ctaColor, source: "visible_cta", confidence: "medium", detail: raw.btnDetail } : visibleBg && isChromatic(visibleBg) ? { value: visibleBg, source: "visible_background", confidence: "low", detail: "area-weighted rendered element background" } : bodyBgHex && !isTransparentOrWhite(bodyBgHex) ? { value: bodyBgHex, source: "body_background", confidence: "low", detail: "computed body background fallback" } : null;
+  const accentChoice = cssAccent ? { value: cssAccent.hex, source: "css_variable", confidence: "high", detail: cssAccent.name } : ctaColor ? { value: ctaColor, source: "visible_cta", confidence: "medium", detail: raw.btnDetail } : null;
+  const primary = primaryChoice?.value ?? null;
+  const accent = accentChoice?.value ?? null;
+  const text2 = raw.bodyColor;
+  const heading = raw.h1Color;
   const background = bodyBgHex;
   const scheme = background ? luminance(background) > 128 ? "light" : "dark" : null;
   return {
@@ -4361,22 +4754,208 @@ async function extractBrandingFromPage(page) {
       text: text2 ?? null,
       heading: heading ?? null
     },
+    colorEvidence: {
+      primary: primaryChoice,
+      accent: accentChoice,
+      background: background ? { value: background, source: "body_background", confidence: "high", detail: "computed body background" } : null,
+      text: text2 ? { value: text2, source: "body_text", confidence: "high", detail: "computed body text color" } : null,
+      heading: heading ? { value: heading, source: "heading_text", confidence: "high", detail: "computed first H1 text color" } : null
+    },
     fonts: {
       body: firstFont(raw.bodyFont ?? ""),
       heading: firstFont(raw.h1Font ?? "")
     },
     assets: {
-      logo: raw.logoSrc || null,
-      favicon: raw.faviconHref || null
+      logo: logoSelection.primary?.url ?? null,
+      favicon: raw.faviconHref || null,
+      logoConfidence: logoSelection.primary?.confidence ?? null,
+      logoSelectionReason: logoSelection.selectionReason,
+      logoVariants: logoSelection.variants,
+      logoCandidates: logoSelection.candidates,
+      proofImages: selectProofImages(raw.proofCandidates ?? [])
     }
   };
 }
 
+// src/lib/rendered-media.ts
+var SETTLE_MS = 450;
+var STABLE_CHECKS_REQUIRED = 3;
+var MAX_SCROLL_ROUNDS = 40;
+var MAX_DOM_NODES = 15e3;
+function mergeAsset(target, incoming) {
+  const existing = target.get(incoming.url);
+  if (!existing) {
+    target.set(incoming.url, incoming);
+    return;
+  }
+  existing.discoveryMethods = [.../* @__PURE__ */ new Set([...existing.discoveryMethods, ...incoming.discoveryMethods])];
+  existing.altTexts = [.../* @__PURE__ */ new Set([...existing.altTexts, ...incoming.altTexts])];
+  existing.contexts = [.../* @__PURE__ */ new Set([...existing.contexts, ...incoming.contexts])];
+  if ((incoming.width ?? 0) * (incoming.height ?? 0) > (existing.width ?? 0) * (existing.height ?? 0)) {
+    existing.width = incoming.width;
+    existing.height = incoming.height;
+  }
+}
+async function readRenderedSnapshot(page) {
+  await page.evaluate("globalThis.__name = globalThis.__name || ((target) => target)");
+  return page.evaluate(({ maxDomNodes }) => {
+    const rows = /* @__PURE__ */ new Map();
+    const resolve2 = (raw) => {
+      if (!raw || raw.startsWith("data:") || raw.startsWith("blob:")) return null;
+      try {
+        const parsed = new URL(raw, document.baseURI);
+        if (parsed.protocol !== "http:" && parsed.protocol !== "https:") return null;
+        parsed.hash = "";
+        return parsed.href;
+      } catch {
+        return null;
+      }
+    };
+    const contextFor = (element) => {
+      const contexts = [];
+      const section2 = element.closest('section,article,main,header,footer,aside,[role="region"]');
+      if (section2?.id) contexts.push(`#${section2.id}`);
+      const labelled = section2?.getAttribute("aria-label")?.trim();
+      if (labelled) contexts.push(labelled.slice(0, 200));
+      const heading = section2?.querySelector("h1,h2,h3,h4,h5,h6")?.textContent?.replace(/\s+/g, " ").trim();
+      if (heading) contexts.push(heading.slice(0, 200));
+      return contexts;
+    };
+    const add = (raw, type, method, element, dimensions, alt) => {
+      const url = resolve2(raw);
+      if (!url) return;
+      const existing = rows.get(url) ?? {
+        url,
+        type,
+        discoveryMethods: [],
+        altTexts: [],
+        contexts: [],
+        width: null,
+        height: null
+      };
+      existing.discoveryMethods = [.../* @__PURE__ */ new Set([...existing.discoveryMethods, method])];
+      const cleanAlt = alt?.replace(/\s+/g, " ").trim();
+      if (cleanAlt) existing.altTexts = [.../* @__PURE__ */ new Set([...existing.altTexts, cleanAlt.slice(0, 500)])];
+      existing.contexts = [.../* @__PURE__ */ new Set([...existing.contexts, ...contextFor(element)])];
+      if (dimensions && dimensions.width > 0 && dimensions.height > 0) {
+        const currentArea = (existing.width ?? 0) * (existing.height ?? 0);
+        if (dimensions.width * dimensions.height > currentArea) {
+          existing.width = dimensions.width;
+          existing.height = dimensions.height;
+        }
+      }
+      rows.set(url, existing);
+    };
+    const srcsetUrls = (value) => (value ?? "").split(",").map((part) => part.trim().split(/\s+/)[0] ?? "").filter(Boolean);
+    for (const img of Array.from(document.querySelectorAll("img"))) {
+      const image = img;
+      const dimensions = { width: image.naturalWidth, height: image.naturalHeight };
+      add(image.currentSrc, "image", "rendered-current-src", image, dimensions, image.alt);
+      add(image.getAttribute("src"), "image", "rendered-src", image, dimensions, image.alt);
+      for (const attr of ["data-src", "data-lazy-src", "data-original", "data-bg", "data-background"]) {
+        add(image.getAttribute(attr), "image", `rendered-${attr}`, image, dimensions, image.alt);
+      }
+      for (const url of srcsetUrls(image.getAttribute("srcset"))) add(url, "image", "rendered-srcset", image, dimensions, image.alt);
+      const anchor = image.closest("a[href]");
+      const anchorAttrs = anchor ? Array.from(anchor.attributes).map((attribute) => `${attribute.name}=${attribute.value}`).join(" ") : "";
+      if (anchor && (/lightbox|gallery|fancybox|glightbox|swipebox|elementor-open-lightbox/i.test(anchorAttrs) || /\.(?:avif|gif|jpe?g|png|svg|webp)(?:[?#]|$)/i.test(anchor.href))) add(anchor.href, "image", "rendered-lightbox-target", image, void 0, image.alt);
+    }
+    for (const source of Array.from(document.querySelectorAll("source"))) {
+      const parent = source.closest("picture,video,audio");
+      const type = parent?.tagName === "VIDEO" ? "video" : parent?.tagName === "AUDIO" ? "audio" : "image";
+      add(source.getAttribute("src"), type, "rendered-source", source);
+      for (const url of srcsetUrls(source.getAttribute("srcset"))) add(url, type, "rendered-source-srcset", source);
+    }
+    for (const video of Array.from(document.querySelectorAll("video"))) {
+      const media = video;
+      add(media.currentSrc || media.src, "video", "rendered-video", media);
+      add(media.poster, "image", "rendered-video-poster", media, { width: media.videoWidth, height: media.videoHeight });
+    }
+    for (const audio of Array.from(document.querySelectorAll("audio"))) {
+      const media = audio;
+      add(media.currentSrc || media.src, "audio", "rendered-audio", media);
+    }
+    for (const svgImage of Array.from(document.querySelectorAll("svg image"))) {
+      add(svgImage.getAttribute("href") || svgImage.getAttribute("xlink:href"), "image", "rendered-svg-image", svgImage);
+    }
+    const all = Array.from(document.querySelectorAll("*")).slice(0, maxDomNodes);
+    for (const element of all) {
+      const background = getComputedStyle(element).backgroundImage;
+      if (!background || background === "none") continue;
+      for (const match of background.matchAll(/url\(["']?(.+?)["']?\)/gi)) {
+        add(match[1], "image", "rendered-computed-background", element);
+      }
+    }
+    const documentHeight = Math.max(document.body?.scrollHeight ?? 0, document.documentElement?.scrollHeight ?? 0);
+    const viewportHeight = window.innerHeight;
+    return {
+      assets: [...rows.values()],
+      documentHeight,
+      scrollY: window.scrollY,
+      viewportHeight,
+      atBottom: window.scrollY + viewportHeight >= documentHeight - 5
+    };
+  }, { maxDomNodes: MAX_DOM_NODES });
+}
+async function collectRenderedPageMedia(page, maxAssets = 1e3) {
+  const boundedMax = Math.max(1, Math.min(maxAssets, 2e3));
+  await page.evaluate(() => {
+    for (const image of Array.from(document.querySelectorAll('img[loading="lazy"]'))) image.loading = "eager";
+  }).catch(() => void 0);
+  const assets = /* @__PURE__ */ new Map();
+  let stableChecks = 0;
+  let previousHeight = -1;
+  let rounds = 0;
+  let documentHeight = 0;
+  while (rounds < MAX_SCROLL_ROUNDS) {
+    rounds += 1;
+    const before = assets.size;
+    const snapshot = await readRenderedSnapshot(page);
+    documentHeight = snapshot.documentHeight;
+    for (const asset of snapshot.assets) mergeAsset(assets, asset);
+    if (assets.size >= boundedMax) {
+      return {
+        assets: [...assets.values()].slice(0, boundedMax),
+        exhausted: false,
+        stopReason: "asset_limit",
+        scrollRounds: rounds,
+        documentHeight
+      };
+    }
+    const unchanged = snapshot.atBottom && before === assets.size && previousHeight === snapshot.documentHeight;
+    stableChecks = unchanged ? stableChecks + 1 : 0;
+    previousHeight = snapshot.documentHeight;
+    if (stableChecks >= STABLE_CHECKS_REQUIRED) {
+      await page.evaluate(() => window.scrollTo(0, 0)).catch(() => void 0);
+      return {
+        assets: [...assets.values()],
+        exhausted: true,
+        stopReason: "page_exhausted",
+        scrollRounds: rounds,
+        documentHeight
+      };
+    }
+    await page.evaluate(({ viewportHeight, documentHeight: height }) => {
+      const next = Math.min(Math.max(0, height - viewportHeight), window.scrollY + Math.max(800, Math.floor(viewportHeight * 0.9)));
+      window.scrollTo(0, next);
+    }, { viewportHeight: snapshot.viewportHeight, documentHeight: snapshot.documentHeight });
+    await page.waitForTimeout(SETTLE_MS);
+  }
+  await page.evaluate(() => window.scrollTo(0, 0)).catch(() => void 0);
+  return {
+    assets: [...assets.values()],
+    exhausted: false,
+    stopReason: "scroll_round_limit",
+    scrollRounds: rounds,
+    documentHeight
+  };
+}
+
 // src/lib/screenshot.ts
 var DESKTOP_VIEWPORT = { width: 1440, height: 900 };
 var MOBILE_VIEWPORT = { width: 390, height: 844 };
 var SCROLL_STEP = 900;
-var SETTLE_MS = 400;
+var SETTLE_MS2 = 400;
 async function scrollAndStitch(page, device = "desktop") {
   const vp = device === "mobile" ? MOBILE_VIEWPORT : DESKTOP_VIEWPORT;
   await page.setViewportSize(vp);
@@ -4392,7 +4971,7 @@ async function scrollAndStitch(page, device = "desktop") {
   let scrollY = 0;
   while (scrollY < totalH) {
     await page.evaluate((y) => window.scrollTo(0, y), scrollY);
-    await page.waitForTimeout(SETTLE_MS);
+    await page.waitForTimeout(SETTLE_MS2);
     const remaining = totalH - scrollY;
     const stripH = Math.min(SCROLL_STEP, remaining);
     const buf = await page.screenshot({
@@ -4423,7 +5002,7 @@ async function scrollAndStitch(page, device = "desktop") {
   );
   return Buffer.from(base64, "base64");
 }
-async function captureLocal(url, device, wantScreenshot, wantBranding) {
+async function captureLocal(url, device, wantScreenshot, wantBranding, wantMedia, maxMediaAssets) {
   const vp = device === "mobile" ? MOBILE_VIEWPORT : DESKTOP_VIEWPORT;
   const browser = await chromium2.launch({ headless: true });
   const runtimeUserAgent = await detectRuntimeUserAgent(browser);
@@ -4434,17 +5013,18 @@ async function captureLocal(url, device, wantScreenshot, wantBranding) {
   }, runtimeUserAgent));
   const page = await context.newPage();
   try {
-    await page.goto(url, { waitUntil: "networkidle", timeout: 6e4 });
+    await page.goto(url, { waitUntil: "domcontentloaded", timeout: 6e4 });
     await page.waitForTimeout(1500);
     const result = {};
     if (wantBranding) result.branding = await extractBrandingFromPage(page);
+    if (wantMedia) result.renderedMedia = await collectRenderedPageMedia(page, maxMediaAssets);
     if (wantScreenshot) result.screenshot = await scrollAndStitch(page, device);
     return result;
   } finally {
     await browser.close();
   }
 }
-async function captureKernel(url, kernelApiKey, device, wantScreenshot, wantBranding) {
+async function captureKernel(url, kernelApiKey, device, wantScreenshot, wantBranding, wantMedia, maxMediaAssets) {
   const kernel = new Kernel2({ apiKey: kernelApiKey });
   const openedAtMs = Date.now();
   const session = await kernel.browsers.create({ stealth: true, timeout_seconds: 240 });
@@ -4457,10 +5037,11 @@ async function captureKernel(url, kernelApiKey, device, wantScreenshot, wantBran
   }, runtimeUserAgent));
   const page = context.pages()[0] ?? await context.newPage();
   try {
-    await page.goto(url, { waitUntil: "networkidle", timeout: 6e4 });
+    await page.goto(url, { waitUntil: "domcontentloaded", timeout: 6e4 });
     await page.waitForTimeout(1500);
     const result = {};
     if (wantBranding) result.branding = await extractBrandingFromPage(page);
+    if (wantMedia) result.renderedMedia = await collectRenderedPageMedia(page, maxMediaAssets);
     if (wantScreenshot) result.screenshot = await scrollAndStitch(page, device);
     return result;
   } finally {
@@ -4480,12 +5061,14 @@ async function capturePageData(url, opts = {}) {
   const device = opts.device ?? "desktop";
   const wantShot = opts.screenshot ?? false;
   const wantBranding = opts.branding ?? false;
+  const wantMedia = opts.media ?? false;
+  const maxMediaAssets = opts.maxMediaAssets ?? 1e3;
   try {
-    return await captureLocal(url, device, wantShot, wantBranding);
+    return await captureLocal(url, device, wantShot, wantBranding, wantMedia, maxMediaAssets);
   } catch (localErr) {
     const msg = localErr instanceof Error ? localErr.message : String(localErr);
     if (!opts.kernelApiKey) throw new Error(`Local capture failed (${msg}) and no headless browser backend is configured`);
-    return await captureKernel(url, opts.kernelApiKey, device, wantShot, wantBranding);
+    return await captureKernel(url, opts.kernelApiKey, device, wantShot, wantBranding, wantMedia, maxMediaAssets);
   }
 }
 
@@ -4890,7 +5473,7 @@ function withTimeout(p, ms) {
 async function createBrowserWithRetry(client2, headless) {
   for (let attempt = 0; attempt < 3; attempt++) {
     try {
-      return await client2.browsers.create({ stealth: true, headless, timeout_seconds: 120 });
+      return await client2.browsers.create({ stealth: true, ...headless ? { headless: true } : {}, timeout_seconds: 120 });
     } catch (err) {
       if (attempt === 2) throw err;
       await new Promise((r) => setTimeout(r, 5e3));
@@ -4899,7 +5482,7 @@ async function createBrowserWithRetry(client2, headless) {
   throw new Error("unreachable");
 }
 var PAGE_HARD_TIMEOUT_MS = 35e3;
-async function crawlPage(context, url) {
+async function crawlPage(context, url, headless) {
   const startedAt = Date.now();
   let page = null;
   let guardState = null;
@@ -4908,13 +5491,38 @@ async function crawlPage(context, url) {
     guardState = await installBrowserRequestGuard(page, url);
     const work = (async (p) => {
       const resp = await p.goto(url, { waitUntil: "domcontentloaded", timeout: 3e4 });
-      const html = await p.evaluate((maxBytes) => {
+      let html = await p.evaluate((maxBytes) => {
         const value = document.documentElement?.outerHTML ?? "";
         if (new TextEncoder().encode(value).byteLength > maxBytes) throw new Error(`Browser HTML exceeds ${maxBytes} byte limit`);
         return value;
       }, MAX_PAGE_HTML_BYTES);
       const headers = resp ? Object.fromEntries(Object.entries(await resp.headers()).map(([k, v]) => [k.toLowerCase(), v])) : void 0;
       const finalUrl = p.url();
+      let challenge = detectBrowserChallenge({ status: resp?.status() ?? null, title: await p.title().catch(() => ""), html });
+      if (challenge.detected && !headless) {
+        const deadline = Date.now() + 2e4;
+        while (challenge.detected && Date.now() < deadline) {
+          await p.waitForTimeout(1e3);
+          html = await p.content();
+          challenge = detectBrowserChallenge({ status: resp?.status() ?? null, title: await p.title().catch(() => ""), html });
+        }
+      }
+      if (challenge.detected) {
+        return {
+          url,
+          html: null,
+          status: resp?.status() ?? 0,
+          via: "browser",
+          headers,
+          responseTimeMs: Date.now() - startedAt,
+          redirectUrl: finalUrl && finalUrl !== url ? finalUrl : null,
+          errorCode: "browser_challenge_unresolved",
+          error: `Browser challenge remained unresolved (${challenge.reason ?? "unknown challenge"}).`,
+          browserMode: headless ? "stealth_headless" : "stealth_headful",
+          challengeDetected: true,
+          stopReason: "challenge_unresolved"
+        };
+      }
       return {
         url,
         html,
@@ -4922,7 +5530,10 @@ async function crawlPage(context, url) {
         via: "browser",
         headers,
         responseTimeMs: Date.now() - startedAt,
-        redirectUrl: finalUrl && finalUrl !== url ? finalUrl : null
+        redirectUrl: finalUrl && finalUrl !== url ? finalUrl : null,
+        browserMode: headless ? "stealth_headless" : "stealth_headful",
+        challengeDetected: false,
+        stopReason: resp && (resp.status() < 200 || resp.status() >= 300) ? "http_error" : "usable_page"
       };
     })(page);
     const timeout = new Promise((_, reject) => setTimeout(() => reject(new Error("page-hard-timeout")), PAGE_HARD_TIMEOUT_MS));
@@ -4937,7 +5548,10 @@ async function crawlPage(context, url) {
       via: "browser",
       responseTimeMs: Date.now() - startedAt,
       errorCode,
-      error: message.slice(0, 500)
+      error: message.slice(0, 500),
+      browserMode: headless ? "stealth_headless" : "stealth_headful",
+      challengeDetected: false,
+      stopReason: "navigation_failed"
     };
   } finally {
     if (page) await page.close().catch(() => {
@@ -4951,7 +5565,7 @@ async function crawlWithRotation(urls, opts) {
   const headless = opts.headless ?? DEFAULT_HEADLESS;
   const uniqueUrls = [...new Set(urls)];
   const byUrl = /* @__PURE__ */ new Map();
-  const runPass = async (targets, phase) => {
+  const runPass = async (targets, phase, passHeadless) => {
     if (targets.length === 0) return;
     let next = 0;
     let done = 0;
@@ -4974,7 +5588,7 @@ async function crawlWithRotation(urls, opts) {
           const closedAtMs = Date.now();
           await client2.browsers.deleteByID(k.session_id).catch(() => {
           });
-          await recordKernelSession({ kernelSessionId: k.session_id, source: "rotating_crawl", stealth: typeof k.stealth === "boolean" ? k.stealth : null, headlessSent: headless, proxyUsed: typeof k.proxy_id === "string" ? Boolean(k.proxy_id) : null, openedAtMs, closedAtMs });
+          await recordKernelSession({ kernelSessionId: k.session_id, source: "rotating_crawl", stealth: typeof k.stealth === "boolean" ? k.stealth : null, headlessSent: passHeadless ? true : null, proxyUsed: typeof k.proxy_id === "string" ? Boolean(k.proxy_id) : null, fallback: phase === "retry", openedAtMs, closedAtMs });
         }
       };
       try {
@@ -4986,7 +5600,7 @@ async function crawlWithRotation(urls, opts) {
           try {
             if (!browser || inBrowser >= urlsPerBrowser) {
               await retire();
-              kb = await createBrowserWithRetry(client2, headless);
+              kb = await createBrowserWithRetry(client2, passHeadless);
               kbOpenedAtMs = Date.now();
               browser = await withTimeout(chromium3.connectOverCDP(kb.cdp_ws_url), 3e4);
               runtimeUserAgent = await detectRuntimeUserAgent(browser);
@@ -4994,7 +5608,7 @@ async function crawlWithRotation(urls, opts) {
             }
             const context = await browser.newContext(withRuntimeUserAgent({ serviceWorkers: "block" }, runtimeUserAgent));
             try {
-              r = await crawlPage(context, url);
+              r = await crawlPage(context, url, passHeadless);
             } finally {
               await context.close().catch(() => {
               });
@@ -5008,7 +5622,10 @@ async function crawlWithRotation(urls, opts) {
               status: 0,
               via: "browser",
               errorCode: "browser_session_failed",
-              error: message.slice(0, 500)
+              error: message.slice(0, 500),
+              browserMode: passHeadless ? "stealth_headless" : "stealth_headful",
+              challengeDetected: false,
+              stopReason: "navigation_failed"
             };
             await retire();
           }
@@ -5032,12 +5649,12 @@ async function crawlWithRotation(urls, opts) {
     };
     await Promise.all(Array.from({ length: workers }, () => worker()));
   };
-  await runPass(uniqueUrls, "main");
+  await runPass(uniqueUrls, "main", headless);
   const failed = uniqueUrls.filter((u) => {
     const r = byUrl.get(u);
     return !r || !r.html || r.status < 200 || r.status >= 300;
   });
-  if (failed.length > 0) await runPass(failed, "retry");
+  if (failed.length > 0) await runPass(failed, "retry", headless ? false : headless);
   return urls.map((u) => byUrl.get(u) ?? {
     url: u,
     html: null,
@@ -5749,8 +6366,6 @@ function parsePageData(url, html, status, via, resp, fetchAttempts = []) {
     if (text2) headings.push({ level: Number(m[1]), text: text2.slice(0, 200) });
   }
   const h1 = headings.find((h) => h.level === 1)?.text ?? null;
-  const bodyText = html.replace(/<script[\s\S]*?<\/script>/gi, "").replace(/<style[\s\S]*?<\/style>/gi, "").replace(/<[^>]+>/g, " ").replace(/\s+/g, " ").trim();
-  const wordCount2 = bodyText.split(" ").filter((w) => w.length > 2).length;
   const schemaTypes = [];
   let schemaTypeBytes = 0;
   const addSchemaType = (value) => {
@@ -5807,11 +6422,14 @@ function parsePageData(url, html, status, via, resp, fetchAttempts = []) {
     }
   }
   const mainHtml = (html.match(/<main[^>]*>([\s\S]*?)<\/main>/i)?.[1] ?? html.match(/<article[^>]*>([\s\S]*?)<\/article>/i)?.[1] ?? html.match(/<body[^>]*>([\s\S]*?)<\/body>/i)?.[1] ?? html).replace(/<(script|style|nav|header|footer|aside|noscript|svg|iframe)[^>]*>[\s\S]*?<\/\1>/gi, "");
+  const mainText = mainHtml.replace(/<[^>]+>/g, " ").replace(/&(?:nbsp|#160);/gi, " ").replace(/&(?:amp|#38);/gi, "&").replace(/&#(?:x[0-9a-f]+|\d+);/gi, " ").replace(/\s+/g, " ").trim();
+  const mainWords = mainText.match(/[\p{L}\p{N}][\p{L}\p{N}'’.-]*/gu) ?? [];
+  const wordCount2 = mainWords.filter((word) => word.length > 2).length;
   let bodyMarkdown = "";
   try {
     bodyMarkdown = turndown.turndown(mainHtml).replace(/\n{3,}/g, "\n\n").trim().slice(0, MAX_PAGE_MARKDOWN);
   } catch {
-    bodyMarkdown = bodyText.slice(0, MAX_PAGE_MARKDOWN);
+    bodyMarkdown = mainText.slice(0, MAX_PAGE_MARKDOWN);
   }
   const outlinks = [];
   const discoveryLinkSet = /* @__PURE__ */ new Set();
@@ -5839,10 +6457,11 @@ function parsePageData(url, html, status, via, resp, fetchAttempts = []) {
       const internal = abs.origin === origin;
       if (internal) {
         internalLinks++;
-        if (!discoveryLinkSet.has(abs.href)) {
-          const bytes2 = Buffer.byteLength(abs.href);
+        const crawlable = normalizeUrl(abs.href, documentUrl);
+        if (crawlable && !discoveryLinkSet.has(crawlable)) {
+          const bytes2 = Buffer.byteLength(crawlable);
           if (discoveryLinkSet.size < PAGE_DATA_LIMITS.discoveryLinks && discoveryBytes + bytes2 <= PAGE_DATA_LIMITS.discoveryBytes) {
-            discoveryLinkSet.add(abs.href);
+            discoveryLinkSet.add(crawlable);
             discoveryBytes += bytes2;
           } else truncatedFields.add("discoveryLinks");
         }
@@ -5864,8 +6483,8 @@ function parsePageData(url, html, status, via, resp, fetchAttempts = []) {
   const h1List = headings.filter((h) => h.level === 1);
   const h1_2 = h1List[1]?.text ?? null;
   const h2Count = headings.filter((h) => h.level === 2).length;
-  const textRatio = Number((bodyText.length / Math.max(1, html.length)).toFixed(3));
-  const contentHash = createHash("sha1").update(bodyText).digest("hex");
+  const textRatio = Number((mainText.length / Math.max(1, html.length)).toFixed(3));
+  const contentHash = createHash("sha1").update(mainText).digest("hex");
   const metaRobots = boundedText(html.match(/<meta[^>]+name=["']robots["'][^>]+content=["']([^"']*)["']/i)?.[1], 512)?.toLowerCase() ?? null;
   const relNext = boundedUrl(html.match(/<link[^>]+rel=["']next["'][^>]+href=["']([^"']*)["']/i)?.[1]);
   const relPrev = boundedUrl(html.match(/<link[^>]+rel=["']prev["'][^>]+href=["']([^"']*)["']/i)?.[1]);
@@ -5919,11 +6538,8 @@ function parsePageData(url, html, status, via, resp, fetchAttempts = []) {
       }
     }
   }
-  if (og?.image) {
-    try {
-      addImageLink(new URL(og.image, documentUrl).href);
-    } catch {
-    }
+  for (const asset of discoverStaticMedia(html, documentUrl)) {
+    if (asset.type === "image") addImageLink(asset.url);
   }
   const imageLinks = [...imageLinkSet];
   const canonNorm = (u) => {
@@ -5950,12 +6566,19 @@ function parsePageData(url, html, status, via, resp, fetchAttempts = []) {
     indexable = false;
     indexabilityReason = "canonicalised";
   }
-  const extractionSucceeded = bodyMarkdown.trim().length > 0;
+  const bodyClass = html.match(/<body\b[^>]*\bclass\s*=\s*["']([^"']*)["']/i)?.[1] ?? "";
+  const wordpressAttachment = /(?:^|\s)(?:attachment|attachment-template-default)(?:\s|$)/i.test(bodyClass);
+  const meaningfulText = mainText.replace(/https?:\/\/\S+/gi, " ").replace(/\s+/g, " ").trim();
+  const meaningfulWords = meaningfulText.match(/[\p{L}\p{N}][\p{L}\p{N}'’.-]*/gu) ?? [];
+  const hasMeaningfulText = meaningfulText.length >= 24 && meaningfulWords.length >= 4;
+  const extractionSucceeded = !wordpressAttachment && bodyMarkdown.trim().length > 0 && hasMeaningfulText;
+  const failureCode = wordpressAttachment ? "wordpress_attachment_page" : bodyMarkdown.trim().length === 0 ? "empty_rendered_content" : "insufficient_text_content";
+  const failureReason = wordpressAttachment ? "The HTML is a WordPress media attachment page, not a text-content page." : bodyMarkdown.trim().length === 0 ? "The HTML response produced no usable page content." : `The main content contained only ${meaningfulWords.length} word(s) and ${meaningfulText.length} text character(s).`;
   if (!extractionSucceeded) {
     indexable = false;
     indexabilityReason = "extraction-failed";
   }
-  const normalizedAttempts = extractionSucceeded ? fetchAttempts : fetchAttempts.map((attempt, index) => index === fetchAttempts.length - 1 && attempt.ok ? { ...attempt, ok: false, errorCode: "empty_rendered_content", error: "The HTML response produced no usable page content." } : attempt);
+  const normalizedAttempts = extractionSucceeded ? fetchAttempts : fetchAttempts.map((attempt, index) => index === fetchAttempts.length - 1 && attempt.ok ? { ...attempt, ok: false, errorCode: failureCode, error: failureReason } : attempt);
   return {
     url,
     status,
@@ -6002,9 +6625,12 @@ function parsePageData(url, html, status, via, resp, fetchAttempts = []) {
     discoveryLinks,
     bodyMarkdown,
     schema,
+    contentKind: extractionSucceeded ? "text_page" : "insufficient_text",
+    mainTextChars: meaningfulText.length,
+    mainWordCount: meaningfulWords.length,
     extractionStatus: extractionSucceeded ? "successful" : "failed",
-    failureCode: extractionSucceeded ? null : "empty_rendered_content",
-    failureReason: extractionSucceeded ? null : "The HTML response produced no usable page content.",
+    failureCode: extractionSucceeded ? null : failureCode,
+    failureReason: extractionSucceeded ? null : failureReason,
     fetchAttempts: normalizedAttempts,
     truncatedFields: [...truncatedFields]
   };
@@ -6092,6 +6718,7 @@ async function fetchPagePlain(url) {
         const attempt3 = failedAttempt("fetch", res.status, responseTimeMs2, "non_html_response", `Plain fetch returned ${contentType}, not HTML.`);
         const page = emptyPageData(url, res.status, "fetch", { code: attempt3.errorCode, message: attempt3.error, attempts: [attempt3] });
         page.contentType = contentType;
+        page.contentKind = "non_html";
         return page;
       }
       const html = await readResponseTextWithLimit(res, MAX_PAGE_HTML_BYTES, "Page HTML");
@@ -6134,9 +6761,24 @@ async function mapWithConcurrency(items, concurrency, fn) {
 }
 async function extractPagesRotating(urls, opts) {
   const uniqueUrls = [...new Set(urls)];
-  const plainPages = await mapWithConcurrency(uniqueUrls, opts.concurrency ?? EXTRACT_CONCURRENCY, fetchPagePlain);
+  const plainPages = await mapWithConcurrency(uniqueUrls, opts.concurrency ?? EXTRACT_CONCURRENCY, async (url) => {
+    const checked = await validatePublicHttpUrl(url, { field: "page URL" });
+    if (checked.error || !checked.parsed) return fetchPagePlain(url);
+    if (normalizeUrl(checked.parsed.href, checked.parsed.href)) return fetchPagePlain(url);
+    const attempt = failedAttempt("fetch", null, 0, "non_page_url", "The URL points to an asset, feed, API, account route, or other non-page path excluded from text-page extraction.");
+    const page = emptyPageData(url, null, "fetch", { code: attempt.errorCode, message: attempt.error, attempts: [attempt] });
+    page.contentKind = "excluded_url";
+    return page;
+  });
   const byUrl = new Map(plainPages.map((page) => [page.url, page]));
-  const browserTargets = plainPages.filter((page) => !isPageExtractionSuccessful(page) && !["unsafe_url", "unsafe_redirect", "cross_site_redirect"].includes(page.failureCode ?? "")).map((page) => page.url);
+  const browserTargets = plainPages.filter((page) => !isPageExtractionSuccessful(page) && ![
+    "unsafe_url",
+    "unsafe_redirect",
+    "cross_site_redirect",
+    "non_html_response",
+    "non_page_url",
+    "wordpress_attachment_page"
+  ].includes(page.failureCode ?? "")).map((page) => page.url);
   if (opts.kernelApiKey && browserTargets.length > 0) {
     const fetched = await crawlWithRotation(browserTargets, {
       apiKey: opts.kernelApiKey,
@@ -8740,7 +9382,7 @@ var siteExtractFn = inngest.createFunction(
       });
     }) : null;
     const finalized = await step.run("finalize", async () => {
-      const { assembleExtractArtifacts } = await import("./extract-bundle-RCTNANCH.js");
+      const { assembleExtractArtifacts } = await import("./extract-bundle-GUEUCTAE.js");
       const current = await getExtractJob(jobId2);
       if (!current) throw new Error("extract job disappeared before finalization");
       const stored = await assembleExtractArtifacts(current, { branding, imageAudit });
@@ -10071,8 +10713,8 @@ async function saveDirectoryCsvLocal(result) {
   const outDir = join3(outputBaseDir(), "directory-workflows");
   await mkdir(outDir, { recursive: true });
   const stamp = result.extractedAt.replace(/[:.]/g, "-");
-  const slug2 = `${result.state}-${result.query}`.toLowerCase().replace(/[^a-z0-9]+/g, "-").replace(/^-+|-+$/g, "").slice(0, 80);
-  const path5 = join3(outDir, `${stamp}-${slug2}-directory-workflow.csv`);
+  const slug4 = `${result.state}-${result.query}`.toLowerCase().replace(/[^a-z0-9]+/g, "-").replace(/^-+|-+$/g, "").slice(0, 80);
+  const path5 = join3(outDir, `${stamp}-${slug4}-directory-workflow.csv`);
   await writeFile(path5, renderDirectoryWorkflowCsv(result), "utf8");
   return path5;
 }
@@ -12214,9 +12856,9 @@ async function listAllPublicLocalSourcebook(category) {
   }) : await getDb().execute(`SELECT r.payload_json FROM local_sourcebook_submissions s JOIN local_sourcebook_revisions r ON r.submission_id = s.id AND r.revision = s.published_revision WHERE s.published_revision IS NOT NULL AND s.status NOT IN ('unpublished', 'rejected') ORDER BY s.category, s.state, s.business_name`);
   return result.rows.map((row) => parseJson2(row.payload_json));
 }
-async function getPublicLocalSourcebook(category, state, slug2) {
+async function getPublicLocalSourcebook(category, state, slug4) {
   await ensureLocalSourcebookSchema();
-  const result = await getDb().execute({ sql: `SELECT r.payload_json FROM local_sourcebook_submissions s JOIN local_sourcebook_revisions r ON r.submission_id = s.id AND r.revision = s.published_revision WHERE s.category = ? AND s.state = ? AND s.slug = ? AND s.published_revision IS NOT NULL AND s.status NOT IN ('unpublished', 'rejected') LIMIT 1`, args: [category, state, slug2] });
+  const result = await getDb().execute({ sql: `SELECT r.payload_json FROM local_sourcebook_submissions s JOIN local_sourcebook_revisions r ON r.submission_id = s.id AND r.revision = s.published_revision WHERE s.category = ? AND s.state = ? AND s.slug = ? AND s.published_revision IS NOT NULL AND s.status NOT IN ('unpublished', 'rejected') LIMIT 1`, args: [category, state, slug4] });
   return result.rows[0] ? parseJson2(result.rows[0].payload_json) : null;
 }
 
@@ -12520,6 +13162,235 @@ var MapsReviewCollector = class {
   }
 };
 
+// src/extractor/MapsImageCollector.ts
+var QUIESCENCE_MS = 700;
+var STABLE_CHECKS_REQUIRED2 = 3;
+var MAX_SCROLL_ROUNDS2 = 80;
+var OWNER_DISCOVERY_LIMIT = 500;
+function mapsImageIdentity(rawUrl) {
+  try {
+    const url = new URL(rawUrl);
+    const path5 = url.hostname.toLowerCase().endsWith("googleusercontent.com") ? url.pathname.replace(/=[^/]+$/, "") : url.pathname;
+    return `${url.hostname.toLowerCase()}${path5}`;
+  } catch {
+    return rawUrl.split("=")[0] ?? rawUrl;
+  }
+}
+function isMapsPhotoUrl(rawUrl) {
+  try {
+    const host2 = new URL(rawUrl).hostname.toLowerCase().replace(/\.$/, "");
+    return host2 === "googleusercontent.com" || host2.endsWith(".googleusercontent.com") || host2 === "streetviewpixels-pa.googleapis.com";
+  } catch {
+    return false;
+  }
+}
+async function openPhotoGallery(page) {
+  const seePhotos = page.getByRole("button", { name: /^see photos$/i }).first();
+  const exact = await seePhotos.count() > 0 ? seePhotos : page.locator('[aria-label^="See photos" i], button[aria-label^="Photo of" i]').first();
+  if (await exact.count() === 0) {
+    return false;
+  }
+  const clicked = await exact.click({ timeout: 5e3 }).then(() => true, () => false);
+  if (!clicked) return false;
+  const galleryControl = page.locator('button[aria-label="By owner" i], [role="tab"][aria-label*="owner" i]').first();
+  await galleryControl.waitFor({ state: "visible", timeout: 5e3 }).catch(() => void 0);
+  return galleryControl.isVisible().catch(() => false);
+}
+async function selectGalleryTab(page, scope) {
+  const matcher = scope === "owner" ? /by owner/i : /^all(?:\s|$)/i;
+  const direct = page.locator(scope === "owner" ? 'button[aria-label="By owner" i]' : 'button[aria-label="All" i]');
+  const roleTab = page.getByRole("tab", { name: matcher });
+  const tabs = await direct.count() > 0 ? direct : roleTab;
+  if (await tabs.count() === 0) return false;
+  const visible = tabs.filter({ visible: true }).first();
+  if (await visible.count() === 0) return false;
+  const clicked = await visible.click({ timeout: 5e3 }).then(() => true, () => false);
+  if (!clicked) return false;
+  await page.waitForTimeout(QUIESCENCE_MS);
+  return true;
+}
+async function readAndAdvanceGallery(page) {
+  return page.evaluate(() => {
+    const mediaNodes = Array.from(document.querySelectorAll('[aria-label^="Photo " i], [aria-label^="Video " i]'));
+    const imageUrl = (root) => {
+      const candidates = [root, ...Array.from(root.querySelectorAll("*"))];
+      for (const node of candidates) {
+        if (node instanceof HTMLImageElement) {
+          const value = node.currentSrc || node.src;
+          if (value) return value;
+        }
+        const inline = node.style.backgroundImage;
+        const computed = inline || window.getComputedStyle(node).backgroundImage;
+        const match = computed?.match(/url\(["']?(.+?)["']?\)/i);
+        if (match?.[1]) return match[1];
+      }
+      return null;
+    };
+    const items = mediaNodes.map((node) => {
+      const label = node.getAttribute("aria-label") ?? "";
+      const match = label.match(/^(Photo|Video)\s+(\d+)/i);
+      return {
+        kind: match?.[1]?.toLowerCase() === "video" ? "video" : "photo",
+        position: match?.[2] ? Number(match[2]) : null,
+        url: imageUrl(node)
+      };
+    });
+    const first = mediaNodes[0] ?? null;
+    const ancestors = [];
+    let current = first?.parentElement ?? null;
+    while (current) {
+      if (current.scrollHeight > current.clientHeight + 40) ancestors.push(current);
+      current = current.parentElement;
+    }
+    const fallback = Array.from(document.querySelectorAll("div")).filter((node) => {
+      const style = window.getComputedStyle(node);
+      return /(auto|scroll)/.test(style.overflowY) && node.scrollHeight > node.clientHeight + 40 && mediaNodes.some((media) => node.contains(media));
+    });
+    const preferred = Array.from(document.querySelectorAll("div.m6QErb.DxyBCb.kA9KIf.dS8AEf")).find((node) => mediaNodes.some((media) => node.contains(media)) && node.scrollHeight > node.clientHeight + 40);
+    const scroller = preferred ?? [...ancestors, ...fallback].sort((a, b) => b.scrollHeight - a.scrollHeight)[0] ?? null;
+    const atBottom = scroller ? scroller.scrollTop + scroller.clientHeight >= scroller.scrollHeight - 5 : true;
+    const metrics = {
+      scrollHeight: scroller?.scrollHeight ?? 0,
+      scrollTop: scroller?.scrollTop ?? 0,
+      clientHeight: scroller?.clientHeight ?? 0,
+      atBottom
+    };
+    if (scroller && !atBottom) {
+      scroller.scrollTop = Math.min(
+        scroller.scrollHeight - scroller.clientHeight,
+        scroller.scrollTop + Math.max(1200, Math.floor(scroller.clientHeight * 1.75))
+      );
+    }
+    return { items, ...metrics };
+  });
+}
+async function collectGalleryPass(page, limit) {
+  const photos = /* @__PURE__ */ new Map();
+  const videos = /* @__PURE__ */ new Set();
+  let stableChecks = 0;
+  let previousHeight = -1;
+  let rounds = 0;
+  while (rounds < MAX_SCROLL_ROUNDS2) {
+    rounds += 1;
+    const before = photos.size + videos.size;
+    const snapshot = await readAndAdvanceGallery(page);
+    for (const item of snapshot.items) {
+      if (item.kind === "video") {
+        videos.add(item.url ? mapsImageIdentity(item.url) : `position:${item.position ?? videos.size}`);
+        continue;
+      }
+      if (!item.url || !isMapsPhotoUrl(item.url)) continue;
+      const key = mapsImageIdentity(item.url);
+      const existing = photos.get(key);
+      if (!existing || (item.position ?? Infinity) < (existing.position ?? Infinity)) photos.set(key, item);
+    }
+    if (photos.size >= limit) {
+      return {
+        items: [...photos.values()].slice(0, limit),
+        exhausted: false,
+        stopReason: "limit_reached",
+        photosDiscovered: photos.size
+      };
+    }
+    await page.waitForTimeout(QUIESCENCE_MS);
+    const unchanged = snapshot.atBottom && before === photos.size + videos.size && previousHeight === snapshot.scrollHeight;
+    stableChecks = unchanged ? stableChecks + 1 : 0;
+    previousHeight = snapshot.scrollHeight;
+    if (stableChecks >= STABLE_CHECKS_REQUIRED2) {
+      return {
+        items: [...photos.values()],
+        exhausted: true,
+        stopReason: "gallery_exhausted",
+        photosDiscovered: photos.size
+      };
+    }
+  }
+  return {
+    items: [...photos.values()],
+    exhausted: false,
+    stopReason: "scroll_round_limit",
+    photosDiscovered: photos.size
+  };
+}
+var MapsImageCollector = class {
+  constructor(page) {
+    this.page = page;
+  }
+  page;
+  async collect(scope, maxImages) {
+    if (!await openPhotoGallery(this.page)) {
+      return {
+        images: [],
+        scope,
+        exhausted: false,
+        stopReason: "gallery_unavailable",
+        ownerGalleryAvailable: false,
+        ownerGalleryExhausted: false,
+        ownerPhotosDiscovered: 0,
+        allPhotosDiscovered: 0
+      };
+    }
+    const ownerGalleryAvailable = await selectGalleryTab(this.page, "owner");
+    const ownerPass = ownerGalleryAvailable ? await collectGalleryPass(this.page, scope === "owner" ? maxImages : OWNER_DISCOVERY_LIMIT) : { items: [], exhausted: false, stopReason: "gallery_unavailable", photosDiscovered: 0 };
+    const ownerKeys = new Set(ownerPass.items.flatMap((item) => item.url ? [mapsImageIdentity(item.url)] : []));
+    if (scope === "owner") {
+      return {
+        images: ownerPass.items.flatMap((item, index) => item.url ? [{
+          index: index + 1,
+          galleryPosition: item.position,
+          sourceUrl: item.url,
+          mediaKey: mapsImageIdentity(item.url),
+          origin: "owner",
+          originConfidence: "owner_gallery"
+        }] : []),
+        scope,
+        exhausted: ownerPass.exhausted,
+        stopReason: ownerGalleryAvailable ? ownerPass.stopReason : "gallery_unavailable",
+        ownerGalleryAvailable,
+        ownerGalleryExhausted: ownerPass.exhausted,
+        ownerPhotosDiscovered: ownerPass.photosDiscovered,
+        allPhotosDiscovered: ownerPass.photosDiscovered
+      };
+    }
+    if (!await selectGalleryTab(this.page, "all")) {
+      return {
+        images: [],
+        scope,
+        exhausted: false,
+        stopReason: "gallery_unavailable",
+        ownerGalleryAvailable,
+        ownerGalleryExhausted: ownerPass.exhausted,
+        ownerPhotosDiscovered: ownerPass.photosDiscovered,
+        allPhotosDiscovered: 0
+      };
+    }
+    const allPass = await collectGalleryPass(this.page, maxImages);
+    const images = allPass.items.flatMap((item, index) => {
+      if (!item.url) return [];
+      const mediaKey = mapsImageIdentity(item.url);
+      const isOwner = ownerKeys.has(mediaKey);
+      return [{
+        index: index + 1,
+        galleryPosition: item.position,
+        sourceUrl: item.url,
+        mediaKey,
+        origin: isOwner ? "owner" : ownerPass.exhausted ? "other" : "unknown",
+        originConfidence: isOwner ? "owner_gallery_match" : ownerPass.exhausted ? "not_in_exhausted_owner_gallery" : "owner_gallery_incomplete"
+      }];
+    });
+    return {
+      images,
+      scope,
+      exhausted: allPass.exhausted,
+      stopReason: allPass.stopReason,
+      ownerGalleryAvailable,
+      ownerGalleryExhausted: ownerPass.exhausted,
+      ownerPhotosDiscovered: ownerPass.photosDiscovered,
+      allPhotosDiscovered: allPass.photosDiscovered
+    };
+  }
+};
+
 // src/extractor/MapsExtractor.ts
 import { z as z11 } from "zod";
 var MapsExtractor = class {
@@ -12544,6 +13415,48 @@ var MapsExtractor = class {
       const identifiers = this.parseUrlIdentifiers(placeUrl);
       const overview = await this.extractOverview(page);
       const hoursTable = await this.extractFullHours(page);
+      let media = {
+        status: "not_requested",
+        scope: options.imageScope,
+        requestedMaxImages: options.maxImages,
+        images: [],
+        imagesCollected: 0,
+        imagesDownloaded: 0,
+        ownerImagesCollected: 0,
+        otherImagesCollected: 0,
+        unknownOriginImagesCollected: 0,
+        ownerGalleryAvailable: false,
+        ownerGalleryExhausted: false,
+        ownerPhotosDiscovered: 0,
+        allPhotosDiscovered: 0,
+        exhausted: false,
+        stopReason: "not_requested",
+        artifact: null,
+        warnings: []
+      };
+      if (options.includeImages) {
+        try {
+          await page.goto(placeUrl, { waitUntil: "domcontentloaded", timeout: 2e4 });
+          await page.waitForTimeout(500);
+          const collected = await new MapsImageCollector(page).collect(options.imageScope, options.maxImages);
+          const ownerImagesCollected = collected.images.filter((image) => image.origin === "owner").length;
+          const otherImagesCollected = collected.images.filter((image) => image.origin === "other").length;
+          const unknownOriginImagesCollected = collected.images.filter((image) => image.origin === "unknown").length;
+          media = {
+            ...media,
+            ...collected,
+            status: collected.images.length > 0 ? "collected" : collected.stopReason === "gallery_unavailable" ? "unavailable" : "none_exist",
+            imagesCollected: collected.images.length,
+            ownerImagesCollected,
+            otherImagesCollected,
+            unknownOriginImagesCollected
+          };
+          await page.goto(placeUrl, { waitUntil: "domcontentloaded", timeout: 2e4 }).catch(() => void 0);
+        } catch (err) {
+          console.warn("[MapsExtractor] image gallery extraction failed:", err instanceof Error ? err.message : String(err));
+          media = { ...media, status: "unavailable", stopReason: "gallery_unavailable", warnings: ["Google Maps image gallery could not be read in this run."] };
+        }
+      }
       let reviewStats = { reviewHistogram: [], reviewTopics: [] };
       let reviews = [];
       let reviewsStatus = "not_requested";
@@ -12631,6 +13544,7 @@ var MapsExtractor = class {
         services,
         areasServed,
         servicesStatus,
+        media,
         durationMs: Date.now() - startMs
       };
     } finally {
@@ -12913,11 +13827,11 @@ function rootDomain() {
   const configured = process.env.LOCAL_SOURCEBOOK_PUBLIC_ROOT_DOMAIN?.trim() || DEFAULT_ROOT_DOMAIN;
   return configured.replace(/^https?:\/\//i, "").replace(/^www\./i, "").replace(/\/.*$/, "").replace(/\.+$/, "").toLowerCase();
 }
-function localSourcebookPublicUrls(category, state, slug2) {
+function localSourcebookPublicUrls(category, state, slug4) {
   const categoryUrl = `https://${CATEGORY_PUBLIC_SLUGS[category]}.${rootDomain()}`;
   const statePath = `/${state.toLowerCase()}`;
-  const profilePath = `${statePath}/${slug2}/`;
-  const reviewsPath = `${statePath}/${slug2}/reviews`;
+  const profilePath = `${statePath}/${slug4}/`;
+  const reviewsPath = `${statePath}/${slug4}/reviews`;
   return {
     categoryUrl,
     nationwideDirectoryUrl: `${categoryUrl}/directory`,
@@ -13465,13 +14379,13 @@ function host(value) {
   }
 }
 function tokens(value) {
-  return new Set(value.toLowerCase().replace(/[^a-z0-9]+/g, " ").split(/\s+/).filter((token4) => token4.length > 1 && !BUSINESS_SUFFIXES.has(token4)));
+  return new Set(value.toLowerCase().replace(/[^a-z0-9]+/g, " ").split(/\s+/).filter((token6) => token6.length > 1 && !BUSINESS_SUFFIXES.has(token6)));
 }
 function nameOverlap(left, right) {
   const a = tokens(left);
   const b = tokens(right);
   if (!a.size || !b.size) return 0;
-  const intersection = [...a].filter((token4) => b.has(token4)).length;
+  const intersection = [...a].filter((token6) => b.has(token6)).length;
   return intersection / Math.max(a.size, b.size);
 }
 function validateLocalSourcebookMapsIdentity(submission, maps) {
@@ -13520,6 +14434,10 @@ function createDefaultLocalSourcebookProvider() {
         includeReviews: true,
         maxReviews,
         includeServices: true,
+        includeImages: false,
+        imageScope: "all",
+        maxImages: 100,
+        maxInlineImages: 3,
         kernelApiKey,
         headless: true
       });
@@ -14405,12 +15323,12 @@ function normalizeIdempotencyKey(value) {
 function tokenFor(id, idempotencyKey3) {
   return createHmac("sha256", billingSecret()).update(id).update(":").update(idempotencyKey3).digest("base64url");
 }
-function tokenHash(token4) {
-  return createHash4("sha256").update(token4).digest("hex");
+function tokenHash(token6) {
+  return createHash4("sha256").update(token6).digest("hex");
 }
-function verifyToken(row, token4) {
+function verifyToken(row, token6) {
   const expected = Buffer.from(row.token_hash, "hex");
-  const actual = Buffer.from(tokenHash(token4), "hex");
+  const actual = Buffer.from(tokenHash(token6), "hex");
   if (expected.length !== actual.length || !timingSafeEqual(expected, actual)) {
     throw new UnifiedBillingError("unauthorized", "invalid billing authorization token", 401);
   }
@@ -14527,11 +15445,11 @@ async function authorizeScheduledRun(args) {
     );
   }
   const id = randomUUID4();
-  const token4 = tokenFor(id, idempotencyKey3);
+  const token6 = tokenFor(id, idempotencyKey3);
   const expiresAt = new Date(Date.now() + AUTHORIZATION_TTL_MS).toISOString();
   const inserted = await getDb().execute({
     sql: "INSERT OR IGNORE INTO billing_authorizations (id, user_id, idempotency_key, billing_class, status, minimum_amount_mc, maximum_amount_mc, token_hash, metadata, expires_at) VALUES (?, ?, ?, ?, 'authorized', ?, ?, ?, ?, ?)",
-    args: [id, user.id, idempotencyKey3, SCHEDULED_RUN_BILLING_CLASS, SCHEDULED_RUN_BASE_MC, maximumMc, tokenHash(token4), safeMetadata2(args.metadata), expiresAt]
+    args: [id, user.id, idempotencyKey3, SCHEDULED_RUN_BILLING_CLASS, SCHEDULED_RUN_BASE_MC, maximumMc, tokenHash(token6), safeMetadata2(args.metadata), expiresAt]
   });
   if (inserted.rowsAffected === 0) {
     const raced = await getDb().execute({
@@ -14547,7 +15465,7 @@ async function authorizeScheduledRun(args) {
   }
   return {
     id,
-    token: token4,
+    token: token6,
     status: "authorized",
     minimumMc: SCHEDULED_RUN_BASE_MC,
     maximumMc,
@@ -16157,9 +17075,9 @@ var YouTubeExtractor = class {
   }
   async fetchContinuation(page, endpoint, contToken, context) {
     const result = await page.evaluate(
-      async ({ ep, token: token4, ctx }) => {
+      async ({ ep, token: token6, ctx }) => {
         const body = {
-          continuation: token4,
+          continuation: token6,
           context: {
             client: {
               clientName: ctx.clientName,
@@ -16403,23 +17321,23 @@ async function extractOnce(options) {
 }
 async function writeOutputs(result, outputDir) {
   await fs.mkdir(outputDir, { recursive: true });
-  const slug2 = result.target.toLowerCase().replace(/\W+/g, "-").slice(0, 40);
+  const slug4 = result.target.toLowerCase().replace(/\W+/g, "-").slice(0, 40);
   const ts = Date.now();
   await fs.writeFile(
-    path4.join(outputDir, `${slug2}-${ts}.json`),
+    path4.join(outputDir, `${slug4}-${ts}.json`),
     JSON.stringify(result, null, 2),
     "utf8"
   );
   if (result.videos.length > 0) {
     await fs.writeFile(
-      path4.join(outputDir, `${slug2}-videos-${ts}.csv`),
+      path4.join(outputDir, `${slug4}-videos-${ts}.csv`),
       Papa.unparse(result.videos, { header: true }),
       "utf8"
     );
   }
   if (result.downloads.length > 0) {
     await fs.writeFile(
-      path4.join(outputDir, `${slug2}-downloads-${ts}.csv`),
+      path4.join(outputDir, `${slug4}-downloads-${ts}.csv`),
       Papa.unparse(result.downloads, { header: true }),
       "utf8"
     );
@@ -16783,6 +17701,8 @@ var ExtractUrlBodyShape = {
   includeFeaturedImage: z16.boolean().optional(),
   downloadMedia: z16.boolean().optional(),
   mediaTypes: z16.array(z16.enum(["image", "video", "audio"])).optional(),
+  maxMediaAssets: z16.number().int().min(1).max(250).optional(),
+  maxInlineImages: z16.number().int().min(0).max(5).optional(),
   delivery: z16.enum(["auto", "inline", "artifact", "memory"]).optional(),
   preserveMedia: z16.boolean().optional(),
   depositToVault: z16.boolean().optional(),
@@ -18059,7 +18979,7 @@ function advertiserTokenOverlap(query, candidate) {
   const candidateTokens = new Set(normalizeAdvertiserName(candidate).split(" ").filter(Boolean));
   if (queryTokens.size === 0 || candidateTokens.size === 0) return 0;
   let overlap = 0;
-  for (const token4 of queryTokens) if (candidateTokens.has(token4)) overlap++;
+  for (const token6 of queryTokens) if (candidateTokens.has(token6)) overlap++;
   return overlap / queryTokens.size;
 }
 function assessPageIntelMatch(body, result) {
@@ -19294,8 +20214,8 @@ function getBlobStore() {
   return cached;
 }
 var VercelBlobStore = class {
-  constructor(token4) {
-    this.token = token4;
+  constructor(token6) {
+    this.token = token6;
   }
   token;
   kind = "vercel-blob";
@@ -19751,8 +20671,8 @@ function safeFilePart(input) {
 }
 function blobKeyPrefix(shortcode, sourceUrl) {
   const stamp = (/* @__PURE__ */ new Date()).toISOString().replace(/[:.]/g, "-").slice(0, 19);
-  const slug2 = shortcode ? `instagram-${shortcode}` : safeFilePart(sourceUrl);
-  return `instagram/${stamp}-${slug2}`;
+  const slug4 = shortcode ? `instagram-${shortcode}` : safeFilePart(sourceUrl);
+  return `instagram/${stamp}-${slug4}`;
 }
 async function fetchMediaBytes(url, referer, runtimeUserAgent) {
   const res = await fetch(url, {
@@ -20664,6 +21584,212 @@ videoApp.post("/status", createApiKeyAuth(), async (c) => {
 
 // src/api/maps-routes.ts
 import { Hono as Hono13 } from "hono";
+
+// src/api/maps-media-artifacts.ts
+import { homedir as homedir2 } from "os";
+import { join as join6 } from "path";
+import { randomBytes as randomBytes2 } from "crypto";
+import { ZipFile } from "yazl";
+import pLimit4 from "p-limit";
+var MAPS_MEDIA_ARTIFACT_PREFIX = "maps-media/";
+var MAPS_MEDIA_ARTIFACT_TTL_MS = 7 * 24 * 60 * 60 * 1e3;
+var MAPS_MEDIA_DOWNLOAD_TTL_MS = 15 * 60 * 1e3;
+var MAX_IMAGE_BYTES = 5 * 1024 * 1024;
+var MAX_ARCHIVE_IMAGE_BYTES = 40 * 1024 * 1024;
+var MAX_INLINE_IMAGE_BYTES = 15e5;
+var MAX_INLINE_TOTAL_BYTES = 25e5;
+var DOWNLOAD_CONCURRENCY = 6;
+var MAX_REDIRECTS = 4;
+function token() {
+  return process.env.MAPS_MEDIA_ARTIFACT_READ_WRITE_TOKEN?.trim() || process.env.PRIVATE_ARTIFACT_READ_WRITE_TOKEN?.trim() || process.env.CONNECTED_DATA_READ_WRITE_TOKEN?.trim() || process.env.CONNECTED_DATA_BLOB_READ_WRITE_TOKEN?.trim() || null;
+}
+function policy() {
+  return {
+    prefix: MAPS_MEDIA_ARTIFACT_PREFIX,
+    artifactTtlMs: MAPS_MEDIA_ARTIFACT_TTL_MS,
+    downloadTtlMs: MAPS_MEDIA_DOWNLOAD_TTL_MS,
+    token: token()
+  };
+}
+function allowedMapsImageUrl(raw) {
+  try {
+    const url = new URL(raw);
+    if (url.protocol !== "https:") return null;
+    const host2 = url.hostname.toLowerCase().replace(/\.$/, "");
+    if (host2 !== "googleusercontent.com" && !host2.endsWith(".googleusercontent.com") && host2 !== "streetviewpixels-pa.googleapis.com") return null;
+    return url;
+  } catch {
+    return null;
+  }
+}
+function preferredMapsImageRendition(rawUrl) {
+  const url = allowedMapsImageUrl(rawUrl);
+  if (!url) return rawUrl;
+  if (url.hostname.toLowerCase().endsWith("googleusercontent.com") && /=[^/]+$/.test(url.pathname)) {
+    url.pathname = url.pathname.replace(/=[^/]+$/, "=s2048");
+  }
+  return url.href;
+}
+function imageMime(bytes) {
+  if (bytes.length >= 3 && bytes[0] === 255 && bytes[1] === 216 && bytes[2] === 255) return { mimeType: "image/jpeg", extension: "jpg" };
+  if (bytes.length >= 8 && bytes[0] === 137 && bytes[1] === 80 && bytes[2] === 78 && bytes[3] === 71) return { mimeType: "image/png", extension: "png" };
+  if (bytes.length >= 12 && String.fromCharCode(...bytes.slice(0, 4)) === "RIFF" && String.fromCharCode(...bytes.slice(8, 12)) === "WEBP") return { mimeType: "image/webp", extension: "webp" };
+  if (bytes.length >= 6 && ["GIF87a", "GIF89a"].includes(String.fromCharCode(...bytes.slice(0, 6)))) return { mimeType: "image/gif", extension: "gif" };
+  return null;
+}
+async function readBounded(response) {
+  const declared = Number(response.headers.get("content-length") ?? "");
+  if (Number.isFinite(declared) && declared > MAX_IMAGE_BYTES) throw new Error("image_too_large");
+  if (!response.body) {
+    const bytes2 = new Uint8Array(await response.arrayBuffer());
+    if (bytes2.byteLength > MAX_IMAGE_BYTES) throw new Error("image_too_large");
+    return bytes2;
+  }
+  const reader = response.body.getReader();
+  const chunks = [];
+  let total = 0;
+  try {
+    while (true) {
+      const { done, value } = await reader.read();
+      if (done) break;
+      if (!value) continue;
+      total += value.byteLength;
+      if (total > MAX_IMAGE_BYTES) throw new Error("image_too_large");
+      chunks.push(value);
+    }
+  } finally {
+    reader.releaseLock();
+  }
+  const bytes = new Uint8Array(total);
+  let offset = 0;
+  for (const chunk of chunks) {
+    bytes.set(chunk, offset);
+    offset += chunk.byteLength;
+  }
+  return bytes;
+}
+async function fetchMapsImage(rawUrl) {
+  let url = allowedMapsImageUrl(preferredMapsImageRendition(rawUrl));
+  if (!url) throw new Error("image_host_not_allowed");
+  for (let redirect = 0; redirect <= MAX_REDIRECTS; redirect += 1) {
+    const checked = await validatePublicHttpUrl(url.href, { field: "Maps image URL" });
+    if (checked.error || !checked.parsed) throw new Error("image_url_rejected");
+    const response = await fetch(checked.parsed.href, {
+      redirect: "manual",
+      headers: { Accept: "image/jpeg,image/png,image/webp,image/gif;q=0.8" },
+      signal: AbortSignal.timeout(15e3)
+    });
+    if ([301, 302, 303, 307, 308].includes(response.status)) {
+      const location2 = response.headers.get("location");
+      if (!location2 || redirect === MAX_REDIRECTS) throw new Error("image_redirect_rejected");
+      url = allowedMapsImageUrl(new URL(location2, url).href);
+      if (!url) throw new Error("image_redirect_host_not_allowed");
+      continue;
+    }
+    if (!response.ok) throw new Error(`image_fetch_${response.status}`);
+    const body = await readBounded(response);
+    const detected = imageMime(body);
+    if (!detected) throw new Error("image_content_invalid");
+    return { bytes: Buffer.from(body), ...detected, finalUrl: url.href };
+  }
+  throw new Error("image_redirect_rejected");
+}
+function zipBuffer(files) {
+  return new Promise((resolve2, reject) => {
+    const zip = new ZipFile();
+    const chunks = [];
+    zip.outputStream.on("data", (chunk) => chunks.push(Buffer.from(chunk)));
+    zip.outputStream.once("error", reject);
+    zip.outputStream.once("end", () => resolve2(Buffer.concat(chunks)));
+    for (const file of files) zip.addBuffer(file.content, file.path);
+    zip.end();
+  });
+}
+function slug(value) {
+  return value.toLowerCase().replace(/[^a-z0-9]+/g, "-").replace(/^-+|-+$/g, "").slice(0, 70) || "google-maps-place";
+}
+function mapsMediaArtifactOwnerId(artifactId) {
+  return privateArtifactOwnerId(artifactId, MAPS_MEDIA_ARTIFACT_PREFIX);
+}
+async function readOwnedMapsMediaArtifactBuffer(args) {
+  if (mapsMediaArtifactOwnerId(args.artifactId) !== args.ownerId) return null;
+  return readPrivateArtifactBuffer({ policy: policy(), artifactId: args.artifactId, maxBytes: 50 * 1024 * 1024 });
+}
+async function packageMapsMedia(args) {
+  const limit = pLimit4(DOWNLOAD_CONCURRENCY);
+  const files = [];
+  let storedBytes = 0;
+  let inlineBytes = 0;
+  let inlineCount = 0;
+  await Promise.all(args.media.images.map((image) => limit(async () => {
+    try {
+      const fetched = await fetchMapsImage(image.sourceUrl);
+      if (storedBytes + fetched.bytes.length > MAX_ARCHIVE_IMAGE_BYTES) throw new Error("archive_byte_limit_reached");
+      storedBytes += fetched.bytes.length;
+      const filename = `images/${String(image.index).padStart(4, "0")}-${image.origin}.${fetched.extension}`;
+      files.push({ path: filename, content: fetched.bytes });
+      image.sourceUrl = fetched.finalUrl;
+      image.filename = filename;
+      image.mimeType = fetched.mimeType;
+      image.bytes = fetched.bytes.length;
+      image.downloadStatus = "downloaded";
+      image.downloadError = null;
+      if (inlineCount < args.maxInlineImages && fetched.bytes.length <= MAX_INLINE_IMAGE_BYTES && inlineBytes + fetched.bytes.length <= MAX_INLINE_TOTAL_BYTES) {
+        image.inlinePreview = { data: fetched.bytes.toString("base64"), mimeType: fetched.mimeType };
+        inlineBytes += fetched.bytes.length;
+        inlineCount += 1;
+      }
+    } catch (error) {
+      image.filename = null;
+      image.mimeType = null;
+      image.bytes = null;
+      image.downloadStatus = "failed";
+      image.downloadError = error instanceof Error ? error.message : "image_download_failed";
+      image.inlinePreview = null;
+    }
+  })));
+  args.media.imagesDownloaded = args.media.images.filter((image) => image.downloadStatus === "downloaded").length;
+  const failed = args.media.images.length - args.media.imagesDownloaded;
+  if (failed > 0) args.media.warnings.push(`${failed} image(s) could not be downloaded; their manifest rows include a bounded error code.`);
+  if (args.media.imagesDownloaded === 0) return { media: args.media, artifact: null };
+  const cleanImages = args.media.images.map(({ inlinePreview: _preview, ...image }) => image);
+  const summary = {
+    businessName: args.businessName,
+    placeUrl: args.placeUrl,
+    extractedAt: args.extractedAt,
+    scope: args.media.scope,
+    imagesCollected: args.media.imagesCollected,
+    imagesDownloaded: args.media.imagesDownloaded,
+    ownerImagesCollected: args.media.ownerImagesCollected,
+    otherImagesCollected: args.media.otherImagesCollected,
+    unknownOriginImagesCollected: args.media.unknownOriginImagesCollected,
+    ownerGalleryExhausted: args.media.ownerGalleryExhausted,
+    galleryExhausted: args.media.exhausted,
+    stopReason: args.media.stopReason,
+    notes: [
+      "origin=owner is backed by the Google Maps By owner gallery or an exact media-key match to it.",
+      "origin=other means absent from an exhausted owner gallery; it can include customer, review, Street View, Google, or unattributed media.",
+      "Google-hosted photo files use a bounded s2048 rendition when that CDN form is available; each file is still subject to byte and signature validation."
+    ]
+  };
+  files.push({ path: "summary.json", content: Buffer.from(JSON.stringify(summary, null, 2)) });
+  files.push({ path: "images.jsonl", content: Buffer.from(cleanImages.map((image) => JSON.stringify(image)).join("\n") + "\n") });
+  const archive = await zipBuffer(files);
+  const id = randomBytes2(6).toString("hex");
+  const pointer = await createPrivateArtifact({
+    policy: policy(),
+    ownerId: args.ownerId,
+    artifactKey: `${id}.zip`,
+    createdAt: new Date(args.extractedAt),
+    filename: `${slug(args.businessName)}-maps-images.zip`,
+    contentType: "application/zip",
+    content: archive
+  });
+  const localPath = token() ? null : join6(process.env.MCP_SCRAPER_OUTPUT_DIR?.trim() || join6(homedir2(), "Downloads", "mcp-scraper"), "blobs", pointer.artifactId);
+  return { media: args.media, artifact: { ...pointer, localPath } };
+}
+
+// src/api/maps-routes.ts
 function mapsErrorResponse(c, err, errorCode) {
   const msg = err instanceof Error ? err.message : String(err);
   const rotationError = err instanceof MapsSearchRotationError ? err : null;
@@ -20782,6 +21908,30 @@ mapsApp.post("/place", createApiKeyAuth(), async (c) => {
         result.reviews = [];
       }
     }
+    if (parsed.data.includeImages && result.media?.images.length > 0) {
+      try {
+        const packaged = await packageMapsMedia({
+          ownerId: String(user.id),
+          businessName: result.name ?? parsed.data.businessName,
+          placeUrl: result.placeUrl,
+          extractedAt: result.extractedAt,
+          media: result.media,
+          maxInlineImages: parsed.data.maxInlineImages
+        });
+        result.media = packaged.media;
+        result.media.artifact = packaged.artifact;
+      } catch (error) {
+        console.warn("[maps/place] image artifact packaging failed:", error instanceof Error ? error.message : String(error));
+        result.media.warnings.push("The image manifest was collected, but the downloadable ZIP artifact could not be created.");
+      }
+    }
+    const logResult = result.media ? {
+      ...result,
+      media: {
+        ...result.media,
+        images: result.media.images.map(({ inlinePreview: _preview, ...image }) => image)
+      }
+    } : result;
     await logRequestEvent({
       userId: user.id,
       source: "maps_place",
@@ -20789,7 +21939,7 @@ mapsApp.post("/place", createApiKeyAuth(), async (c) => {
       query: `${parsed.data.businessName} ${parsed.data.location}`,
       location: parsed.data.location,
       resultCount: reviewCount,
-      result
+      result: logResult
     });
     return c.json(result);
   } catch (err) {
@@ -21729,7 +22879,7 @@ function getLocalSourcebookContract(category) {
 }
 async function prepareLocalSourcebookWrite(input) {
   const parsed = DirectoryIdentitySchema.parse(input);
-  const slug2 = parsed.slug ?? parsed.businessName.toLowerCase().replace(/[^a-z0-9]+/g, "-").replace(/^-|-$/g, "").slice(0, 100);
+  const slug4 = parsed.slug ?? parsed.businessName.toLowerCase().replace(/[^a-z0-9]+/g, "-").replace(/^-|-$/g, "").slice(0, 100);
   const categoryTag = CATEGORY_TAG[parsed.category];
   const candidates = [
     { tag: categoryTag, central: true, reusable: true },
@@ -21737,12 +22887,12 @@ async function prepareLocalSourcebookWrite(input) {
     ...parsed.tags.filter((tag) => tag !== categoryTag).map((tag) => ({ tag }))
   ];
   const tagResolutions = await resolveLocalSourcebookTags(candidates);
-  const publicUrls = localSourcebookPublicUrls(parsed.category, parsed.state, slug2);
+  const publicUrls = localSourcebookPublicUrls(parsed.category, parsed.state, slug4);
   const schemaOrgType = parsed.schemaOrgType ?? defaultLocalSourcebookSchemaType(parsed.category);
   return {
     ok: true,
-    route: { category: parsed.category, state: parsed.state, slug: slug2, ...publicUrls },
-    proposedWrite: { ...parsed, schemaOrgType, slug: slug2, tags: tagResolutions.filter((item) => item.action === "reuse").map((item) => item.tag) },
+    route: { category: parsed.category, state: parsed.state, slug: slug4, ...publicUrls },
+    proposedWrite: { ...parsed, schemaOrgType, slug: slug4, tags: tagResolutions.filter((item) => item.action === "reuse").map((item) => item.tag) },
     contract: getLocalSourcebookContract(parsed.category),
     tagResolutions,
     instructions: [
@@ -21807,7 +22957,7 @@ async function persistLocalSourcebookTags(submissionId, userId, tags, decisions
 }
 
 // src/api/local-sourcebook-routes.ts
-var slug = (value) => value.toLowerCase().trim().replace(/[^a-z0-9]+/g, "-").replace(/^-|-$/g, "").slice(0, 100);
+var slug2 = (value) => value.toLowerCase().trim().replace(/[^a-z0-9]+/g, "-").replace(/^-|-$/g, "").slice(0, 100);
 var SubmitSchema = z26.object({
   category: z26.enum(LOCAL_SOURCEBOOK_CATEGORIES),
   state: z26.string().trim().length(2).transform((value) => value.toLowerCase()),
@@ -21878,7 +23028,7 @@ localSourcebookApp.post("/capture", createApiKeyAuth(), async (c) => {
     if (!idempotencyKey3) {
       return c.json({ error: "idempotency_key_required", message: "A stable idempotencyKey is required for a new Local Sourcebook capture." }, 400);
     }
-    const listingSlug = identity.slug ?? slug(identity.businessName);
+    const listingSlug = identity.slug ?? slug2(identity.businessName);
     const publicUrls = localSourcebookPublicUrls(identity.category, identity.state, listingSlug);
     const charged = await chargeListingWrite({ surface: "local_sourcebook", kind: "create", userId: Number(user.id), idempotencyKey: idempotencyKey3 });
     if ("insufficient" in charged) return c.json(charged.insufficient, 402);
@@ -21929,7 +23079,7 @@ localSourcebookApp.post("/submissions", createApiKeyAuth(), async (c) => {
   if (!parsed.success) return c.json({ error: "invalid_submission", issues: parsed.error.issues }, 400);
   const input = parsed.data;
   if (!input.idempotencyKey) return c.json({ error: "idempotency_key_required", message: "A stable idempotencyKey is required for a new Local Sourcebook listing." }, 400);
-  const listingSlug = input.slug ?? slug(input.businessName);
+  const listingSlug = input.slug ?? slug2(input.businessName);
   const schemaOrgType = input.schemaOrgType ?? defaultLocalSourcebookSchemaType(input.category);
   const publicUrls = localSourcebookPublicUrls(input.category, input.state, listingSlug);
   let billing = null;
@@ -22986,7 +24136,7 @@ import { createHash as createHash8, randomUUID as randomUUID9 } from "crypto";
 
 // src/serp-intelligence/page-snapshot-extractor.ts
 import { createHash as createHash7 } from "crypto";
-import pLimit4 from "p-limit";
+import pLimit5 from "p-limit";
 var DEFAULT_TIMEOUT_MS = 15e3;
 var DEFAULT_MAX_CONCURRENCY = 2;
 var DEFAULT_MAX_CONTENT_CHARS = 25e4;
@@ -23267,7 +24417,7 @@ async function capturePageSnapshot(target, options = {}) {
 async function capturePageSnapshots(targets, options = {}) {
   const timeoutMs = normalizeTimeoutMs(options.timeoutMs);
   const maxConcurrency = normalizeMaxConcurrency(options.maxConcurrency);
-  const limit = pLimit4(maxConcurrency);
+  const limit = pLimit5(maxConcurrency);
   const pageSnapshotArtifacts = await Promise.all(
     targets.map((target) => limit(() => capturePageSnapshot(target, { ...options, timeoutMs })))
   );
@@ -24108,15 +25258,15 @@ var ALLOWED_IMAGE_TYPES = /* @__PURE__ */ new Map([
   ["image/webp", "webp"],
   ["image/gif", "gif"]
 ]);
-function token() {
+function token2() {
   return process.env.IMAGE_SOURCE_ARTIFACT_READ_WRITE_TOKEN?.trim() || process.env.PRIVATE_ARTIFACT_READ_WRITE_TOKEN?.trim() || process.env.CONNECTED_DATA_READ_WRITE_TOKEN?.trim() || process.env.CONNECTED_DATA_BLOB_READ_WRITE_TOKEN?.trim() || null;
 }
-function policy() {
+function policy2() {
   return {
     prefix: IMAGE_SOURCE_ARTIFACT_PREFIX,
     artifactTtlMs: IMAGE_SOURCE_ARTIFACT_TTL_MS,
     downloadTtlMs: IMAGE_SOURCE_DOWNLOAD_TTL_MS,
-    token: token()
+    token: token2()
   };
 }
 function imageSourceArtifactOwnerId(artifactId) {
@@ -24130,7 +25280,7 @@ async function createImageSourceArtifact(args) {
   }
   const id = randomUUID10().replaceAll("-", "");
   return createPrivateArtifact({
-    policy: policy(),
+    policy: policy2(),
     ownerId: args.ownerId,
     artifactKey: `${id}.${extension}`,
     createdAt: args.createdAt ?? /* @__PURE__ */ new Date(),
@@ -24142,7 +25292,7 @@ async function createImageSourceArtifact(args) {
 async function readOwnedImageSourceArtifact(args) {
   if (imageSourceArtifactOwnerId(args.artifactId) !== args.ownerId) return null;
   return readPrivateArtifactBuffer({
-    policy: policy(),
+    policy: policy2(),
     artifactId: args.artifactId,
     maxBytes: IMAGE_SOURCE_MAX_BYTES
   });
@@ -24728,8 +25878,8 @@ function protectedResourceMetadata() {
 function wwwAuthenticateValue() {
   return `Bearer resource_metadata="${oauthResourceBaseUrl()}/.well-known/oauth-protected-resource"`;
 }
-function isBearerJwt(token4) {
-  return !token4.startsWith("sk_") && token4.split(".").length === 3;
+function isBearerJwt(token6) {
+  return !token6.startsWith("sk_") && token6.split(".").length === 3;
 }
 var jwksSingleton = null;
 function getJwks() {
@@ -24737,8 +25887,8 @@ function getJwks() {
   jwksSingleton = createRemoteJWKSet(new URL(`${oauthIssuer()}/.well-known/jwks.json`));
   return jwksSingleton;
 }
-async function verifyScraperOAuthJwt(token4) {
-  const { payload } = await jwtVerify(token4, getJwks(), {
+async function verifyScraperOAuthJwt(token6) {
+  const { payload } = await jwtVerify(token6, getJwks(), {
     issuer: oauthIssuer(),
     audience: oauthResourceUrl()
   });
@@ -27461,7 +28611,7 @@ async function resolveUser3(customerId, emailFallback) {
 // src/api/oauth-routes.ts
 import { Hono as Hono24 } from "hono";
 import { getCookie, setCookie } from "hono/cookie";
-import { createHash as createHash9, randomBytes as randomBytes2, randomUUID as randomUUID13 } from "crypto";
+import { createHash as createHash9, randomBytes as randomBytes3, randomUUID as randomUUID13 } from "crypto";
 import { importPKCS8, exportJWK, SignJWT } from "jose";
 var ISSUER = "https://mcpscraper.dev";
 var RESOURCE = () => process.env.MCP_MEMORY_RESOURCE_URL ?? "https://memory.mcpscraper.dev/mcp";
@@ -27560,9 +28710,9 @@ function negotiateScope(requested, user, resource) {
   if (operator && !unique3.includes("memory.admin")) unique3.push("memory.admin");
   return unique3.join(" ");
 }
-async function sessionUser(token4) {
-  if (!token4) return null;
-  const userId = verifySession(token4);
+async function sessionUser(token6) {
+  if (!token6) return null;
+  const userId = verifySession(token6);
   if (!userId) return null;
   const user = await withOAuthDatabaseDeadline("session-user", getUserById(userId));
   return user ?? null;
@@ -27747,7 +28897,7 @@ oauthApp.post("/oauth/register", async (c) => {
     }
   }
   const clientName = typeof body.client_name === "string" ? body.client_name : null;
-  const clientId = `client_${randomBytes2(16).toString("hex")}`;
+  const clientId = `client_${randomBytes3(16).toString("hex")}`;
   await withOAuthDatabaseDeadline("register-client", registerClient(clientId, redirectUris, clientName));
   console.log("[oauth-dcr] register OK client_id=%s redirect_uris=%s", clientId, JSON.stringify(redirectUris));
   return c.json({
@@ -27822,7 +28972,7 @@ oauthApp.post("/oauth/authorize", async (c) => {
   if (action2 === "deny") return redirectWithError(p.redirect_uri, p.state, "access_denied");
   if (action2 !== "approve") return c.text("unsupported action", 400);
   const scope = negotiateScope(p.scope, user, p.resource);
-  const code = `code_${randomBytes2(32).toString("base64url")}`;
+  const code = `code_${randomBytes3(32).toString("base64url")}`;
   const expiresAt = new Date(Date.now() + CODE_TTL_SECONDS * 1e3).toISOString();
   await withOAuthDatabaseDeadline("put-authorization-code", putCode({
     code,
@@ -27873,7 +29023,7 @@ oauthApp.post("/oauth/token", async (c) => {
     const plan = user ? resolvePlan(user) : "free";
     const audience = record.resource ?? RESOURCE();
     const accessToken = await mintAccessToken(record.identity, record.scope, plan, audience);
-    const refreshToken = `rt_${randomBytes2(40).toString("base64url")}`;
+    const refreshToken = `rt_${randomBytes3(40).toString("base64url")}`;
     await withOAuthDatabaseDeadline("put-refresh-token", putRefresh({
       refresh_token: refreshToken,
       client_id: clientId,
@@ -27903,7 +29053,7 @@ oauthApp.post("/oauth/token", async (c) => {
     const plan = user ? resolvePlan(user) : "free";
     const audience = record.resource ?? RESOURCE();
     const accessToken = await mintAccessToken(record.identity, record.scope, plan, audience);
-    const nextRefresh = `rt_${randomBytes2(40).toString("base64url")}`;
+    const nextRefresh = `rt_${randomBytes3(40).toString("base64url")}`;
     await withOAuthDatabaseDeadline("rotate-refresh-token", rotateRefresh(refreshToken, {
       refresh_token: nextRefresh,
       client_id: record.client_id,
@@ -27921,35 +29071,35 @@ oauthApp.post("/oauth/token", async (c) => {
 // src/api/chat-routes.ts
 import { Hono as Hono25 } from "hono";
 var chatApp = new Hono25();
-function tokenOk(token4) {
-  return !!token4 && token4.startsWith("mk_") && token4.length > 10;
+function tokenOk(token6) {
+  return !!token6 && token6.startsWith("mk_") && token6.length > 10;
 }
 function jsonError(message, status = 400) {
   return new Response(JSON.stringify({ ok: false, error: message }), { status, headers: { "content-type": "application/json" } });
 }
 chatApp.get("/api/channels", async (c) => {
-  const token4 = c.req.query("token");
-  if (!tokenOk(token4)) return jsonError("missing or malformed token", 401);
-  const r = await memoryCall("listVaultsTool", {}, token4);
+  const token6 = c.req.query("token");
+  if (!tokenOk(token6)) return jsonError("missing or malformed token", 401);
+  const r = await memoryCall("listVaultsTool", {}, token6);
   if (!r.ok) return c.json(r);
   const vaults = (r.vaults ?? []).filter((v) => v.kind === "channel");
   return c.json({ ok: true, channels: vaults });
 });
 chatApp.get("/api/messages", async (c) => {
-  const token4 = c.req.query("token");
-  if (!tokenOk(token4)) return jsonError("missing or malformed token", 401);
+  const token6 = c.req.query("token");
+  if (!tokenOk(token6)) return jsonError("missing or malformed token", 401);
   const vault = c.req.query("vault");
   if (!vault) return jsonError("vault is required");
   const parentMessageId = c.req.query("parentMessageId") || void 0;
-  const r = await memoryCall("listChannelMessagesTool", { vault, parentMessageId }, token4);
+  const r = await memoryCall("listChannelMessagesTool", { vault, parentMessageId }, token6);
   return c.json(r);
 });
 chatApp.get("/api/poll", async (c) => {
-  const token4 = c.req.query("token");
-  if (!tokenOk(token4)) return jsonError("missing or malformed token", 401);
+  const token6 = c.req.query("token");
+  if (!tokenOk(token6)) return jsonError("missing or malformed token", 401);
   const vault = c.req.query("vault");
   if (!vault) return jsonError("vault is required");
-  const r = await memoryCall("pollChannelTool", { vault }, token4);
+  const r = await memoryCall("pollChannelTool", { vault }, token6);
   return c.json(r);
 });
 function parseAttachNote(v) {
@@ -27974,12 +29124,12 @@ chatApp.post("/api/reply", async (c) => {
   return c.json(r);
 });
 chatApp.get("/api/notes-own", async (c) => {
-  const token4 = c.req.query("token");
-  if (!tokenOk(token4)) return jsonError("missing or malformed token", 401);
-  const vaultsRes = await memoryCall("listVaultsTool", {}, token4);
+  const token6 = c.req.query("token");
+  if (!tokenOk(token6)) return jsonError("missing or malformed token", 401);
+  const vaultsRes = await memoryCall("listVaultsTool", {}, token6);
   if (!vaultsRes.ok) return c.json(vaultsRes);
   const ownVaults = (vaultsRes.vaults ?? []).filter((v) => v.role === "owner" && v.kind === "notes");
-  const lists = await Promise.all(ownVaults.map((v) => memoryCall("listTool", { vault: v.handle }, token4)));
+  const lists = await Promise.all(ownVaults.map((v) => memoryCall("listTool", { vault: v.handle }, token6)));
   const notes = ownVaults.flatMap((v, i) => {
     const r = lists[i];
     return r.ok ? (r.notes ?? []).map((n) => ({ vault: v.handle, path: n.path, title: n.title })) : [];
@@ -27987,12 +29137,12 @@ chatApp.get("/api/notes-own", async (c) => {
   return c.json({ ok: true, notes });
 });
 chatApp.get("/api/message-note", async (c) => {
-  const token4 = c.req.query("token");
-  if (!tokenOk(token4)) return jsonError("missing or malformed token", 401);
+  const token6 = c.req.query("token");
+  if (!tokenOk(token6)) return jsonError("missing or malformed token", 401);
   const vault = c.req.query("vault");
   const messageId = c.req.query("messageId");
   if (!vault || !messageId) return jsonError("vault and messageId are required");
-  const r = await memoryCall("getMessageNoteTool", { vault, messageId }, token4);
+  const r = await memoryCall("getMessageNoteTool", { vault, messageId }, token6);
   return c.json(r);
 });
 chatApp.post("/api/react", async (c) => {
@@ -28003,17 +29153,17 @@ chatApp.post("/api/react", async (c) => {
   return c.json(r);
 });
 chatApp.get("/api/mentions", async (c) => {
-  const token4 = c.req.query("token");
-  if (!tokenOk(token4)) return jsonError("missing or malformed token", 401);
-  const r = await memoryCall("myMentionsTool", {}, token4);
+  const token6 = c.req.query("token");
+  if (!tokenOk(token6)) return jsonError("missing or malformed token", 401);
+  const r = await memoryCall("myMentionsTool", {}, token6);
   return c.json(r);
 });
 chatApp.get("/api/members", async (c) => {
-  const token4 = c.req.query("token");
-  if (!tokenOk(token4)) return jsonError("missing or malformed token", 401);
+  const token6 = c.req.query("token");
+  if (!tokenOk(token6)) return jsonError("missing or malformed token", 401);
   const vault = c.req.query("vault");
   if (!vault) return jsonError("vault is required");
-  const r = await memoryCall("listChannelMembersTool", { vault }, token4);
+  const r = await memoryCall("listChannelMembersTool", { vault }, token6);
   return c.json(r);
 });
 chatApp.post("/api/channel", async (c) => {
@@ -28049,13 +29199,13 @@ chatApp.post("/api/member-remove", async (c) => {
   return c.json(r);
 });
 chatApp.get("/:token", (c) => {
-  const token4 = c.req.param("token");
-  if (!tokenOk(token4)) {
+  const token6 = c.req.param("token");
+  if (!tokenOk(token6)) {
     return c.html(`<!doctype html><html><body style="font-family:system-ui;padding:40px;color:#3D3548"><h2>This chat link isn't valid.</h2><p>Ask the AI to run get-chat-link again, or revoke-chat-link then get-chat-link if you think it was compromised.</p></body></html>`, 401);
   }
-  return c.html(renderChatPage(token4));
+  return c.html(renderChatPage(token6));
 });
-function renderChatPage(token4) {
+function renderChatPage(token6) {
   return `<!doctype html>
 <html>
 <head>
@@ -28240,7 +29390,7 @@ function renderChatPage(token4) {
 </div>
 
 <script>
-const TOKEN = ${JSON.stringify(token4)};
+const TOKEN = ${JSON.stringify(token6)};
 const state = { channels: [], activeVault: null, activeName: null, members: [], threadParent: null, pollTimer: null, pendingAttach: null, threadPendingAttach: null, ownNotes: null, pickerTarget: 'main' };
 
 function api(path, opts) {
@@ -28610,8 +29760,8 @@ var MAX_VAULT_RECORDS = 200;
 var MAX_MEMORY_READ_CONCURRENCY = 4;
 var MAX_MEMORY_READ_ATTEMPTS = 3;
 var vaultApp = new Hono26();
-function validToken(token4) {
-  return !!token4 && token4.startsWith("mk_") && token4.length > 20 && token4.length < 256;
+function validToken(token6) {
+  return !!token6 && token6.startsWith("mk_") && token6.length > 20 && token6.length < 256;
 }
 function isVault(value) {
   return typeof value === "string" && VAULTS.includes(value);
@@ -28737,11 +29887,11 @@ function shouldRetryMemoryRead(error) {
 function sleep(ms) {
   return new Promise((resolve2) => setTimeout(resolve2, ms));
 }
-async function readMemory(tool, args, token4) {
-  let result = await memoryCall(tool, args, token4);
+async function readMemory(tool, args, token6) {
+  let result = await memoryCall(tool, args, token6);
   for (let attempt = 1; !result.ok && attempt < MAX_MEMORY_READ_ATTEMPTS && shouldRetryMemoryRead(result.error); attempt += 1) {
     await sleep(attempt * 150);
-    result = await memoryCall(tool, args, token4);
+    result = await memoryCall(tool, args, token6);
   }
   return result;
 }
@@ -28758,27 +29908,27 @@ async function mapWithConcurrency3(items, limit, map) {
   await Promise.all(Array.from({ length: Math.min(limit, items.length) }, () => worker()));
   return values;
 }
-async function readVault(vault, token4) {
-  const list = await readMemory("listTool", { vault }, token4);
+async function readVault(vault, token6) {
+  const list = await readMemory("listTool", { vault }, token6);
   if (!list.ok) throw new Error(list.error ?? `unable to read ${vault}`);
   const noteRefs = (list.notes ?? []).slice(0, MAX_VAULT_RECORDS);
   const notes = await mapWithConcurrency3(
     noteRefs,
     MAX_MEMORY_READ_CONCURRENCY,
-    ({ path: path5 }) => readMemory("getTool", { vault, path: path5 }, token4)
+    ({ path: path5 }) => readMemory("getTool", { vault, path: path5 }, token6)
   );
   const failed = notes.find((result) => !result.ok);
   if (failed && !failed.ok) throw new Error(failed.error ?? `unable to read ${vault} record`);
   return notes.filter((result) => result.ok && !!result.note).map((result) => workspaceRecord(vault, result.note));
 }
 vaultApp.get("/api/workspace", async (c) => {
-  const token4 = c.req.query("token");
-  if (!validToken(token4)) return c.json({ ok: false, error: "missing or malformed Vault App link" }, 401);
+  const token6 = c.req.query("token");
+  if (!validToken(token6)) return c.json({ ok: false, error: "missing or malformed Vault App link" }, 401);
   try {
     const requested = c.req.query("vault");
     const vaults = isVault(requested) ? [requested] : VAULTS;
     const results = [];
-    for (const vault of vaults) results.push(await readVault(vault, token4));
+    for (const vault of vaults) results.push(await readVault(vault, token6));
     const records = results.flat().sort((a, b) => b.updatedAt.localeCompare(a.updatedAt));
     return c.json({ ok: true, records, limited: results.some((result) => result.length >= 200) });
   } catch (error) {
@@ -28787,8 +29937,8 @@ vaultApp.get("/api/workspace", async (c) => {
 });
 vaultApp.post("/api/records", async (c) => {
   const body = await c.req.json().catch(() => ({}));
-  const token4 = typeof body.token === "string" ? body.token : void 0;
-  if (!validToken(token4)) return c.json({ ok: false, error: "missing or malformed Vault App link" }, 401);
+  const token6 = typeof body.token === "string" ? body.token : void 0;
+  if (!validToken(token6)) return c.json({ ok: false, error: "missing or malformed Vault App link" }, 401);
   const vault = body.vault;
   const path5 = stringValue(body.path, 320);
   const title = stringValue(body.title, 320);
@@ -28799,19 +29949,19 @@ vaultApp.post("/api/records", async (c) => {
   const validationError2 = validateNewRecord(vault, normalizedProps);
   if (validationError2) return c.json({ ok: false, error: validationError2 }, 400);
   const baseRevision = typeof body.baseRevision === "number" && Number.isInteger(body.baseRevision) ? body.baseRevision : void 0;
-  const result = await memoryCall("putTool", { vault, path: path5, title, content: content || title, props: normalizedProps, ...baseRevision === void 0 ? {} : { baseRevision } }, token4);
+  const result = await memoryCall("putTool", { vault, path: path5, title, content: content || title, props: normalizedProps, ...baseRevision === void 0 ? {} : { baseRevision } }, token6);
   return c.json(result, result.ok ? 200 : result.conflict ? 409 : 502);
 });
 vaultApp.post("/api/records/transition", async (c) => {
   const body = await c.req.json().catch(() => ({}));
-  const token4 = typeof body.token === "string" ? body.token : void 0;
-  if (!validToken(token4)) return c.json({ ok: false, error: "missing or malformed Vault App link" }, 401);
+  const token6 = typeof body.token === "string" ? body.token : void 0;
+  if (!validToken(token6)) return c.json({ ok: false, error: "missing or malformed Vault App link" }, 401);
   const vault = typeof body.vault === "string" ? body.vault : "";
   const path5 = typeof body.path === "string" ? body.path : "";
   const status = stringValue(body.status, 80);
   const baseRevision = typeof body.baseRevision === "number" && Number.isInteger(body.baseRevision) ? body.baseRevision : void 0;
   if (!isVault(vault) || !path5 || !status) return c.json({ ok: false, error: "valid vault, path, and status are required" }, 400);
-  const current = await readMemory("getTool", { vault, path: path5 }, token4);
+  const current = await readMemory("getTool", { vault, path: path5 }, token6);
   if (!current.ok || !current.note) return c.json(current, current.ok ? 404 : 502);
   const result = await memoryCall("putTool", {
     vault,
@@ -28820,13 +29970,13 @@ vaultApp.post("/api/records/transition", async (c) => {
     content: current.note.content,
     props: { ...current.note.props ?? {}, status },
     baseRevision: baseRevision ?? current.note.revision
-  }, token4);
+  }, token6);
   return c.json(result, result.ok ? 200 : result.conflict ? 409 : 502);
 });
 vaultApp.post("/api/records/update", async (c) => {
   const body = await c.req.json().catch(() => ({}));
-  const token4 = typeof body.token === "string" ? body.token : void 0;
-  if (!validToken(token4)) return c.json({ ok: false, error: "missing or malformed Vault App link" }, 401);
+  const token6 = typeof body.token === "string" ? body.token : void 0;
+  if (!validToken(token6)) return c.json({ ok: false, error: "missing or malformed Vault App link" }, 401);
   const vault = body.vault;
   const path5 = stringValue(body.path, 320);
   const title = typeof body.title === "string" ? stringValue(body.title, 320) : void 0;
@@ -28836,7 +29986,7 @@ vaultApp.post("/api/records/update", async (c) => {
   if (!isVault(vault) || !path5 || body.title !== void 0 && !title || body.props !== void 0 && !props) {
     return c.json({ ok: false, error: "valid vault, path, and optional record fields are required" }, 400);
   }
-  const current = await readMemory("getTool", { vault, path: path5 }, token4);
+  const current = await readMemory("getTool", { vault, path: path5 }, token6);
   if (!current.ok || !current.note) return c.json(current, current.ok ? 404 : 502);
   const nextProps = normalizeRelationshipProps(vault, { ...current.note.props ?? {}, ...props ?? {} });
   const validationError2 = validateNewRecord(vault, nextProps);
@@ -28848,18 +29998,18 @@ vaultApp.post("/api/records/update", async (c) => {
     content: content ?? current.note.content,
     props: nextProps,
     baseRevision: baseRevision ?? current.note.revision
-  }, token4);
+  }, token6);
   return c.json(result, result.ok ? 200 : result.conflict ? 409 : 502);
 });
 vaultApp.delete("/api/records", async (c) => {
   const body = await c.req.json().catch(() => ({}));
-  const token4 = typeof body.token === "string" ? body.token : void 0;
-  if (!validToken(token4)) return c.json({ ok: false, error: "missing or malformed Vault App link" }, 401);
+  const token6 = typeof body.token === "string" ? body.token : void 0;
+  if (!validToken(token6)) return c.json({ ok: false, error: "missing or malformed Vault App link" }, 401);
   const vault = body.vault;
   const path5 = stringValue(body.path, 320);
   const baseRevision = typeof body.baseRevision === "number" && Number.isInteger(body.baseRevision) ? body.baseRevision : void 0;
   if (vault !== "Tasks" || !path5) return c.json({ ok: false, error: "only a valid task record can be deleted" }, 400);
-  const current = await readMemory("getTool", { vault, path: path5 }, token4);
+  const current = await readMemory("getTool", { vault, path: path5 }, token6);
   if (!current.ok || !current.note) return c.json(current, current.ok ? 404 : 502);
   if (!["task", "milestone"].includes(typeof current.note.props?.type === "string" ? current.note.props.type : defaultType("Tasks"))) {
     return c.json({ ok: false, error: "only task records can be deleted" }, 400);
@@ -28868,13 +30018,13 @@ vaultApp.delete("/api/records", async (c) => {
     vault,
     path: path5,
     baseRevision: baseRevision ?? current.note.revision
-  }, token4);
+  }, token6);
   return c.json(result, result.ok ? 200 : result.conflict ? 409 : 502);
 });
 vaultApp.post("/api/communications/review", async (c) => {
   const body = await c.req.json().catch(() => ({}));
-  const token4 = typeof body.token === "string" ? body.token : void 0;
-  if (!validToken(token4)) return c.json({ ok: false, error: "missing or malformed Vault App link" }, 401);
+  const token6 = typeof body.token === "string" ? body.token : void 0;
+  if (!validToken(token6)) return c.json({ ok: false, error: "missing or malformed Vault App link" }, 401);
   const path5 = stringValue(body.path, 320);
   const action2 = stringValue(body.action, 24);
   const title = typeof body.title === "string" ? stringValue(body.title, 320) : void 0;
@@ -28885,7 +30035,7 @@ vaultApp.post("/api/communications/review", async (c) => {
   if (!path5 || !normalizedAction || !["approve", "deny", "edit"].includes(normalizedAction) || body.title !== void 0 && !title) {
     return c.json({ ok: false, error: "valid path, action, and optional draft fields are required" }, 400);
   }
-  const current = await readMemory("getTool", { vault: "Communications", path: path5 }, token4);
+  const current = await readMemory("getTool", { vault: "Communications", path: path5 }, token6);
   if (!current.ok || !current.note) return c.json(current, current.ok ? 404 : 502);
   if (current.note.props?.type !== "email") return c.json({ ok: false, error: "only email communications can be reviewed" }, 400);
   const reviewed = normalizedAction === "approve" || normalizedAction === "deny";
@@ -28909,13 +30059,13 @@ vaultApp.post("/api/communications/review", async (c) => {
     content: content ?? current.note.content,
     props,
     baseRevision: baseRevision ?? current.note.revision
-  }, token4);
+  }, token6);
   return c.json(result, result.ok ? 200 : result.conflict ? 409 : 502);
 });
 vaultApp.post("/api/activity", async (c) => {
   const body = await c.req.json().catch(() => ({}));
-  const token4 = typeof body.token === "string" ? body.token : void 0;
-  if (!validToken(token4)) return c.json({ ok: false, error: "missing or malformed Vault App link" }, 401);
+  const token6 = typeof body.token === "string" ? body.token : void 0;
+  if (!validToken(token6)) return c.json({ ok: false, error: "missing or malformed Vault App link" }, 401);
   const title = stringValue(body.title, 320);
   const content = typeof body.content === "string" && body.content.length <= 2e4 ? body.content : "";
   const props = propsValue(body.props) ?? {};
@@ -28925,7 +30075,7 @@ vaultApp.post("/api/activity", async (c) => {
     return c.json({ ok: false, error: "Activities require at least one canonical People reference in person_refs" }, 400);
   }
   for (const ref of personRefs) {
-    const person = await readMemory("getTool", { vault: "People", path: ref.replace(/^People::/, "") }, token4);
+    const person = await readMemory("getTool", { vault: "People", path: ref.replace(/^People::/, "") }, token6);
     if (!person.ok || !person.note || !["person", "organization"].includes(String(person.note.props?.type ?? ""))) {
       return c.json({ ok: false, error: `Activity person reference is not a known People record: ${ref}` }, 400);
     }
@@ -28953,37 +30103,37 @@ vaultApp.post("/api/activity", async (c) => {
       ...props,
       person_refs: personRefs
     }
-  }, token4);
+  }, token6);
   return c.json(result, result.ok ? 200 : 502);
 });
 
 // src/api/schedule-routes.ts
 import { Hono as Hono27 } from "hono";
 var scheduleApp = new Hono27();
-function tokenOk2(token4) {
-  return !!token4 && token4.startsWith("mk_") && token4.length > 10;
+function tokenOk2(token6) {
+  return !!token6 && token6.startsWith("mk_") && token6.length > 10;
 }
 function jsonError2(message, status = 400) {
   return new Response(JSON.stringify({ ok: false, error: message }), { status, headers: { "content-type": "application/json" } });
 }
 scheduleApp.get("/api/status", async (c) => {
-  const token4 = c.req.query("token");
-  if (!tokenOk2(token4)) return jsonError2("missing or malformed token", 401);
-  const r = await memoryCall("getScheduleStatusTool", {}, token4);
+  const token6 = c.req.query("token");
+  if (!tokenOk2(token6)) return jsonError2("missing or malformed token", 401);
+  const r = await memoryCall("getScheduleStatusTool", {}, token6);
   return c.json(r);
 });
 scheduleApp.get("/api/vaults", async (c) => {
-  const token4 = c.req.query("token");
-  if (!tokenOk2(token4)) return jsonError2("missing or malformed token", 401);
-  const r = await memoryCall("listVaultsTool", {}, token4);
+  const token6 = c.req.query("token");
+  if (!tokenOk2(token6)) return jsonError2("missing or malformed token", 401);
+  const r = await memoryCall("listVaultsTool", {}, token6);
   if (!r.ok) return c.json(r);
   const vaults = (r.vaults ?? []).filter((v) => v.kind !== "channel");
   return c.json({ ok: true, vaults });
 });
 scheduleApp.get("/api/actions", async (c) => {
-  const token4 = c.req.query("token");
-  if (!tokenOk2(token4)) return jsonError2("missing or malformed token", 401);
-  const r = await memoryCall("listScheduledActionsTool", {}, token4);
+  const token6 = c.req.query("token");
+  if (!tokenOk2(token6)) return jsonError2("missing or malformed token", 401);
+  const r = await memoryCall("listScheduledActionsTool", {}, token6);
   return c.json(r);
 });
 scheduleApp.post("/api/propose", async (c) => {
@@ -29019,13 +30169,13 @@ scheduleApp.post("/api/actions/:id/delete", async (c) => {
   return c.json(r);
 });
 scheduleApp.get("/:token", (c) => {
-  const token4 = c.req.param("token");
-  if (!tokenOk2(token4)) {
+  const token6 = c.req.param("token");
+  if (!tokenOk2(token6)) {
     return c.html(`<!doctype html><html><body style="font-family:system-ui;padding:40px;color:#3D3548"><h2>This automations link isn't valid.</h2><p>Ask the AI to run get-schedule-link again, or revoke-schedule-link then get-schedule-link if you think it was compromised.</p></body></html>`, 401);
   }
-  return c.html(renderSchedulePage(token4));
+  return c.html(renderSchedulePage(token6));
 });
-function renderSchedulePage(token4) {
+function renderSchedulePage(token6) {
   return `<!doctype html>
 <html>
 <head>
@@ -29123,7 +30273,7 @@ function renderSchedulePage(token4) {
 </div>
 
 <script>
-const TOKEN = ${JSON.stringify(token4)};
+const TOKEN = ${JSON.stringify(token6)};
 const state = { actions: [], vaults: [] };
 
 function api(path, opts) { return fetch('/schedule' + path, opts).then(r => r.json()); }
@@ -29366,8 +30516,8 @@ function supportThreadToken(customerEmail, normalizedSubject) {
   return shortHash(`${customerEmail.trim().toLowerCase()}
 ${normalizeSupportSubject(normalizedSubject).toLowerCase()}`);
 }
-function supportThreadAddress(token4, receivingDomain) {
-  const safeToken = token4.toLowerCase().replace(/[^a-f0-9]/g, "").slice(0, 24);
+function supportThreadAddress(token6, receivingDomain) {
+  const safeToken = token6.toLowerCase().replace(/[^a-f0-9]/g, "").slice(0, 24);
   const domain = receivingDomain.trim().toLowerCase();
   if (!safeToken || !/^[a-z0-9.-]+\.[a-z]{2,}$/i.test(domain)) throw new Error("invalid support thread address");
   return `support+${safeToken}@${domain}`;
@@ -29394,8 +30544,8 @@ function personPath(identity) {
   const local = identity.email.split("@")[0];
   return `contacts/${safePathPart(identity.name === identity.email ? local : identity.name)}-${shortHash(identity.email, 12)}`;
 }
-function issuePath(token4) {
-  return `support/threads/${token4}`;
+function issuePath(token6) {
+  return `support/threads/${token6}`;
 }
 function communicationPath(email) {
   const date = cleanLine(email.created_at, (/* @__PURE__ */ new Date()).toISOString()).slice(0, 10).replace(/[^0-9-]/g, "");
@@ -29579,8 +30729,8 @@ function buildIssueContent(email, customer, personPathValue, threadAddressValue)
     `- Person: ${noteRef("People", personPathValue)}`
   ].join("\n");
 }
-async function findOrCreateIssue(memoryKey, email, customer, personPathValue, token4, threadAddressValue) {
-  const path5 = issuePath(token4);
+async function findOrCreateIssue(memoryKey, email, customer, personPathValue, token6, threadAddressValue) {
+  const path5 = issuePath(token6);
   const existing = await getNote(memoryKey, "Issues", path5);
   if (existing) return existing;
   const subject = normalizeSupportSubject(email.subject);
@@ -29590,7 +30740,7 @@ async function findOrCreateIssue(memoryKey, email, customer, personPathValue, to
     path: path5,
     title: `Support thread \u2014 ${subject} \u2014 ${customer.email}`.slice(0, 240),
     content: buildIssueContent(email, customer, personPathValue, threadAddressValue),
-    source: `resend:thread:${token4}`,
+    source: `resend:thread:${token6}`,
     type: "user_friction",
     tagCandidates: ISSUE_TAGS,
     props: {
@@ -29599,7 +30749,7 @@ async function findOrCreateIssue(memoryKey, email, customer, personPathValue, to
       summary,
       pinned: false,
       source_type: "thread",
-      source_ref: `resend:thread:${token4}`,
+      source_ref: `resend:thread:${token6}`,
       related: [],
       related_vault_notes: [noteRef("People", personPathValue)],
       embed: true,
@@ -29614,7 +30764,7 @@ async function findOrCreateIssue(memoryKey, email, customer, personPathValue, to
       customer_email: customer.email,
       customer_name: customer.name,
       normalized_subject: subject,
-      thread_token: token4,
+      thread_token: token6,
       thread_address: threadAddressValue,
       communication_refs: [],
       message_count: 0,
@@ -29657,7 +30807,7 @@ function buildCommunicationContent(email, customer, direction, personPathValue,
     ...parentPath ? [`- Previous message: [[${parentPath}]]`] : []
   ].join("\n");
 }
-async function captureCommunication(memoryKey, email, customer, direction, personPathValue, issuePathValue, token4, parentPath) {
+async function captureCommunication(memoryKey, email, customer, direction, personPathValue, issuePathValue, token6, parentPath) {
   const path5 = communicationPath(email);
   const existing = await getNote(memoryKey, "Communication", path5);
   if (existing) return existing;
@@ -29696,8 +30846,8 @@ async function captureCommunication(memoryKey, email, customer, direction, perso
       provider: "resend",
       provider_connection_ref: "resend:updates.mcpscraper.dev",
       provider_message_ref: providerMessageRef,
-      provider_thread_ref: token4,
-      thread_ref: token4,
+      provider_thread_ref: token6,
+      thread_ref: token6,
       issue_ref: issuePathValue,
       sender_email: supportSender(email)?.email ?? email.from,
       recipient_emails: email.to ?? [],
@@ -29757,8 +30907,8 @@ async function updateIssueThread(memoryKey, issuePathValue, email, communication
     if (!result.conflict || attempt === 1) throw new Error(result.error ?? "support thread issue update failed");
   }
 }
-async function getSupportThreadByToken(memoryKey, token4) {
-  const safeToken = token4.toLowerCase().replace(/[^a-f0-9]/g, "").slice(0, 24);
+async function getSupportThreadByToken(memoryKey, token6) {
+  const safeToken = token6.toLowerCase().replace(/[^a-f0-9]/g, "").slice(0, 24);
   if (safeToken.length !== 24) return null;
   const path5 = issuePath(safeToken);
   const issue = await getNote(memoryKey, "Issues", path5);
@@ -29786,8 +30936,8 @@ async function captureSupportMessage(memoryKey, email, options) {
   const customer = options.customer ?? supportSender(email);
   if (!customer) throw new Error("support sender does not contain a usable email address");
   const normalizedSubject = options.existingThread?.normalizedSubject ?? normalizeSupportSubject(email.subject);
-  const token4 = options.existingThread?.threadToken ?? supportThreadToken(customer.email, normalizedSubject);
-  const threadAddressValue = options.existingThread?.threadAddress ?? supportThreadAddress(token4, options.receivingDomain);
+  const token6 = options.existingThread?.threadToken ?? supportThreadToken(customer.email, normalizedSubject);
+  const threadAddressValue = options.existingThread?.threadAddress ?? supportThreadAddress(token6, options.receivingDomain);
   const person = options.existingThread ? await getNote(memoryKey, "People", options.existingThread.personPath) : await findOrCreatePerson(memoryKey, customer, email.created_at);
   if (!person) throw new Error("support person could not be resolved");
   const issue = options.existingThread?.issue ?? await findOrCreateIssue(
@@ -29795,7 +30945,7 @@ async function captureSupportMessage(memoryKey, email, options) {
     email,
     customer,
     person.path,
-    token4,
+    token6,
     threadAddressValue
   );
   const parentPath = typeof issue.props?.last_communication_ref === "string" ? issue.props.last_communication_ref : void 0;
@@ -29806,7 +30956,7 @@ async function captureSupportMessage(memoryKey, email, options) {
     options.direction,
     person.path,
     issue.path,
-    token4,
+    token6,
     parentPath
   );
   await updateIssueThread(memoryKey, issue.path, email, communication.path, options.direction, person.path);
@@ -29815,7 +30965,7 @@ async function captureSupportMessage(memoryKey, email, options) {
     communicationPath: communication.path,
     personPath: person.path,
     parentCommunicationPath: parentPath,
-    threadToken: token4,
+    threadToken: token6,
     threadAddress: threadAddressValue,
     customerEmail: customer.email,
     normalizedSubject,
@@ -29988,8 +31138,8 @@ resendInboundApp.post("/webhooks", async (c) => {
         threadAddress: captured.threadAddress
       });
     }
-    const token4 = extractSupportThreadToken(receivedEvent.data.to ?? [], ...domains);
-    const thread = token4 ? await getSupportThreadByToken(memoryKey, token4) : null;
+    const token6 = extractSupportThreadToken(receivedEvent.data.to ?? [], ...domains);
+    const thread = token6 ? await getSupportThreadByToken(memoryKey, token6) : null;
     if (!thread) return c.json({ ok: true, route, ignored: true, reason: "unknown-support-thread" });
     const operator = parseMailbox(destination);
     if (operator && sender.email === operator.email) {
@@ -30275,8 +31425,8 @@ var workshopFieldNotes = [
 function escapeHtml3(value) {
   return value.replaceAll("&", "&amp;").replaceAll("<", "&lt;").replaceAll(">", "&gt;").replaceAll('"', "&quot;").replaceAll("'", "&#039;");
 }
-function workshopFieldNoteUrl(slug2) {
-  return `${WORKSHOP_FIELD_NOTES_URL}?article=${encodeURIComponent(slug2)}`;
+function workshopFieldNoteUrl(slug4) {
+  return `${WORKSHOP_FIELD_NOTES_URL}?article=${encodeURIComponent(slug4)}`;
 }
 function renderWorkshopFieldNotesBody() {
   let activeCategory = "";
@@ -30835,16 +31985,16 @@ import { z as z31 } from "zod";
 // src/editorial-reading-room/render.ts
 import { createHash as createHash11 } from "crypto";
 import { readFileSync as readFileSync3 } from "fs";
-import { dirname as dirname3, join as join6, resolve } from "path";
+import { dirname as dirname3, join as join7, resolve } from "path";
 import { Marked, Renderer } from "marked";
 var runtimeEntryDir = dirname3(resolve(process.argv[1] || process.cwd()));
 var assetCache = /* @__PURE__ */ new Map();
 function assetPath(name) {
   const candidates = [
-    join6(runtimeEntryDir, "editorial-reading-room", "assets", name),
-    join6(runtimeEntryDir, "..", "editorial-reading-room", "assets", name),
-    join6(process.cwd(), "src", "editorial-reading-room", "assets", name),
-    join6(process.cwd(), "dist", "editorial-reading-room", "assets", name)
+    join7(runtimeEntryDir, "editorial-reading-room", "assets", name),
+    join7(runtimeEntryDir, "..", "editorial-reading-room", "assets", name),
+    join7(process.cwd(), "src", "editorial-reading-room", "assets", name),
+    join7(process.cwd(), "dist", "editorial-reading-room", "assets", name)
   ];
   for (const candidate of candidates) {
     try {
@@ -30918,8 +32068,8 @@ function addHeadingIds(html) {
   });
   return { rendered, toc };
 }
-function safeFilename(requested, slug2) {
-  const stem = (requested || slug2).replace(/\.html?$/i, "").replace(/[^a-zA-Z0-9._-]+/g, "-").replace(/^-+|-+$/g, "").slice(0, 110) || "editorial-reading-room";
+function safeFilename(requested, slug4) {
+  const stem = (requested || slug4).replace(/\.html?$/i, "").replace(/[^a-zA-Z0-9._-]+/g, "-").replace(/^-+|-+$/g, "").slice(0, 110) || "editorial-reading-room";
   return `${stem}.html`;
 }
 function escapedJsonForHtml(value) {
@@ -31075,20 +32225,20 @@ ${provenance}`;
 var EDITORIAL_READING_ROOM_ARTIFACT_PREFIX = "editorial-reading-rooms/";
 var EDITORIAL_READING_ROOM_ARTIFACT_TTL_MS = 7 * 24 * 60 * 60 * 1e3;
 var EDITORIAL_READING_ROOM_DOWNLOAD_TTL_MS = 15 * 60 * 1e3;
-function token2() {
+function token3() {
   return process.env.EDITORIAL_READING_ROOM_ARTIFACT_READ_WRITE_TOKEN?.trim() || process.env.PRIVATE_ARTIFACT_READ_WRITE_TOKEN?.trim() || process.env.CONNECTED_DATA_READ_WRITE_TOKEN?.trim() || process.env.CONNECTED_DATA_BLOB_READ_WRITE_TOKEN?.trim() || null;
 }
-function policy2() {
+function policy3() {
   return {
     prefix: EDITORIAL_READING_ROOM_ARTIFACT_PREFIX,
     artifactTtlMs: EDITORIAL_READING_ROOM_ARTIFACT_TTL_MS,
     downloadTtlMs: EDITORIAL_READING_ROOM_DOWNLOAD_TTL_MS,
-    token: token2()
+    token: token3()
   };
 }
 function createEditorialReadingRoomArtifact(args) {
   return createPrivateArtifact({
-    policy: policy2(),
+    policy: policy3(),
     ownerId: args.ownerId,
     artifactKey: `${args.rendered.sha256.slice(0, 12)}-${args.rendered.filename}`,
     createdAt: args.rendered.generatedAt,
@@ -31099,7 +32249,7 @@ function createEditorialReadingRoomArtifact(args) {
 }
 function renewEditorialReadingRoomArtifactDownload(args) {
   return renewPrivateArtifactDownload({
-    policy: policy2(),
+    policy: policy3(),
     ownerId: args.ownerId,
     artifactId: args.artifactId
   });
@@ -31879,7 +33029,7 @@ async function searchCommonsEntities(filters = {}, userId) {
 async function prepareCommonsEntity(input, user) {
   await ensureCommonsSchema();
   const title = optionalText2(input.title, 180) ?? "";
-  const slug2 = normalizeSlug(input.slug || title);
+  const slug4 = normalizeSlug(input.slug || title);
   const schemaOrgType = optionalText2(input.schemaOrgType, 80);
   const contract = commonsEntityProfileFor(input.entityType, schemaOrgType);
   const entityType = contract.entityType;
@@ -31887,7 +33037,7 @@ async function prepareCommonsEntity(input, user) {
   const headings = extractMarkdownHeadings(bodyMarkdown);
   const duplicateCandidates = await potentialDuplicateCandidates({
     title,
-    slug: slug2,
+    slug: slug4,
     source: normalizeSource(input.source),
     maxCandidates: clampNumber(input.maxCandidates, 1, 20, 8)
   });
@@ -31904,8 +33054,8 @@ async function prepareCommonsEntity(input, user) {
       entityIdPrefix: "TPW-Q",
       userId: user?.id ?? null,
       normalizedEntityType: entityType,
-      proposedSlug: slug2 || null,
-      publicUrl: slug2 ? publicUrlForSlug(slug2) : null,
+      proposedSlug: slug4 || null,
+      publicUrl: slug4 ? publicUrlForSlug(slug4) : null,
       writePath: "commons_prepare_entity -> commons_validate_entity -> commons_submit_entity"
     },
     contract,
@@ -31940,7 +33090,7 @@ async function validateCommonsEntity(input, user) {
   const warnings = [];
   const title = optionalText2(input.title, 180);
   const description = optionalText2(input.description, 600);
-  const slug2 = normalizeSlug(input.slug || title || "");
+  const slug4 = normalizeSlug(input.slug || title || "");
   const contract = commonsEntityProfileFor(input.entityType, input.seo?.schemaOrgType);
   const source = normalizeSource(input.source);
   const featuredImage = normalizeFeaturedImage(input.featuredImage);
@@ -31949,11 +33099,11 @@ async function validateCommonsEntity(input, user) {
   const placeholderSections = unsupportedPlaceholderSections(bodyMarkdown);
   const duplicateCandidates = await potentialDuplicateCandidates({
     title: title ?? "",
-    slug: slug2,
+    slug: slug4,
     source,
     maxCandidates: 8
   });
-  const existing = slug2 || input.entityId ? await findEntityBySlugOrIdAnyStatus(slug2, input.entityId) : null;
+  const existing = slug4 || input.entityId ? await findEntityBySlugOrIdAnyStatus(slug4, input.entityId) : null;
   try {
     normalizeCommonsClaims(input.claims);
   } catch (error) {
@@ -31961,7 +33111,7 @@ async function validateCommonsEntity(input, user) {
   }
   if (!title || title.length < 3) errors.push("title must be at least 3 characters.");
   if (!description || description.length < 8) errors.push("description must be at least 8 characters.");
-  if (!slug2) errors.push("A Commons entity needs a URL slug.");
+  if (!slug4) errors.push("A Commons entity needs a URL slug.");
   if (!featuredImage?.url) errors.push("A featured image is required before a Commons entity can publish.");
   if (!bodyMarkdown.trim() && !source.originalUrl && !source.resolvedUrl) {
     errors.push("A public entity needs article body text or source evidence before publishing.");
@@ -32422,13 +33572,13 @@ async function findProposalByIdempotency(userId, idempotencyKey3) {
   });
   return result.rows[0] ? rowToProposal(result.rows[0]) : null;
 }
-async function findEntityBySlugOrIdAnyStatus(slug2, entityId) {
+async function findEntityBySlugOrIdAnyStatus(slug4, entityId) {
   const result = entityId ? await getDb().execute({
     sql: "SELECT * FROM commons_entities WHERE slug = ? OR id = ? LIMIT 1",
-    args: [slug2, entityId]
+    args: [slug4, entityId]
   }) : await getDb().execute({
     sql: "SELECT * FROM commons_entities WHERE slug = ? LIMIT 1",
-    args: [slug2]
+    args: [slug4]
   });
   return result.rows[0] ? rowToEntity(result.rows[0]) : null;
 }
@@ -32620,13 +33770,13 @@ function canonicalizeSourceUrl(value) {
 function normalizeSubmitInput(input) {
   const title = requiredText(input.title, "title", 3, 180);
   const description = requiredText(input.description, "description", 8, 600);
-  const slug2 = normalizeSlug(input.slug || title);
-  if (!slug2) throw new CommonsRepositoryError("slug_required", "A Commons entity needs a URL slug.");
+  const slug4 = normalizeSlug(input.slug || title);
+  if (!slug4) throw new CommonsRepositoryError("slug_required", "A Commons entity needs a URL slug.");
   return {
     idempotencyKey: requiredText(input.idempotencyKey, "idempotencyKey", 8, 200),
     title,
     description,
-    slug: slug2,
+    slug: slug4,
     entityId: normalizeEntityId(input.entityId),
     entityType: normalizeEntityType(input.entityType),
     disambiguationName: optionalText2(input.disambiguationName, 240) ?? void 0,
@@ -33175,13 +34325,13 @@ function normalizeRelatedLinks(relatedLinks) {
   return relatedLinks.map((link) => {
     const title = requiredText(link.title, "relatedLinks.title", 1, 180);
     const url = optionalText2(link.url, 2e3);
-    const slug2 = link.slug ? normalizeSlug(link.slug) : void 0;
+    const slug4 = link.slug ? normalizeSlug(link.slug) : void 0;
     const entityId = normalizeEntityId(link.entityId);
-    const needsLink = link.needsLink === true || !url && !slug2 && !entityId;
+    const needsLink = link.needsLink === true || !url && !slug4 && !entityId;
     return {
       title,
       url,
-      slug: slug2,
+      slug: slug4,
       entityId,
       relationship: optionalText2(link.relationship, 120) ?? void 0,
       summary: optionalText2(link.summary, 300) ?? void 0,
@@ -33412,8 +34562,8 @@ function actorLabel(input, user) {
 function publicBaseUrl() {
   return (process.env.TRANSPARENT_COMMONS_PUBLIC_BASE_URL?.trim() || DEFAULT_COMMONS_BASE_URL).replace(/\/+$/, "");
 }
-function publicUrlForSlug(slug2) {
-  return `${publicBaseUrl()}/wiki/${encodeURIComponent(slug2)}`;
+function publicUrlForSlug(slug4) {
+  return `${publicBaseUrl()}/wiki/${encodeURIComponent(slug4)}`;
 }
 function allocateEntityId() {
   return `TPW-Q${Date.now()}${Math.floor(Math.random() * 1e3).toString().padStart(3, "0")}`;
@@ -33615,11 +34765,11 @@ async function validateCommonsPublication(input, user) {
       } catch (error) {
         errors.push(error instanceof Error ? error.message : String(error));
       }
-      const slug2 = normalizeEditionSlug(input.editionSlug || input.edition.site.slug);
-      const latest = publication ? await getLatestEdition(publication.id, slug2) : null;
-      if (latest && input.baseRevision === void 0) errors.push(`Edition ${slug2} already exists at revision ${latest.revision}; supply baseRevision to edit it.`);
+      const slug4 = normalizeEditionSlug(input.editionSlug || input.edition.site.slug);
+      const latest = publication ? await getLatestEdition(publication.id, slug4) : null;
+      if (latest && input.baseRevision === void 0) errors.push(`Edition ${slug4} already exists at revision ${latest.revision}; supply baseRevision to edit it.`);
       if (latest && input.baseRevision !== void 0 && latest.revision !== input.baseRevision) {
-        errors.push(`Edition ${slug2} is revision ${latest.revision}; the proposed edit targeted ${input.baseRevision}.`);
+        errors.push(`Edition ${slug4} is revision ${latest.revision}; the proposed edit targeted ${input.baseRevision}.`);
       }
     }
   }
@@ -34368,7 +35518,7 @@ import Papa2 from "papaparse";
 import {
   createHash as createHash15,
   createHmac as createHmac3,
-  randomBytes as randomBytes3,
+  randomBytes as randomBytes4,
   timingSafeEqual as timingSafeEqual2
 } from "crypto";
 import { z as z33 } from "zod";
@@ -34580,7 +35730,7 @@ function dashboardCallbackUrl() {
 }
 async function createThorbitConnectUrl(userId) {
   if (!bridgeConfigured()) throw new Error("Thorbit X-Ray account bridge is not configured");
-  const state = randomBytes3(32).toString("base64url");
+  const state = randomBytes4(32).toString("base64url");
   const stateHash = createHash15("sha256").update(state).digest("hex");
   await getAnalyticsPool().query(
     `INSERT INTO analytics_thorbit_connect_states(state_hash,user_id,expires_at)
@@ -34593,8 +35743,8 @@ async function createThorbitConnectUrl(userId) {
   url.searchParams.set("state", state);
   return url.toString();
 }
-function verifyThorbitAssertion(token4) {
-  const [encoded, signature] = token4.split(".");
+function verifyThorbitAssertion(token6) {
+  const [encoded, signature] = token6.split(".");
   if (!encoded || !signature || !bridgeConfigured()) throw new Error("Invalid Thorbit assertion");
   const expected = createHmac3("sha256", bridgeSecret()).update(encoded).digest();
   const actual = Buffer.from(signature, "base64url");
@@ -36072,7 +37222,7 @@ function scheduledArtifactOwnerIdForApiKey(apiKey) {
 }
 
 // src/api/scheduled-run-view-links.ts
-import { createHash as createHash18, randomBytes as randomBytes4, randomUUID as randomUUID17 } from "crypto";
+import { createHash as createHash18, randomBytes as randomBytes5, randomUUID as randomUUID17 } from "crypto";
 var schemaReady2 = false;
 async function ensureScheduledRunViewLinksSchema() {
   if (schemaReady2) return;
@@ -36125,8 +37275,8 @@ async function ensureScheduledRunViewLinksSchema() {
   `);
   schemaReady2 = true;
 }
-function tokenHash2(token4) {
-  return createHash18("sha256").update(token4).digest("hex");
+function tokenHash2(token6) {
+  return createHash18("sha256").update(token6).digest("hex");
 }
 function mapRow(row) {
   return {
@@ -36146,7 +37296,7 @@ function mapRow(row) {
 async function createScheduledRunViewLink(input) {
   await ensureScheduledRunViewLinksSchema();
   const now = input.now ?? /* @__PURE__ */ new Date();
-  const token4 = randomBytes4(32).toString("base64url");
+  const token6 = randomBytes5(32).toString("base64url");
   const record = {
     shareId: randomUUID17(),
     ownerId: input.ownerId,
@@ -36155,7 +37305,7 @@ async function createScheduledRunViewLink(input) {
     title: input.title.slice(0, 300),
     summary: input.summary.slice(0, 2e3),
     rendererKey: input.rendererKey,
-    tokenHash: tokenHash2(token4),
+    tokenHash: tokenHash2(token6),
     expiresAt: new Date(now.getTime() + input.expiresInDays * 24 * 60 * 60 * 1e3).toISOString(),
     revokedAt: null,
     createdAt: now.toISOString()
@@ -36180,9 +37330,9 @@ async function createScheduledRunViewLink(input) {
       record.createdAt
     ]
   });
-  return { record, token: token4 };
+  return { record, token: token6 };
 }
-async function resolveScheduledRunViewLink(token4, now = /* @__PURE__ */ new Date()) {
+async function resolveScheduledRunViewLink(token6, now = /* @__PURE__ */ new Date()) {
   await ensureScheduledRunViewLinksSchema();
   const result = await getDb().execute({
     sql: `
@@ -36194,7 +37344,7 @@ async function resolveScheduledRunViewLink(token4, now = /* @__PURE__ */ new Dat
         AND expires_at > ?
       LIMIT 1
     `,
-    args: [tokenHash2(token4), now.toISOString()]
+    args: [tokenHash2(token6), now.toISOString()]
   });
   const row = result.rows[0];
   return row ? mapRow(row) : null;
@@ -36609,7 +37759,7 @@ scheduledResultApp.post("/schedule-runs/:runId/view-links", async (c) => {
   const artifact = result.data.run.artifactOutputs.find((output) => output.artifactId === body.data.artifactId);
   if (!artifact) return c.json(apiError("The scheduled result artifact was not found.", "not_found"), 404);
   const ownerId = scheduledArtifactOwnerIdForApiKey(user.api_key);
-  const { record, token: token4 } = await createScheduledRunViewLink({
+  const { record, token: token6 } = await createScheduledRunViewLink({
     ownerId,
     runId: result.data.run.runId,
     artifactId: artifact.artifactId,
@@ -36624,7 +37774,7 @@ scheduledResultApp.post("/schedule-runs/:runId/view-links", async (c) => {
     shareId: record.shareId,
     runId: record.runId,
     artifactId: record.artifactId,
-    url: `${origin.replace(/\/$/, "")}/view/scheduled-run/${token4}`,
+    url: `${origin.replace(/\/$/, "")}/view/scheduled-run/${token6}`,
     expiresAt: record.expiresAt,
     createdAt: record.createdAt
   }, 201);
@@ -36650,15 +37800,15 @@ import { createHash as createHash21 } from "crypto";
 var SCHEDULED_RUN_ARTIFACT_PREFIX = "scheduled-run-artifacts/";
 var SCHEDULED_RUN_ARTIFACT_DOWNLOAD_TTL_MS = 15 * 60 * 1e3;
 var SCHEDULED_RUN_ARTIFACT_MAX_BYTES = 2e6;
-function token3() {
+function token4() {
   return process.env.SCHEDULED_ARTIFACT_READ_WRITE_TOKEN?.trim() || process.env.PRIVATE_ARTIFACT_READ_WRITE_TOKEN?.trim() || process.env.CONNECTED_DATA_READ_WRITE_TOKEN?.trim() || process.env.CONNECTED_DATA_BLOB_READ_WRITE_TOKEN?.trim() || null;
 }
-function policy3() {
+function policy4() {
   return {
     prefix: SCHEDULED_RUN_ARTIFACT_PREFIX,
     artifactTtlMs: null,
     downloadTtlMs: SCHEDULED_RUN_ARTIFACT_DOWNLOAD_TTL_MS,
-    token: token3()
+    token: token4()
   };
 }
 function runStorageSegment(runId) {
@@ -36669,7 +37819,7 @@ async function createScheduledRunArtifact(args) {
     throw new Error("Scheduled artifact HTML must be 2,000,000 bytes or fewer.");
   }
   const stored = await createPrivateArtifact({
-    policy: policy3(),
+    policy: policy4(),
     ownerId: args.request.ownerId,
     scopeSegments: [runStorageSegment(args.request.runId)],
     artifactKey: `${args.rendered.sha256.slice(0, 16)}-${args.rendered.filename}`,
@@ -36695,7 +37845,7 @@ async function createScheduledRunArtifact(args) {
 async function readScheduledRunArtifact(args) {
   if (!args.artifactId.startsWith(`${SCHEDULED_RUN_ARTIFACT_PREFIX}${args.ownerId}/`)) return null;
   const window2 = await readPrivateArtifactWindow({
-    policy: policy3(),
+    policy: policy4(),
     artifactId: args.artifactId,
     offset: 0,
     maxBytes: SCHEDULED_RUN_ARTIFACT_MAX_BYTES + 1
@@ -37258,6 +38408,282 @@ function shouldRunSiteExtractInBackground(input) {
   return input.background === true || input.downloadImages === true || requestedSiteMaxPages(input.maxPages) > MAX_SYNCHRONOUS_SITE_PAGES;
 }
 
+// src/api/page-media-artifacts.ts
+import { createHash as createHash23, randomBytes as randomBytes6 } from "crypto";
+import { homedir as homedir3 } from "os";
+import { basename, extname, join as join8 } from "path";
+import pLimit6 from "p-limit";
+import { ZipFile as ZipFile2 } from "yazl";
+var PAGE_MEDIA_ARTIFACT_PREFIX = "page-media/";
+var PAGE_MEDIA_ARTIFACT_TTL_MS = 7 * 24 * 60 * 60 * 1e3;
+var PAGE_MEDIA_DOWNLOAD_TTL_MS = 15 * 60 * 1e3;
+var MAX_FILE_BYTES = 10 * 1024 * 1024;
+var MAX_ARCHIVE_MEDIA_BYTES = 45 * 1024 * 1024;
+var MAX_INLINE_IMAGE_BYTES2 = 15e5;
+var MAX_INLINE_TOTAL_BYTES2 = 25e5;
+var DOWNLOAD_CONCURRENCY2 = 6;
+var MAX_REDIRECTS2 = 5;
+function token5() {
+  return process.env.PAGE_MEDIA_ARTIFACT_READ_WRITE_TOKEN?.trim() || process.env.PRIVATE_ARTIFACT_READ_WRITE_TOKEN?.trim() || process.env.CONNECTED_DATA_READ_WRITE_TOKEN?.trim() || process.env.CONNECTED_DATA_BLOB_READ_WRITE_TOKEN?.trim() || null;
+}
+function policy5() {
+  return {
+    prefix: PAGE_MEDIA_ARTIFACT_PREFIX,
+    artifactTtlMs: PAGE_MEDIA_ARTIFACT_TTL_MS,
+    downloadTtlMs: PAGE_MEDIA_DOWNLOAD_TTL_MS,
+    token: token5()
+  };
+}
+function imageSignature(bytes, contentType) {
+  if (bytes.length >= 3 && bytes[0] === 255 && bytes[1] === 216 && bytes[2] === 255) return { mimeType: "image/jpeg", extension: "jpg" };
+  if (bytes.length >= 8 && bytes[0] === 137 && bytes[1] === 80 && bytes[2] === 78 && bytes[3] === 71) return { mimeType: "image/png", extension: "png" };
+  if (bytes.length >= 12 && String.fromCharCode(...bytes.slice(0, 4)) === "RIFF" && String.fromCharCode(...bytes.slice(8, 12)) === "WEBP") return { mimeType: "image/webp", extension: "webp" };
+  if (bytes.length >= 6 && ["GIF87a", "GIF89a"].includes(String.fromCharCode(...bytes.slice(0, 6)))) return { mimeType: "image/gif", extension: "gif" };
+  if (bytes.length >= 12 && String.fromCharCode(...bytes.slice(4, 12)).match(/^ftyp(?:avif|avis)$/)) return { mimeType: "image/avif", extension: "avif" };
+  const prefix = Buffer.from(bytes.slice(0, Math.min(bytes.length, 1024))).toString("utf8").replace(/^\uFEFF/, "").trimStart();
+  if ((contentType === "image/svg+xml" || prefix.startsWith("<svg") || /^<\?xml[\s\S]*?<svg/i.test(prefix)) && /<svg[\s>]/i.test(prefix)) {
+    return { mimeType: "image/svg+xml", extension: "svg" };
+  }
+  return null;
+}
+function mediaSignature(bytes, contentType, expectedType) {
+  if (expectedType === "image") return imageSignature(bytes, contentType);
+  if (bytes.length >= 12 && String.fromCharCode(...bytes.slice(4, 8)) === "ftyp") return { mimeType: "video/mp4", extension: "mp4" };
+  if (bytes.length >= 4 && bytes[0] === 26 && bytes[1] === 69 && bytes[2] === 223 && bytes[3] === 163) return { mimeType: "video/webm", extension: "webm" };
+  if (bytes.length >= 4 && String.fromCharCode(...bytes.slice(0, 4)) === "OggS") {
+    return expectedType === "audio" ? { mimeType: "audio/ogg", extension: "ogg" } : { mimeType: "video/ogg", extension: "ogv" };
+  }
+  if (expectedType === "audio" && bytes.length >= 3 && String.fromCharCode(...bytes.slice(0, 3)) === "ID3") return { mimeType: "audio/mpeg", extension: "mp3" };
+  if (contentType && typeFromMime(contentType) === expectedType) {
+    const extension = contentType.split("/")[1]?.replace("jpeg", "jpg").replace("mpeg", "mp3").replace("svg+xml", "svg");
+    if (extension && /^[a-z0-9]+$/i.test(extension)) return { mimeType: contentType, extension };
+  }
+  return null;
+}
+function imageDimensions(bytes, mimeType) {
+  const buffer = Buffer.from(bytes);
+  if (mimeType === "image/png" && buffer.length >= 24) return { width: buffer.readUInt32BE(16), height: buffer.readUInt32BE(20) };
+  if (mimeType === "image/gif" && buffer.length >= 10) return { width: buffer.readUInt16LE(6), height: buffer.readUInt16LE(8) };
+  if (mimeType === "image/webp" && buffer.length >= 30) {
+    const chunk = buffer.toString("ascii", 12, 16);
+    if (chunk === "VP8X") return { width: 1 + buffer.readUIntLE(24, 3), height: 1 + buffer.readUIntLE(27, 3) };
+    if (chunk === "VP8L" && buffer[20] === 47) {
+      const bits = buffer.readUInt32LE(21);
+      return { width: (bits & 16383) + 1, height: (bits >> 14 & 16383) + 1 };
+    }
+  }
+  if (mimeType === "image/jpeg") {
+    let offset = 2;
+    while (offset + 9 < buffer.length) {
+      if (buffer[offset] !== 255) {
+        offset += 1;
+        continue;
+      }
+      const marker = buffer[offset + 1];
+      if (marker === 216 || marker === 217) {
+        offset += 2;
+        continue;
+      }
+      const length = buffer.readUInt16BE(offset + 2);
+      if (length < 2 || offset + length + 2 > buffer.length) break;
+      if ([192, 193, 194, 195, 197, 198, 199, 201, 202, 203, 205, 206, 207].includes(marker)) {
+        return { height: buffer.readUInt16BE(offset + 5), width: buffer.readUInt16BE(offset + 7) };
+      }
+      offset += length + 2;
+    }
+  }
+  if (mimeType === "image/svg+xml") {
+    const source = buffer.toString("utf8", 0, Math.min(buffer.length, 64 * 1024));
+    const tag = source.match(/<svg\b[^>]*>/i)?.[0] ?? "";
+    const width = Number(tag.match(/\bwidth=["']?([\d.]+)/i)?.[1] ?? 0);
+    const height = Number(tag.match(/\bheight=["']?([\d.]+)/i)?.[1] ?? 0);
+    if (width > 0 && height > 0) return { width: Math.round(width), height: Math.round(height) };
+    const viewBox = tag.match(/\bviewBox=["']([^"']+)["']/i)?.[1]?.trim().split(/[\s,]+/).map(Number);
+    if (viewBox?.length === 4 && viewBox[2] > 0 && viewBox[3] > 0) return { width: Math.round(viewBox[2]), height: Math.round(viewBox[3]) };
+  }
+  return null;
+}
+async function readBounded2(response) {
+  const declared = Number(response.headers.get("content-length") ?? "");
+  if (Number.isFinite(declared) && declared > MAX_FILE_BYTES) throw new Error("media_too_large");
+  if (!response.body) {
+    const bytes = Buffer.from(await response.arrayBuffer());
+    if (bytes.length > MAX_FILE_BYTES) throw new Error("media_too_large");
+    return bytes;
+  }
+  const reader = response.body.getReader();
+  const chunks = [];
+  let total = 0;
+  try {
+    for (; ; ) {
+      const { done, value } = await reader.read();
+      if (done) break;
+      if (!value) continue;
+      total += value.byteLength;
+      if (total > MAX_FILE_BYTES) throw new Error("media_too_large");
+      chunks.push(Buffer.from(value));
+    }
+  } finally {
+    reader.releaseLock();
+  }
+  return Buffer.concat(chunks);
+}
+async function fetchMedia(rawUrl, expectedType) {
+  let target = rawUrl;
+  for (let redirects = 0; redirects <= MAX_REDIRECTS2; redirects += 1) {
+    const checked = await validatePublicHttpUrl(target, { field: "website media URL" });
+    if (checked.error || !checked.parsed) throw new Error("media_url_rejected");
+    const response = await fetch(checked.parsed.href, {
+      redirect: "manual",
+      headers: { Accept: expectedType === "image" ? "image/*" : `${expectedType}/*` },
+      signal: AbortSignal.timeout(15e3)
+    });
+    if ([301, 302, 303, 307, 308].includes(response.status)) {
+      const location2 = response.headers.get("location");
+      if (!location2 || redirects === MAX_REDIRECTS2) throw new Error("media_redirect_rejected");
+      target = new URL(location2, checked.parsed).href;
+      continue;
+    }
+    if (!response.ok) throw new Error(`media_fetch_${response.status}`);
+    const bytes = await readBounded2(response);
+    const declared = response.headers.get("content-type")?.split(";")[0].trim().toLowerCase() ?? null;
+    const detected = mediaSignature(bytes, declared, expectedType);
+    if (!detected || typeFromMime(detected.mimeType) !== expectedType) throw new Error("media_content_invalid");
+    const dimensions = expectedType === "image" ? imageDimensions(bytes, detected.mimeType) : null;
+    return {
+      bytes,
+      ...detected,
+      finalUrl: checked.parsed.href,
+      width: dimensions?.width ?? null,
+      height: dimensions?.height ?? null,
+      sha256: createHash23("sha256").update(bytes).digest("hex")
+    };
+  }
+  throw new Error("media_redirect_rejected");
+}
+function zipBuffer2(files) {
+  return new Promise((resolve2, reject) => {
+    const zip = new ZipFile2();
+    const chunks = [];
+    zip.outputStream.on("data", (chunk) => chunks.push(Buffer.from(chunk)));
+    zip.outputStream.once("error", reject);
+    zip.outputStream.once("end", () => resolve2(Buffer.concat(chunks)));
+    for (const file of files) zip.addBuffer(file.content, file.path);
+    zip.end();
+  });
+}
+function slug3(value) {
+  return value.toLowerCase().replace(/[^a-z0-9]+/g, "-").replace(/^-+|-+$/g, "").slice(0, 70) || "website";
+}
+function safeOriginalName(rawUrl) {
+  try {
+    const name = basename(new URL(rawUrl).pathname).replace(/[^a-zA-Z0-9._-]+/g, "-").replace(/^-+|-+$/g, "");
+    return name.slice(0, 80);
+  } catch {
+    return "";
+  }
+}
+function pageMediaArtifactOwnerId(artifactId) {
+  return privateArtifactOwnerId(artifactId, PAGE_MEDIA_ARTIFACT_PREFIX);
+}
+async function readOwnedPageMediaArtifactBuffer(args) {
+  if (pageMediaArtifactOwnerId(args.artifactId) !== args.ownerId) return null;
+  return readPrivateArtifactBuffer({ policy: policy5(), artifactId: args.artifactId, maxBytes: 60 * 1024 * 1024 });
+}
+async function packagePageMedia(args) {
+  const files = [];
+  const limit = pLimit6(DOWNLOAD_CONCURRENCY2);
+  const digestToFilename = /* @__PURE__ */ new Map();
+  let storedBytes = 0;
+  let inlineBytes = 0;
+  let inlineCount = 0;
+  await Promise.all(args.media.assets.map((asset, position) => limit(async () => {
+    try {
+      const fetched = await fetchMedia(asset.url, asset.type);
+      asset.finalUrl = fetched.finalUrl;
+      asset.mimeType = fetched.mimeType;
+      asset.sizeBytes = fetched.bytes.length;
+      asset.sha256 = fetched.sha256;
+      asset.width = fetched.width ?? asset.width;
+      asset.height = fetched.height ?? asset.height;
+      const duplicate = digestToFilename.get(fetched.sha256);
+      if (duplicate) {
+        asset.filename = duplicate;
+        asset.duplicateOf = duplicate;
+        asset.downloadStatus = "downloaded";
+        asset.downloadError = null;
+        return;
+      }
+      if (storedBytes + fetched.bytes.length > MAX_ARCHIVE_MEDIA_BYTES) throw new Error("archive_byte_limit_reached");
+      storedBytes += fetched.bytes.length;
+      const original = safeOriginalName(fetched.finalUrl);
+      const extension = extname(original);
+      const stem = original ? extension ? original.slice(0, -extension.length) : original : asset.type;
+      const filename = `media/${String(position + 1).padStart(4, "0")}-${slug3(stem)}.${fetched.extension}`;
+      digestToFilename.set(fetched.sha256, filename);
+      files.push({ path: filename, content: fetched.bytes });
+      asset.filename = filename;
+      asset.duplicateOf = null;
+      asset.downloadStatus = "downloaded";
+      asset.downloadError = null;
+      if (asset.type === "image" && inlineCount < args.maxInlineImages && fetched.bytes.length <= MAX_INLINE_IMAGE_BYTES2 && inlineBytes + fetched.bytes.length <= MAX_INLINE_TOTAL_BYTES2) {
+        asset.inlinePreview = { data: fetched.bytes.toString("base64"), mimeType: fetched.mimeType };
+        inlineBytes += fetched.bytes.length;
+        inlineCount += 1;
+      }
+    } catch (error) {
+      asset.finalUrl = null;
+      asset.mimeType = null;
+      asset.sizeBytes = null;
+      asset.sha256 = null;
+      asset.savedPath = null;
+      asset.downloadStatus = "failed";
+      asset.downloadError = error instanceof Error ? error.message : "media_download_failed";
+      asset.inlinePreview = null;
+    }
+  })));
+  const downloaded = args.media.assets.filter((asset) => asset.downloadStatus === "downloaded").length;
+  const failed = args.media.assets.length - downloaded;
+  if (failed > 0) args.media.warnings.push(`${failed} media asset(s) could not be downloaded; media.jsonl contains bounded error codes.`);
+  if (downloaded === 0) return { media: args.media, artifact: null };
+  const cleanAssets = args.media.assets.map(({ inlinePreview: _preview, ...asset }) => asset);
+  const summary = {
+    pageUrl: args.pageUrl,
+    title: args.title,
+    extractedAt: args.extractedAt,
+    completeness: args.media.completeness,
+    exhausted: args.media.exhausted,
+    stopReason: args.media.stopReason,
+    scrollRounds: args.media.scrollRounds,
+    staticFound: args.media.staticFound,
+    renderedFound: args.media.renderedFound,
+    totalFound: args.media.totalFound,
+    retainedAfterFilteringAndVariantCollapse: args.media.assets.length,
+    downloaded,
+    failed,
+    notes: [
+      "The inventory unions static-source and rendered-page discovery.",
+      "complete means rendered scrolling reached three stable document-height checks; it does not claim every interactive control was opened.",
+      "Media records preserve discovery evidence but do not assert ownership, rights, identity, or publishability."
+    ]
+  };
+  files.push({ path: "summary.json", content: Buffer.from(JSON.stringify(summary, null, 2)) });
+  files.push({ path: "media.jsonl", content: Buffer.from(cleanAssets.map((asset) => JSON.stringify(asset)).join("\n") + "\n") });
+  const archive = await zipBuffer2(files);
+  const id = randomBytes6(6).toString("hex");
+  const pointer = await createPrivateArtifact({
+    policy: policy5(),
+    ownerId: args.ownerId,
+    artifactKey: `${id}.zip`,
+    createdAt: new Date(args.extractedAt),
+    filename: `${slug3(args.title || new URL(args.pageUrl).hostname)}-website-media.zip`,
+    contentType: "application/zip",
+    content: archive
+  });
+  const localPath = token5() ? null : join8(process.env.MCP_SCRAPER_OUTPUT_DIR?.trim() || join8(homedir3(), "Downloads", "mcp-scraper"), "blobs", pointer.artifactId);
+  return { media: args.media, artifact: { ...pointer, localPath } };
+}
+
 // src/api/site-extract-reconciliation.ts
 async function redispatchFundedSiteExtractJobs(limit = 25) {
   const jobs = await listFundedPendingExtractJobs(limit);
@@ -37323,13 +38749,13 @@ async function reconcileSiteExtractSettlements(limit = 25) {
 }
 
 // src/api/page-diff.ts
-import { createHash as createHash23 } from "crypto";
+import { createHash as createHash24 } from "crypto";
 import { diffLines } from "diff";
 var MAX_SNAPSHOT_CONTENT_CHARS = 25e4;
 var MAX_DIFF_HUNKS = 200;
 var MAX_DIFF_LINES_PER_RESPONSE = 2e3;
 function sha256Hex(value) {
-  return createHash23("sha256").update(value).digest("hex");
+  return createHash24("sha256").update(value).digest("hex");
 }
 function truncateForStorage(value, maxChars = MAX_SNAPSHOT_CONTENT_CHARS) {
   if (value.length <= maxChars) return { value, truncated: false };
@@ -37422,8 +38848,8 @@ async function uploadFallbackBlob(opts) {
   try {
     const content = (opts.content ?? "").trim();
     if (!content) return null;
-    const slug2 = (slugify(opts.title || opts.source) || "scrape").slice(0, 60);
-    const key = `${SCRAPE_FALLBACK_PREFIX}${slug2}.md`;
+    const slug4 = (slugify(opts.title || opts.source) || "scrape").slice(0, 60);
+    const key = `${SCRAPE_FALLBACK_PREFIX}${slug4}.md`;
     const doc = `# ${opts.title}
 Source: ${opts.source}
 
@@ -37443,10 +38869,10 @@ async function persistScrapeBody(user, opts) {
 }
 
 // src/api/scrape-image-sink.ts
-import { createHash as createHash24 } from "crypto";
+import { createHash as createHash25 } from "crypto";
 var MAX_IMAGES_PER_SCRAPE = 25;
 function idempotencyKey2(userId, vault, input) {
-  return `scrape-image-${createHash24("sha256").update(`${userId}\0${vault}\0${input.sourceKind}\0${input.sourceUrl}\0${input.imageUrl ?? ""}\0${input.imageBase64 ?? ""}`).digest("hex")}`;
+  return `scrape-image-${createHash25("sha256").update(`${userId}\0${vault}\0${input.sourceKind}\0${input.sourceUrl}\0${input.imageUrl ?? ""}\0${input.imageBase64 ?? ""}`).digest("hex")}`;
 }
 async function persistScrapeImagesToMemory(user, inputs, vault) {
   const selected = inputs.slice(0, MAX_IMAGES_PER_SCRAPE);
@@ -37490,7 +38916,7 @@ async function persistScrapeImagesToMemory(user, inputs, vault) {
 }
 
 // src/api/archive-reader.ts
-import { basename, extname } from "path";
+import { basename as basename2, extname as extname2 } from "path";
 import yauzl from "yauzl";
 var MAX_ARCHIVE_DOWNLOAD_BYTES = 50 * 1024 * 1024;
 var MAX_ARCHIVE_ENTRIES = 1e4;
@@ -37545,9 +38971,9 @@ var ArchiveReadError = class extends Error {
   retryable;
 };
 function readableContentType(path5) {
-  const extensionType = READABLE_EXTENSIONS.get(extname(path5).toLowerCase());
+  const extensionType = READABLE_EXTENSIONS.get(extname2(path5).toLowerCase());
   if (extensionType) return extensionType;
-  return READABLE_FILENAMES.has(basename(path5).toLowerCase()) ? "text/plain" : null;
+  return READABLE_FILENAMES.has(basename2(path5).toLowerCase()) ? "text/plain" : null;
 }
 function safeEntryPath(path5) {
   const normalized = path5.replaceAll("\\", "/");
@@ -37908,7 +39334,7 @@ function archiveLibrarySource(archiveUrl, path5) {
   return source.href;
 }
 function archiveEntryTitle(path5) {
-  return basename(path5).slice(0, 200) || "Archive entry";
+  return basename2(path5).slice(0, 200) || "Archive entry";
 }
 function inferredWaybackCapturedAt(content) {
   const timestamp = content.slice(0, 4e3).match(/^Archive timestamp:\s*(\d{14})\s*$/m)?.[1];
@@ -37918,7 +39344,7 @@ function inferredWaybackCapturedAt(content) {
 }
 
 // src/api/connection-memory-import.ts
-import { createHash as createHash25 } from "crypto";
+import { createHash as createHash26 } from "crypto";
 var CONNECTION_MEMORY_IMPORT_MAX_ARGS_BYTES = 64 * 1024;
 var CONNECTION_MEMORY_IMPORT_MAX_RESULT_BYTES = 1e6;
 var CONNECTION_MEMORY_IMPORT_MAX_STRING_CHARS = 256e3;
@@ -37948,7 +39374,7 @@ function canonicalJson(value) {
   return JSON.stringify(value);
 }
 function sha2562(value) {
-  return createHash25("sha256").update(value).digest("hex");
+  return createHash26("sha256").update(value).digest("hex");
 }
 function sensitiveKey(key) {
   const normalized = key.toLowerCase().replace(/[^a-z0-9]/g, "");
@@ -38166,17 +39592,17 @@ async function importServiceConnectionToMemory(identity, input, dependencies) {
 
 // src/api/scrape-blob-cleanup.ts
 import { readdir, stat, unlink } from "fs/promises";
-import { homedir as homedir2 } from "os";
-import { join as join7 } from "path";
-async function cleanupVercel(token4, cutoff) {
+import { homedir as homedir4 } from "os";
+import { join as join9 } from "path";
+async function cleanupVercel(token6, cutoff) {
   const { list, del } = await import("@vercel/blob");
   let cursor;
   let deleted = 0;
   do {
-    const res = await list({ prefix: SCRAPE_FALLBACK_PREFIX, cursor, token: token4 });
+    const res = await list({ prefix: SCRAPE_FALLBACK_PREFIX, cursor, token: token6 });
     const expired = res.blobs.filter((b) => new Date(b.uploadedAt).getTime() < cutoff);
     if (expired.length) {
-      await del(expired.map((b) => b.url), { token: token4 });
+      await del(expired.map((b) => b.url), { token: token6 });
       deleted += expired.length;
     }
     cursor = res.hasMore ? res.cursor : void 0;
@@ -38184,8 +39610,8 @@ async function cleanupVercel(token4, cutoff) {
   return { deleted, store: "vercel-blob" };
 }
 async function cleanupLocal(cutoff) {
-  const baseDir = process.env.MCP_SCRAPER_OUTPUT_DIR?.trim() || join7(homedir2(), "Downloads", "mcp-scraper");
-  const dir = join7(baseDir, "blobs", SCRAPE_FALLBACK_PREFIX.replace(/\/$/, ""));
+  const baseDir = process.env.MCP_SCRAPER_OUTPUT_DIR?.trim() || join9(homedir4(), "Downloads", "mcp-scraper");
+  const dir = join9(baseDir, "blobs", SCRAPE_FALLBACK_PREFIX.replace(/\/$/, ""));
   let deleted = 0;
   let entries;
   try {
@@ -38194,7 +39620,7 @@ async function cleanupLocal(cutoff) {
     return { deleted: 0, store: "local" };
   }
   for (const name of entries) {
-    const path5 = join7(dir, name);
+    const path5 = join9(dir, name);
     try {
       const s = await stat(path5);
       if (s.isFile() && s.mtimeMs < cutoff) {
@@ -38209,8 +39635,8 @@ async function cleanupLocal(cutoff) {
 async function cleanupExpiredScrapeBlobs(maxAgeMs = SCRAPE_BLOB_TTL_MS) {
   const cutoff = Date.now() - maxAgeMs;
   try {
-    const token4 = process.env.BLOB_READ_WRITE_TOKEN;
-    return token4 ? await cleanupVercel(token4, cutoff) : await cleanupLocal(cutoff);
+    const token6 = process.env.BLOB_READ_WRITE_TOKEN;
+    return token6 ? await cleanupVercel(token6, cutoff) : await cleanupLocal(cutoff);
   } catch {
     return { deleted: 0, store: "none" };
   }
@@ -38959,7 +40385,7 @@ async function dbUsage(identity, plan) {
 }
 
 // src/api/nango-control.ts
-import { createHash as createHash27, randomUUID as randomUUID22 } from "crypto";
+import { createHash as createHash28, randomUUID as randomUUID22 } from "crypto";
 
 // src/api/slack-archive-analysis.ts
 function isRecord2(value) {
@@ -39333,7 +40759,7 @@ async function exportSlackChannelPage(input, dependencies) {
 }
 
 // src/api/main-nango-transport.ts
-import { createHash as createHash26, randomUUID as randomUUID21 } from "crypto";
+import { createHash as createHash27, randomUUID as randomUUID21 } from "crypto";
 import { Client, StreamableHTTPClientTransport } from "@modelcontextprotocol/client";
 
 // src/api/connected-tool-policy.ts
@@ -39376,9 +40802,9 @@ function buildConnectedToolPolicyRegistry(args) {
   return policies;
 }
 function connectedToolPolicyOrThrow(registry, toolName) {
-  const policy4 = registry.get(toolName);
-  if (!policy4) throw new Error("connected_tool_policy_missing");
-  return policy4;
+  const policy6 = registry.get(toolName);
+  if (!policy6) throw new Error("connected_tool_policy_missing");
+  return policy6;
 }
 
 // src/api/main-nango-transport.ts
@@ -39724,9 +41150,9 @@ async function listNangoToolsDirect(identity, connectionId) {
     connectionActive: connection.lifecycleStatus === "connected",
     actionsEnabled: connection.actionsEnabled
   });
-  const readTools = [...policies.values()].filter((policy4) => policy4.classification === "read").map((policy4) => policy4.name);
-  const actionTools = [...policies.values()].filter((policy4) => policy4.classification === "action").map((policy4) => policy4.name);
-  const revision = createHash26("sha256").update(JSON.stringify(tools.map((tool) => ({ name: tool.name, inputSchema: tool.inputSchema })))).digest("hex");
+  const readTools = [...policies.values()].filter((policy6) => policy6.classification === "read").map((policy6) => policy6.name);
+  const actionTools = [...policies.values()].filter((policy6) => policy6.classification === "action").map((policy6) => policy6.name);
+  const revision = createHash27("sha256").update(JSON.stringify(tools.map((tool) => ({ name: tool.name, inputSchema: tool.inputSchema })))).digest("hex");
   await updateServiceConnectionTools(connection.id, readTools, actionTools, revision);
   const refreshed = await getOwnedServiceConnection(identity, connection.id);
   return { connection: refreshed ?? { ...connection, readTools, actionTools, toolRevision: revision }, tools };
@@ -39735,18 +41161,18 @@ async function callNangoToolDirect(args) {
   const { connection, tools } = await listNangoToolsDirect(args.identity, args.connectionId);
   const selected = tools.find((tool) => tool.name === args.tool);
   if (!selected) throw new MainNangoTransportError("The requested provider tool is unavailable.", 404, "live_tool_missing", false);
-  const policy4 = connectedToolPolicyOrThrow(buildConnectedToolPolicyRegistry({
+  const policy6 = connectedToolPolicyOrThrow(buildConnectedToolPolicyRegistry({
     tools,
     connectionActive: connection.lifecycleStatus === "connected",
     actionsEnabled: connection.actionsEnabled
   }), selected.name);
-  if (policy4.classification !== args.classification) {
+  if (policy6.classification !== args.classification) {
     throw new MainNangoTransportError("The provider tool classification does not match this operation.", 403, "tool_not_allowed", false);
   }
-  if (!policy4.available && policy4.blockedReason === "actions_disabled") {
+  if (!policy6.available && policy6.blockedReason === "actions_disabled") {
     throw new MainNangoTransportError("Actions are disabled for this service connection.", 403, "actions_disabled", false);
   }
-  if (!policy4.available) {
+  if (!policy6.available) {
     throw new MainNangoTransportError("The provider tool is not authorized for this connection.", 403, "tool_not_allowed", false);
   }
   await preflightConnectedUsage({
@@ -39754,7 +41180,7 @@ async function callNangoToolDirect(args) {
     ratePolicyVersion: CONNECTED_USAGE_RATE_POLICY_VERSION
   });
   const requestId = args.requestId?.trim() || randomUUID21();
-  const idempotencyKey3 = `main-nango:${createHash26("sha256").update(args.identity.toLowerCase()).update("\0").update(connection.id).update("\0").update(args.tool).update("\0").update(requestId).digest("hex")}`;
+  const idempotencyKey3 = `main-nango:${createHash27("sha256").update(args.identity.toLowerCase()).update("\0").update(connection.id).update("\0").update(args.tool).update("\0").update(requestId).digest("hex")}`;
   const startedAt = /* @__PURE__ */ new Date();
   const started = performance.now();
   let result;
@@ -39779,7 +41205,7 @@ async function callNangoToolDirect(args) {
       toolName: args.tool,
       operationKind: args.operationKind ?? args.classification,
       outcome: providerError ? "error" : "partial",
-      requestId: requestId.length <= 200 ? requestId : createHash26("sha256").update(requestId).digest("hex"),
+      requestId: requestId.length <= 200 ? requestId : createHash27("sha256").update(requestId).digest("hex"),
       startedAt: startedAt.toISOString(),
       completedAt: completedAt.toISOString()
     }
@@ -39791,13 +41217,13 @@ async function describeNangoToolDirect(identity, connectionId, toolName) {
   const { connection, tools } = await listNangoToolsDirect(identity, connectionId);
   const tool = tools.find((candidate) => candidate.name === toolName);
   if (!tool) throw new MainNangoTransportError("The requested provider tool is unavailable.", 404, "live_tool_missing", false);
-  const policy4 = connectedToolPolicyOrThrow(buildConnectedToolPolicyRegistry({
+  const policy6 = connectedToolPolicyOrThrow(buildConnectedToolPolicyRegistry({
     tools,
     connectionActive: connection.lifecycleStatus === "connected",
     actionsEnabled: connection.actionsEnabled
   }), tool.name);
   const classification = classifyConnectedTool(tool);
-  const callable = policy4.available;
+  const callable = policy6.available;
   const projected = {
     name: tool.name,
     ...tool.title ? { title: tool.title } : {},
@@ -39810,18 +41236,18 @@ async function describeNangoToolDirect(identity, connectionId, toolName) {
     ...projected,
     classification,
     callable,
-    blockedReason: policy4.blockedReason,
-    requiredPermissions: policy4.requiredPermissions,
-    missingPermissions: policy4.missingPermissions,
-    requiredFeatures: policy4.requiredFeatures,
-    missingFeatures: policy4.missingFeatures,
+    blockedReason: policy6.blockedReason,
+    requiredPermissions: policy6.requiredPermissions,
+    missingPermissions: policy6.missingPermissions,
+    requiredFeatures: policy6.requiredFeatures,
+    missingFeatures: policy6.missingFeatures,
     transport: "nango",
     providerConfigKey: connection.providerConfigKey,
     providerContractVersion: MAIN_INTEGRATION_CONTRACT_VERSION,
     providerContractHash: MAIN_INTEGRATION_CONTRACT_HASH,
     protocolVersion: null,
     schemaSource: "live_tools_list",
-    schemaHash: createHash26("sha256").update(JSON.stringify(projected)).digest("hex"),
+    schemaHash: createHash27("sha256").update(JSON.stringify(projected)).digest("hex"),
     fetchedAt: (/* @__PURE__ */ new Date()).toISOString()
   };
 }
@@ -40545,8 +41971,8 @@ async function setScheduleConnectionActionsEnabled(identity, connectionId, enabl
   return data.connection.actionsEnabled === true;
 }
 async function callScheduleConnectionAction(identity, connectionId, input, tool, idempotencyKey3) {
-  const requestId = `main-connected-action:${createHash27("sha256").update(identity).update("\0").update(idempotencyKey3?.trim() || randomUUID22()).digest("hex")}`;
-  const requestDigest = createHash27("sha256").update(connectionId).update("\0").update(tool?.trim() ?? "").update("\0").update(canonicalJson2(input)).digest("hex");
+  const requestId = `main-connected-action:${createHash28("sha256").update(identity).update("\0").update(idempotencyKey3?.trim() || randomUUID22()).digest("hex")}`;
+  const requestDigest = createHash28("sha256").update(connectionId).update("\0").update(tool?.trim() ?? "").update("\0").update(canonicalJson2(input)).digest("hex");
   if (mainOwnsIntegrations()) {
     const selectedTool = tool?.trim();
     if (!selectedTool) throw new NangoControlError("An action tool is required.", 400, "invalid_request", false);
@@ -40697,7 +42123,7 @@ function canonicalJson2(value) {
   return JSON.stringify(value);
 }
 function projectedToolSchemaHash(tool) {
-  return createHash27("sha256").update(canonicalJson2(tool)).digest("hex");
+  return createHash28("sha256").update(canonicalJson2(tool)).digest("hex");
 }
 async function describeNangoTool(identity, connectionId, tool, fresh) {
   if (mainOwnsIntegrations()) {
@@ -40976,7 +42402,7 @@ async function callMainOwnedExportPage(identity, input) {
 }
 
 // src/api/resend-control.ts
-import { createHash as createHash28 } from "crypto";
+import { createHash as createHash29 } from "crypto";
 var DEFAULT_CONNECTION_CONTROL_URL = "https://mcp-scraper-scheduler.vercel.app";
 var RESEND_PROVIDER_CONFIG_KEY = "resend";
 var RESEND_LOGO_URL = "https://cdn.resend.com/brand/resend-icon-black.svg";
@@ -41235,7 +42661,7 @@ async function callResendRead(identity, connectionId, tool, args) {
   return isRecord5(data) ? data.result ?? data : data;
 }
 async function callResendAction(identity, connectionId, tool, input, idempotencyKey3) {
-  const requestId = `main-resend-action:${createHash28("sha256").update(identity).update("\0").update(idempotencyKey3.trim()).digest("hex")}`;
+  const requestId = `main-resend-action:${createHash29("sha256").update(identity).update("\0").update(idempotencyKey3.trim()).digest("hex")}`;
   const body = await controlRequest2("/api/internal/resend/actions/call", {
     method: "POST",
     headers: { "x-request-id": requestId },
@@ -41362,9 +42788,9 @@ var auth4 = createMiddleware5(async (c, next) => {
   return next();
 });
 var sessionAuth = createMiddleware5(async (c, next) => {
-  const token4 = getCookie2(c, "session");
-  if (!token4) return c.json({ error: "Not authenticated" }, 401);
-  const userId = verifySession(token4);
+  const token6 = getCookie2(c, "session");
+  if (!token6) return c.json({ error: "Not authenticated" }, 401);
+  const userId = verifySession(token6);
   if (!userId) return c.json({ error: "Session expired" }, 401);
   const user = await getUserById(userId);
   if (!user) return c.json({ error: "User not found" }, 401);
@@ -41509,8 +42935,8 @@ app.post("/auth/register", requireAllowedOrigin, async (c) => {
         console.warn("[auth/register] memory provision failed (will retry on first write):", err instanceof Error ? err.message : String(err));
       }
     })();
-    const token4 = signSession(user.id);
-    setCookie2(c, "session", token4, sessionCookieOptions2);
+    const token6 = signSession(user.id);
+    setCookie2(c, "session", token6, sessionCookieOptions2);
     return c.json({ email: user.email, api_key: newKey }, 201);
   } catch (err) {
     const msg = err instanceof Error ? err.message : "";
@@ -41528,8 +42954,8 @@ app.post("/auth/login", requireAllowedOrigin, async (c) => {
   if (!user || !user.password_hash || !verifyPassword(password, user.password_hash)) {
     return c.json({ error: "Invalid email or password" }, 401);
   }
-  const token4 = signSession(user.id);
-  setCookie2(c, "session", token4, sessionCookieOptions2);
+  const token6 = signSession(user.id);
+  setCookie2(c, "session", token6, sessionCookieOptions2);
   return c.json({ email: user.email, api_key: user.key_active ? user.api_key : null });
 });
 app.post("/auth/logout", requireAllowedOrigin, (c) => {
@@ -41584,9 +43010,9 @@ app.post("/auth/forgot-password", requireAllowedOrigin, async (c) => {
   if (emailLimited) return emailLimited;
   const user = await getUserByEmail(normalizedEmail);
   if (!user) return c.json({ ok: true });
-  const token4 = await createPasswordResetToken(user.id);
+  const token6 = await createPasswordResetToken(user.id);
   const appUrl = process.env.APP_URL ?? "https://mcpscraper.dev";
-  const resetUrl = `${appUrl}/reset-password?token=${token4}`;
+  const resetUrl = `${appUrl}/reset-password?token=${token6}`;
   if (process.env.RESEND_API_KEY) {
     try {
       const resend = new Resend3(process.env.RESEND_API_KEY);
@@ -41606,12 +43032,12 @@ app.post("/auth/forgot-password", requireAllowedOrigin, async (c) => {
   return c.json({ ok: true });
 });
 app.post("/auth/reset-password", requireAllowedOrigin, async (c) => {
-  const { token: token4, password } = await c.req.json();
-  if (!token4 || !password) return c.json({ error: "Token and password required" }, 400);
+  const { token: token6, password } = await c.req.json();
+  if (!token6 || !password) return c.json({ error: "Token and password required" }, 400);
   if (password.length < 8) return c.json({ error: "Password must be at least 8 characters" }, 400);
   const limited = await enforceRateLimit(c, "auth_reset", rateLimitKey(c), 10, 60 * 60);
   if (limited) return limited;
-  const userId = await consumePasswordResetToken(token4);
+  const userId = await consumePasswordResetToken(token6);
   if (!userId) return c.json({ error: "Invalid or expired reset link" }, 400);
   await setPassword(userId, password);
   return c.json({ ok: true });
@@ -41648,9 +43074,9 @@ function sessionBootstrapPayload(user) {
 }
 app.get("/me", async (c) => {
   c.header("Cache-Control", "no-store");
-  const token4 = getCookie2(c, "session");
-  if (!token4) return c.json({ authenticated: false });
-  const userId = verifySession(token4);
+  const token6 = getCookie2(c, "session");
+  if (!token6) return c.json({ authenticated: false });
+  const userId = verifySession(token6);
   if (!userId) {
     deleteCookie(c, "session", { path: "/", secure: secureCookies2, sameSite: "Strict" });
     return c.json({ authenticated: false });
@@ -43276,6 +44702,8 @@ app.post("/extract-url", auth4, async (c) => {
   }
   const effectiveDelivery = bodyResult.data.depositToVault ? "memory" : requestedDelivery;
   const preserveMedia = bodyResult.data.preserveMedia ?? bodyResult.data.downloadMedia ?? false;
+  const maxMediaAssets = bodyResult.data.maxMediaAssets ?? 100;
+  const maxInlineImages = bodyResult.data.maxInlineImages ?? 3;
   if (!allowLocal) {
     const checked = await validatePublicHttpUrl(url, { field: "URL" });
     if (checked.error || !checked.parsed) return c.json({ error: checked.error ?? "Invalid URL" }, 400);
@@ -43310,7 +44738,14 @@ app.post("/extract-url", auth4, async (c) => {
     const device = screenshotDevice === "mobile" ? "mobile" : "desktop";
     const [result, pageData] = await Promise.all([
       extractKpo({ url: extractionUrl, kernelApiKey }),
-      screenshot2 || extractBranding2 ? capturePageData(canonicalUrl, { kernelApiKey, device, screenshot: !!screenshot2, branding: !!extractBranding2 }).catch((err) => {
+      screenshot2 || extractBranding2 || preserveMedia ? capturePageData(canonicalUrl, {
+        kernelApiKey,
+        device,
+        screenshot: !!screenshot2,
+        branding: !!extractBranding2,
+        media: preserveMedia,
+        maxMediaAssets: Math.min(1e3, Math.max(250, maxMediaAssets * 4))
+      }).catch((err) => {
         console.error("[extract-url] capturePageData failed:", err instanceof Error ? err.message : err);
         return null;
       }) : null
@@ -43321,7 +44756,28 @@ app.post("/extract-url", auth4, async (c) => {
     if (screenshotBuf) {
       screenshotMeta = { base64: screenshotBuf.toString("base64"), sizeBytes: screenshotBuf.length, device };
     }
-    const mediaMeta = preserveMedia ? await harvestPageMedia(result.bodyHtml, waybackReplay?.originalUrl ?? canonicalUrl, { types: mediaTypes ?? ["image", "video", "audio"], outputDir: null }) : null;
+    let mediaMeta = preserveMedia ? await harvestPageMedia(result.bodyHtml, waybackReplay?.originalUrl ?? canonicalUrl, {
+      types: mediaTypes ?? ["image", "video", "audio"],
+      outputDir: null,
+      rendered: pageData?.renderedMedia ?? null,
+      maxAssets: maxMediaAssets
+    }) : null;
+    if (mediaMeta) {
+      try {
+        const packaged = await packagePageMedia({
+          ownerId: String(user.id),
+          pageUrl: canonicalUrl,
+          title: result.title ?? null,
+          extractedAt: (/* @__PURE__ */ new Date()).toISOString(),
+          media: mediaMeta,
+          maxInlineImages
+        });
+        mediaMeta = packaged.media;
+        mediaMeta.artifact = packaged.artifact;
+      } catch (error) {
+        mediaMeta.warnings.push(`Media packaging failed: ${error instanceof Error ? error.message : "media_packaging_failed"}`);
+      }
+    }
     const featuredImage = includeFeaturedImage ? resolveFeaturedImage({
       html: result.bodyHtml,
       meta: result.meta,
@@ -43504,7 +44960,7 @@ app.post("/archive/read", auth4, async (c) => {
   try {
     let ownedArchive = null;
     if (artifactId) {
-      const buffer = await readOwnedSiteExtractArtifactBuffer({ artifactId, ownerId: String(user.id) });
+      const buffer = artifactId.startsWith(MAPS_MEDIA_ARTIFACT_PREFIX) ? await readOwnedMapsMediaArtifactBuffer({ artifactId, ownerId: String(user.id) }) : artifactId.startsWith(PAGE_MEDIA_ARTIFACT_PREFIX) ? await readOwnedPageMediaArtifactBuffer({ artifactId, ownerId: String(user.id) }) : await readOwnedSiteExtractArtifactBuffer({ artifactId, ownerId: String(user.id) });
       if (!buffer) throw new ArchiveReadError("archive_not_found", "Archive artifact was not found or has expired.", 404);
       ownedArchive = { buffer, ref: artifactId };
     }
@@ -44314,7 +45770,7 @@ app.get("/cron/tick", async (c) => {
     return c.json({ error: "Unauthorized" }, 401);
   }
   const startedAt = Date.now();
-  const { drainQueue } = await import("./worker-KQN673JF.js");
+  const { drainQueue } = await import("./worker-JL4TG6IF.js");
   const budget = { maxJobs: 10, deadlineMs: startedAt + CRON_TICK_DRAIN_BUDGET_MS };
   const origin = `${new URL(c.req.url).protocol}//${new URL(c.req.url).host}`;
   const unfinished = [];
@@ -44385,7 +45841,7 @@ app.post("/api/internal/extract-refinalize/:id", async (c) => {
     terminalExtractJobStatus: terminalExtractJobStatus2,
     extractJobLimitInfo: extractJobLimitInfo2
   } = await import("./site-extract-repository-3VQAALNR.js");
-  const { assembleExtractArtifacts } = await import("./extract-bundle-RCTNANCH.js");
+  const { assembleExtractArtifacts } = await import("./extract-bundle-GUEUCTAE.js");
   const existing = await getExtractJob2(jobId2);
   if (!existing) return c.json({ error: "job not found" }, 404);
   if (existing.status !== "failed") {
@@ -44597,4 +46053,4 @@ app.get("/blog/:slug/", (c) => {
 export {
   app
 };
-//# sourceMappingURL=server-KAEHVDY7.js.map
+//# sourceMappingURL=server-7EXEDKAU.js.map