mcp-scraper 0.40.2 → 0.40.3

package/dist/bin/api-server.cjs

@@ -76,14 +76,48 @@ var init_browser_service_env = __esm({
 });
 
 // src/errors.ts
+function normalizePublicErrorCode(code) {
+  return typeof code === "string" && PUBLIC_ERROR_CODES.has(code) ? code : "service_unavailable";
+}
+function publicErrorMessage(code) {
+  switch (normalizePublicErrorCode(code)) {
+    case "request_aborted":
+      return "The request was cancelled before it completed.";
+    case "captcha_exhausted":
+    case "captcha_or_blocked":
+      return "The target site returned a verification challenge. Please retry later.";
+    case "location_mismatch":
+      return "The target site returned results for a different location. Please retry.";
+    case "proxy_tunnel_failed":
+    case "proxy_unavailable":
+      return "The web request could not establish a working connection. Please retry later.";
+    case "harvest_timeout":
+    case "mcp_request_timeout":
+      return "The request timed out before it completed. Please retry with a smaller request.";
+    default:
+      return PUBLIC_SERVICE_UNAVAILABLE_MESSAGE;
+  }
+}
 function sanitizeVendorName(message) {
   return message.replace(/kernel\.sh\s+sessions?/gi, "sessions").replace(/kernel\.sh\s+session/gi, "this session").replace(/kernel\.sh/gi, "the service").replace(/kernel\s+sessions?/gi, "sessions").replace(/kernel\s+session/gi, "this session").replace(/\bkernel\b/gi, "the service").replace(/  +/g, " ").trim();
 }
-var RECAPTCHA_INSTRUCTIONS, CaptchaError, ExtractionError, MapsSearchIncompletePageError, RequestAbortedError, LocationMismatchError;
+var RECAPTCHA_INSTRUCTIONS, PUBLIC_SERVICE_UNAVAILABLE_MESSAGE, PUBLIC_ERROR_CODES, CaptchaError, ExtractionError, MapsSearchIncompletePageError, RequestAbortedError, LocationMismatchError;
 var init_errors = __esm({
   "src/errors.ts"() {
     "use strict";
     RECAPTCHA_INSTRUCTIONS = "Google returned a CAPTCHA. Run with --headless=false to re-warm the browser profile, then retry.";
+    PUBLIC_SERVICE_UNAVAILABLE_MESSAGE = "This operation is temporarily unavailable. Please retry later.";
+    PUBLIC_ERROR_CODES = /* @__PURE__ */ new Set([
+      "request_aborted",
+      "captcha_exhausted",
+      "captcha_or_blocked",
+      "location_mismatch",
+      "proxy_tunnel_failed",
+      "proxy_unavailable",
+      "harvest_timeout",
+      "mcp_request_timeout",
+      "service_unavailable"
+    ]);
     CaptchaError = class extends Error {
       constructor(instructions) {
         super(`CAPTCHA detected. ${instructions}`);
@@ -130,8 +164,8 @@ function redactVendorUrls(value) {
 function sanitizeOutboundDiagnostics(value, parentKey = "") {
   if (typeof value === "string") {
     let out = redactVendorUrls(value);
-    if (SANITIZED_VALUE_KEYS.test(parentKey) && /kernel/i.test(out)) {
-      out = sanitizeVendorName(out);
+    if (SANITIZED_VALUE_KEYS.test(parentKey)) {
+      out = publicErrorMessage("service_unavailable");
     }
     return out;
   }
@@ -139,6 +173,7 @@ function sanitizeOutboundDiagnostics(value, parentKey = "") {
   if (value !== null && typeof value === "object") {
     const out = {};
     for (const [key, val] of Object.entries(value)) {
+      if (INTERNAL_DIAGNOSTIC_KEYS.has(key)) continue;
       const renamed = KEY_RENAMES[key] ?? key;
       if (VENDOR_URL_KEYS.has(key)) {
         out[renamed] = null;
@@ -164,24 +199,47 @@ function sanitizeHarvestResult(result) {
     }
   };
 }
-var KEY_RENAMES, SANITIZED_VALUE_KEYS, VENDOR_URL_KEYS, VENDOR_URL_RE;
+var KEY_RENAMES, SANITIZED_VALUE_KEYS, INTERNAL_DIAGNOSTIC_KEYS, VENDOR_URL_KEYS, VENDOR_URL_RE;
 var init_outbound_sanitize = __esm({
   "src/api/outbound-sanitize.ts"() {
     "use strict";
     init_errors();
     KEY_RENAMES = {
-      kernel: "browserRuntime",
-      kernel_session_id: "browser_session_id",
-      kernel_delete_started: "session_cleanup_started",
-      kernel_delete_succeeded: "session_cleanup_succeeded",
-      kernel_delete_error: "session_cleanup_error",
-      kernelSessionId: "browserSessionId",
-      kernelDeleteStarted: "sessionCleanupStarted",
-      kernelDeleteSucceeded: "sessionCleanupSucceeded",
-      kernelDeleteError: "sessionCleanupError",
-      kernelProxyId: "proxyId"
+      kernel: "browserRuntime"
     };
     SANITIZED_VALUE_KEYS = /error|message/i;
+    INTERNAL_DIAGNOSTIC_KEYS = /* @__PURE__ */ new Set([
+      "kernel_session_id",
+      "browser_session_id",
+      "kernelSessionId",
+      "browserSessionId",
+      "sessionId",
+      "kernel_delete_started",
+      "session_cleanup_started",
+      "kernelDeleteStarted",
+      "sessionCleanupStarted",
+      "kernel_delete_succeeded",
+      "session_cleanup_succeeded",
+      "kernelDeleteSucceeded",
+      "sessionCleanupSucceeded",
+      "kernel_delete_error",
+      "session_cleanup_error",
+      "kernelDeleteError",
+      "sessionCleanupError",
+      "kernelProxyId",
+      "proxyId",
+      "requestedProxyIdSuffix",
+      "retrievedProxyIdSuffix",
+      "provider",
+      "providerName",
+      "service",
+      "serviceName",
+      "vendor",
+      "vendorName",
+      "organization",
+      "organizationId",
+      "accountId"
+    ]);
     VENDOR_URL_KEYS = /* @__PURE__ */ new Set([
       "hosted_url",
       "hostedUrl",
@@ -3619,6 +3677,8 @@ __export(db_exports, {
   appendWorkflowArtifacts: () => appendWorkflowArtifacts,
   cancelJob: () => cancelJob,
   checkRateLimit: () => checkRateLimit,
+  checkpointJob: () => checkpointJob,
+  claimInngestPaaJob: () => claimInngestPaaJob,
   claimMonthlyFreeRefresh: () => claimMonthlyFreeRefresh,
   claimPendingJob: () => claimPendingJob,
   claimPendingKpoJob: () => claimPendingKpoJob,
@@ -3632,6 +3692,7 @@ __export(db_exports, {
   countActiveJobsForUser: () => countActiveJobsForUser,
   countActiveUsers: () => countActiveUsers,
   createJob: () => createJob,
+  createJobWithId: () => createJobWithId,
   createKpoJob: () => createKpoJob,
   createPasswordResetToken: () => createPasswordResetToken,
   createRunningJob: () => createRunningJob,
@@ -3685,7 +3746,10 @@ __export(db_exports, {
   listInboxMessages: () => listInboxMessages,
   listJobs: () => listJobs,
   listKpoJobs: () => listKpoJobs,
+  listPendingInngestPaaJobs: () => listPendingInngestPaaJobs,
+  listRecentTerminalInngestPaaJobs: () => listRecentTerminalInngestPaaJobs,
   listRequestEvents: () => listRequestEvents,
+  listStaleRunningInngestPaaJobs: () => listStaleRunningInngestPaaJobs,
   listUsers: () => listUsers,
   listUsersDueForConnectedAccountBillingReconciliation: () => listUsersDueForConnectedAccountBillingReconciliation,
   listWorkflowArtifacts: () => listWorkflowArtifacts,
@@ -3694,6 +3758,7 @@ __export(db_exports, {
   logKpoPhaseComplete: () => logKpoPhaseComplete,
   logRequestEvent: () => logRequestEvent,
   markInboxMessageOpened: () => markInboxMessageOpened,
+  markJobBillingSettled: () => markJobBillingSettled,
   markWorkflowRunRunning: () => markWorkflowRunRunning,
   markWorkflowScheduleRan: () => markWorkflowScheduleRan,
   migrate: () => migrate,
@@ -4977,11 +5042,15 @@ function deserialize(raw) {
 }
 async function createJob(userId, query, options, callbackUrl) {
   const id = (0, import_node_crypto.randomUUID)();
+  await createJobWithId(id, userId, query, options, callbackUrl);
+  return id;
+}
+async function createJobWithId(id, userId, query, options, callbackUrl) {
+  if (!/^[a-zA-Z0-9-]{1,100}$/.test(id)) throw new Error("job id is invalid");
   await getDb().execute({
     sql: "INSERT INTO jobs (id, user_id, query, options, callback_url) VALUES (?, ?, ?, ?, ?)",
     args: [id, userId, query, JSON.stringify(options), callbackUrl ?? null]
   });
-  return id;
 }
 async function createRunningJob(userId, query, options) {
   const id = (0, import_node_crypto.randomUUID)();
@@ -5511,7 +5580,13 @@ async function countActiveJobsForUser(userId) {
 }
 async function claimPendingJob() {
   const db = getDb();
-  const res = await db.execute(`SELECT * FROM jobs WHERE status = 'pending' ORDER BY created_at LIMIT 1`);
+  const res = await db.execute(`
+    SELECT * FROM jobs
+    WHERE status = 'pending'
+      AND COALESCE(json_extract(options, '$.executionOwner'), 'cron') != 'inngest'
+    ORDER BY created_at
+    LIMIT 1
+  `);
   const job = res.rows[0] ? rowToRawJob(res.rows[0]) : void 0;
   if (!job) return void 0;
   const upd = await db.execute({
@@ -5520,6 +5595,80 @@ async function claimPendingJob() {
   });
   return upd.rowsAffected === 0 ? void 0 : { ...job, status: "running" };
 }
+async function claimInngestPaaJob(id) {
+  const db = getDb();
+  const current = await getJob(id);
+  if (!current || current.options.executionOwner !== "inngest" || current.options.serpOnly === true) return void 0;
+  if (current.status === "running") return void 0;
+  if (current.status === "pending") {
+    const updated = await db.execute({
+      sql: `UPDATE jobs
+            SET status = 'running', started_at = COALESCE(started_at, datetime('now')), error = NULL
+            WHERE id = ? AND status = 'pending'`,
+      args: [id]
+    });
+    if (updated.rowsAffected === 0) return getJob(id);
+    return { ...current, status: "running", started_at: current.started_at ?? (/* @__PURE__ */ new Date()).toISOString() };
+  }
+  return current;
+}
+async function checkpointJob(id, result) {
+  const updated = await getDb().execute({
+    sql: `UPDATE jobs SET result = ? WHERE id = ? AND status = 'running'`,
+    args: [JSON.stringify(result), id]
+  });
+  return updated.rowsAffected === 1;
+}
+async function listPendingInngestPaaJobs(limit = 25) {
+  const safeLimit = Math.max(1, Math.min(100, Math.floor(limit)));
+  const rows = await getDb().execute({
+    sql: `SELECT * FROM jobs
+          WHERE status = 'pending'
+            AND json_extract(options, '$.executionOwner') = 'inngest'
+            AND COALESCE(json_extract(options, '$.serpOnly'), 0) = 0
+          ORDER BY created_at
+          LIMIT ?`,
+    args: [safeLimit]
+  });
+  return rows.rows.map((row) => deserialize(rowToRawJob(row)));
+}
+async function listRecentTerminalInngestPaaJobs(limit = 25) {
+  const safeLimit = Math.max(1, Math.min(100, Math.floor(limit)));
+  const rows = await getDb().execute({
+    sql: `SELECT * FROM jobs
+          WHERE status IN ('done', 'failed', 'cancelled')
+            AND json_extract(options, '$.executionOwner') = 'inngest'
+            AND json_extract(options, '$.billingDebitKey') IS NOT NULL
+            AND json_extract(options, '$.billingSettledAt') IS NULL
+          ORDER BY completed_at DESC
+          LIMIT ?`,
+    args: [safeLimit]
+  });
+  return rows.rows.map((row) => deserialize(rowToRawJob(row)));
+}
+async function listStaleRunningInngestPaaJobs(limit = 25) {
+  const safeLimit = Math.max(1, Math.min(100, Math.floor(limit)));
+  const rows = await getDb().execute({
+    sql: `SELECT * FROM jobs
+          WHERE status = 'running'
+            AND started_at <= datetime('now', '-10 minutes')
+            AND json_extract(options, '$.executionOwner') = 'inngest'
+          ORDER BY started_at
+          LIMIT ?`,
+    args: [safeLimit]
+  });
+  return rows.rows.map((row) => deserialize(rowToRawJob(row)));
+}
+async function markJobBillingSettled(id, billedMc, settledAt = (/* @__PURE__ */ new Date()).toISOString()) {
+  if (!Number.isSafeInteger(billedMc) || billedMc < 0) throw new Error("job billed amount must be a non-negative integer");
+  const updated = await getDb().execute({
+    sql: `UPDATE jobs
+          SET options = json_set(options, '$.billingSettledAt', ?, '$.billedMc', ?)
+          WHERE id = ?`,
+    args: [settledAt, billedMc, id]
+  });
+  return updated.rowsAffected === 1;
+}
 async function completeJob(id, result) {
   await getDb().execute({ sql: `UPDATE jobs SET status = 'done', result = ?, completed_at = datetime('now') WHERE id = ?`, args: [JSON.stringify(result), id] });
 }
@@ -15931,15 +16080,15 @@ function formatStructuredError(body, fallback) {
     return `Insufficient credits. Balance: ${body.balance_credits} credits. This call requires ${body.required_credits} credits. Top up at ${body.topup_url}`;
   }
   if (body.error === "mcp_request_timeout") {
-    return typeof body.message === "string" ? body.message : "MCP Scraper request timed out and was cancelled.";
+    return publicErrorMessage("mcp_request_timeout");
   }
   if (typeof body.error_code === "string") {
-    const message = typeof body.error === "string" ? body.error : typeof body.message === "string" ? body.message : fallback;
+    const code = normalizePublicErrorCode(body.error_code);
+    const message = publicErrorMessage(code);
     const retryable = body.retryable === true ? " Retryable: yes." : "";
-    return `${body.error_code}: ${message}${retryable}${errorAttemptsSection(body)}`;
+    return `${code}: ${message}${retryable}${errorAttemptsSection(body)}`;
   }
-  if (typeof body.error === "string") return body.error;
-  return fallback || "Tool error";
+  return publicErrorMessage("service_unavailable");
 }
 function parseData(raw) {
   const first = raw.content.find((b) => b.type === "text");
@@ -15950,7 +16099,7 @@ function parseData(raw) {
     const data = parsed.result ?? parsed;
     return { data };
   } catch {
-    if (raw.isError) return { error: sanitizeVendorText(text2 || "Tool error") };
+    if (raw.isError) return { error: publicErrorMessage("service_unavailable") };
     return { error: "Failed to parse tool response" };
   }
 }
@@ -15992,10 +16141,9 @@ function debugSection(debug) {
   const candidates = Array.isArray(locationEvidence?.candidates) ? locationEvidence.candidates.slice(0, 4).map((c) => `${c.city}, ${c.regionCode} (${c.count})`).join(", ") : "";
   const lines = [
     "\n## Debug",
-    `- Proxy mode: ${request.proxyMode ?? kernel.proxyMode ?? "unknown"} \xB7 requested proxy: ${kernel.requestedProxyIdPresent === true ? `yes (${kernel.requestedProxyIdSuffix ?? "redacted"})` : "no"}`,
-    `- Proxy resolution: ${proxyResolution.source ?? "unknown"}${proxyResolution.target ? ` \xB7 ${proxyResolution.target.level ?? "city"} ${proxyResolution.target.city}, ${proxyResolution.target.state}` : ""}${proxyResolution.error ? ` \xB7 ${truncate(proxyResolution.error, 180)}` : ""}`,
-    `- Browser session: ${kernel.sessionId ?? "unknown"} \xB7 retrieved proxy: ${kernel.retrievedProxyIdPresent === true ? `yes (${kernel.retrievedProxyIdSuffix ?? "redacted"})` : kernel.retrievedProxyIdPresent === false ? "no" : "unknown"}`,
-    `- Browser IP geo: ${[network.ip, network.city, network.region, network.country].filter(Boolean).join(" \xB7 ") || network.error || "unknown"}`,
+    `- Proxy mode: ${request.proxyMode ?? kernel.proxyMode ?? "unknown"}`,
+    `- Proxy resolution: ${proxyResolution.target ? `${proxyResolution.target.level ?? "city"} ${proxyResolution.target.city}, ${proxyResolution.target.state}` : proxyResolution.error ? publicErrorMessage("service_unavailable") : "unknown"}`,
+    `- Browser IP geo: ${[network.ip, network.city, network.region, network.country].filter(Boolean).join(" \xB7 ") || (network.error ? publicErrorMessage("service_unavailable") : "unknown")}`,
     `- Google URL: ${truncate(nav.requestedUrl, 240) || "unknown"}`,
     `- Final URL: ${truncate(nav.finalUrl, 240) || "unknown"} \xB7 CAPTCHA: ${nav.captchaDetected === true ? "yes" : nav.captchaDetected === false ? "no" : "unknown"} \xB7 redirected: ${nav.redirected === true ? "yes" : nav.redirected === false ? "no" : "unknown"}`
   ];
@@ -16011,7 +16159,6 @@ function errorAttemptsSection(body) {
     const debug = attempt.debug ?? {};
     const browser = debug.browser ?? {};
     const kernel = browser.browserRuntime ?? browser.kernel ?? {};
-    const proxyResolution = kernel.proxyResolution ?? {};
     const network = browser.networkLocation ?? {
       ip: attempt.observedIp ?? attempt.observed_ip,
       city: attempt.observedCity ?? attempt.observed_city,
@@ -16019,10 +16166,7 @@ function errorAttemptsSection(body) {
     };
     const nav = browser.serpNavigation ?? {};
     const geo = [network.ip, network.city, network.region].filter(Boolean).join(" / ") || "geo unknown";
-    const sessionId = attempt.browser_session_id ?? attempt.browserSessionIdSuffix ?? attempt.kernel_session_id ?? kernel.sessionId ?? "unknown";
-    const cleanupSucceeded2 = attempt.session_cleanup_succeeded ?? attempt.kernel_delete_succeeded;
-    const proxySource = proxyResolution.source ?? attempt.proxyResolutionSource;
-    return `- Attempt ${attempt.attempt_number ?? attempt.attemptNumber ?? "?"}: ${attempt.outcome ?? attempt.status ?? "unknown"} \xB7 session ${sessionId} \xB7 proxy ${debug.request?.proxyMode ?? kernel.proxyMode ?? attempt.proxyMode ?? "unknown"}${proxySource ? `/${proxySource}` : ""} \xB7 ${geo} \xB7 CAPTCHA ${nav.captchaDetected === true ? "yes" : nav.captchaDetected === false ? "no" : "unknown"} \xB7 cleanup ${cleanupSucceeded2 === true ? "yes" : cleanupSucceeded2 === false ? "no" : "unknown"}`;
+    return `- Attempt ${attempt.attempt_number ?? attempt.attemptNumber ?? "?"}: ${attempt.outcome ?? attempt.status ?? "unknown"} \xB7 proxy mode ${debug.request?.proxyMode ?? kernel.proxyMode ?? attempt.proxyMode ?? "unknown"} \xB7 ${geo} \xB7 verification challenge ${nav.captchaDetected === true ? "yes" : nav.captchaDetected === false ? "no" : "unknown"}`;
   });
   return `
 
@@ -18533,6 +18677,9 @@ var init_selectors = __esm({
       itemDataInitQ: "data-initq",
       itemQuestionEl: ".JlqpRe",
       answerContainer: ".bCOlv, .hgKElc, .wDYxhc, .LGOjhe, .fo7IQd, .fmW3u",
+      aiAnswerBody: ".pWvJNd",
+      aiCitation: "a.PMDqCb[href]",
+      aiSourceCard: "a.vIWmYe[href], a.Zbfntb[href]",
       sourceTitle: "h3",
       sourceSite: ".VuuXrf",
       sourceCite: "cite",
@@ -23182,6 +23329,968 @@ var init_directory_workflow2 = __esm({
   }
 });
 
+// src/api/paa-capture-artifacts.ts
+function paaCaptureArtifactPolicy() {
+  return {
+    prefix: PAA_CAPTURE_ARTIFACT_PREFIX,
+    artifactTtlMs: 7 * DAY_MS,
+    downloadTtlMs: 15 * 60 * 1e3,
+    token: process.env.PAA_CAPTURE_BLOB_READ_WRITE_TOKEN ?? process.env.BLOB_READ_WRITE_TOKEN ?? null
+  };
+}
+async function createPaaRawDomArtifact(input) {
+  return createPrivateArtifact({
+    policy: paaCaptureArtifactPolicy(),
+    ownerId: String(input.userId),
+    artifactKey: `${input.jobId}-attempt-${input.attempt}.html.gz`,
+    createdAt: input.createdAt ?? /* @__PURE__ */ new Date(),
+    filename: `${input.jobId}-serp.html.gz`,
+    contentType: "application/gzip",
+    content: input.gzip
+  });
+}
+async function tryCreatePaaRawDomArtifact(input) {
+  try {
+    return {
+      artifact: await createPaaRawDomArtifact(input),
+      status: "stored"
+    };
+  } catch (error) {
+    console.error("[paa-capture-artifact] private DOM preservation unavailable:", error instanceof Error ? error.message : String(error));
+    return { artifact: null, status: "unavailable" };
+  }
+}
+var DAY_MS, PAA_CAPTURE_ARTIFACT_PREFIX;
+var init_paa_capture_artifacts = __esm({
+  "src/api/paa-capture-artifacts.ts"() {
+    "use strict";
+    init_private_artifacts();
+    DAY_MS = 24 * 60 * 60 * 1e3;
+    PAA_CAPTURE_ARTIFACT_PREFIX = "paa-captures";
+  }
+});
+
+// src/api/paa-harvest-settlement.ts
+function capturedQuestionCount(result) {
+  if (!result || typeof result !== "object") return 0;
+  const value = result;
+  if (typeof value.totalQuestions === "number") return value.totalQuestions;
+  return Array.isArray(value.progress?.records) ? value.progress.records.length : 0;
+}
+function finalCost(result, heldMc) {
+  const questions = capturedQuestionCount(result);
+  if (questions <= 0) return 0;
+  return Math.min(heldMc, MC_COSTS.paa_base + questions * MC_COSTS.paa);
+}
+async function settlePaaHarvestJob(jobOrId) {
+  const job = typeof jobOrId === "string" ? await getJob(jobOrId) : jobOrId;
+  if (!job) return false;
+  const options = job.options;
+  const debitKey2 = options.billingDebitKey;
+  const heldMc = Number(options.billingHoldMc ?? 0);
+  if (!debitKey2 || !Number.isSafeInteger(heldMc) || heldMc <= 0) return false;
+  const settlement = await settleDebitMcIdempotent(
+    job.user_id,
+    debitKey2,
+    finalCost(job.result, heldMc),
+    LedgerOperation.PAA_REFUND,
+    "durable PAA harvest settlement",
+    "paa_harvest"
+  );
+  await markJobBillingSettled(job.id, settlement.final_amount_mc);
+  return true;
+}
+var init_paa_harvest_settlement = __esm({
+  "src/api/paa-harvest-settlement.ts"() {
+    "use strict";
+    init_db();
+    init_rates();
+  }
+});
+
+// src/api/webhook.ts
+async function deliverWebhook(url, payload, retries = 3) {
+  for (let attempt = 1; attempt <= retries; attempt++) {
+    try {
+      const res = await fetch(url, {
+        method: "POST",
+        headers: { "content-type": "application/json" },
+        body: JSON.stringify(payload),
+        signal: AbortSignal.timeout(1e4)
+      });
+      if (res.ok) return;
+      console.warn(`[webhook] attempt ${attempt} \u2192 ${res.status} from ${url}`);
+    } catch (err) {
+      console.warn(`[webhook] attempt ${attempt} failed:`, err instanceof Error ? err.message : err);
+    }
+    if (attempt < retries) await new Promise((r) => setTimeout(r, 1e3 * attempt * 2));
+  }
+  console.error(`[webhook] gave up after ${retries} attempts for ${url}`);
+}
+var init_webhook = __esm({
+  "src/api/webhook.ts"() {
+    "use strict";
+  }
+});
+
+// src/paa/durable-capture.ts
+function remainingSeconds(deadlineMs, ceiling) {
+  return Math.max(1, Math.min(ceiling, Math.floor((deadlineMs - Date.now()) / 1e3)));
+}
+async function execute(kernel, sessionId, code, deadlineMs, ceilingSeconds) {
+  if (Date.now() >= deadlineMs) throw new Error("paa_work_deadline_exhausted");
+  const response = await kernel.browsers.playwright.execute(sessionId, {
+    code,
+    timeout_sec: remainingSeconds(deadlineMs, ceilingSeconds)
+  });
+  if (!response.success || response.result === null || response.result === void 0) {
+    throw new Error(response.error || response.stderr || "co-located browser execution failed");
+  }
+  return response.result;
+}
+function navigationCode(searchUrl) {
+  return `
+    const wait = ms => page.waitForTimeout(ms);
+    const block = async () => {
+      if (/google\\.[^/]+\\/sorry\\//i.test(page.url())) return 'captcha';
+      if (await page.locator(${JSON.stringify(PAASelectors.captchaMarker)}).count().catch(() => 0)) return 'captcha';
+      const title = await page.title().catch(() => '');
+      const text = await page.locator('body').innerText({ timeout: 2000 }).catch(() => '');
+      if (/recaptcha|unusual traffic|are you a robot|about this page|detected unusual traffic/i.test(text)) return 'captcha';
+      if (/\\b403\\b.{0,120}forbidden|access denied|permission to access/i.test(title + '\\n' + text.slice(0, 3000))) return 'soft_block';
+      return null;
+    };
+    await page.goto(${JSON.stringify(searchUrl)}, { waitUntil: 'domcontentloaded', timeout: 45000 });
+    let captchaObserved = false;
+    let solverCleared = false;
+    let blocked = await block();
+    const solverDeadline = Date.now() + ${PAA_SOLVER_BUDGET_MS};
+    while (blocked === 'captcha' && Date.now() < solverDeadline) {
+      captchaObserved = true;
+      await wait(4000 + Math.floor(Math.random() * 1500));
+      blocked = await block();
+      if (!blocked) solverCleared = true;
+    }
+    let count = await page.locator(${JSON.stringify(PAASelectors.item)}).count().catch(() => 0);
+    for (let scan = 0; !blocked && count === 0 && scan < 7; scan += 1) {
+      await page.mouse.wheel(0, 520 + Math.floor(Math.random() * 420));
+      await wait(350 + Math.floor(Math.random() * 500));
+      count = await page.locator(${JSON.stringify(PAASelectors.item)}).count().catch(() => 0);
+    }
+    await page.evaluate((itemSelector) => {
+      const state = window;
+      if (state.__mcpTrustedListenerInstalled) return;
+      document.addEventListener('click', event => {
+        if (event.target instanceof Element && event.target.closest(itemSelector)) {
+          state.__mcpLastPaaClickTrusted = event.isTrusted;
+        }
+      }, { capture: true });
+      state.__mcpTrustedListenerInstalled = true;
+    }, ${JSON.stringify(PAASelectors.item)}).catch(() => {});
+    return {
+      outcome: blocked || (count > 0 ? 'ready' : 'no_paa'),
+      finalUrl: page.url(),
+      title: await page.title().catch(() => ''),
+      captchaObserved,
+      solverCleared,
+      environment: await page.evaluate(() => ({
+        userAgent: navigator.userAgent,
+        language: navigator.language,
+        platform: navigator.platform,
+        timezone: Intl.DateTimeFormat().resolvedOptions().timeZone,
+        innerWidth: window.innerWidth,
+        innerHeight: window.innerHeight,
+        outerWidth: window.outerWidth,
+        outerHeight: window.outerHeight,
+        screenWidth: window.screen.width,
+        screenHeight: window.screen.height,
+        devicePixelRatio: window.devicePixelRatio,
+      })).catch(() => null),
+    };
+  `;
+}
+function recordReaderSource() {
+  return `
+    const clean = value => (value || '').replace(/\\u00a0/g, ' ').replace(/[ \\t]+/g, ' ').replace(/\\n{3,}/g, '\\n\\n').trim();
+    const externalHref = anchor => {
+      const href = anchor && anchor.href || '';
+      if (!/^https?:\\/\\//i.test(href)) return '';
+      try {
+        const url = new URL(href);
+        if (/(^|\\.)google(usercontent)?\\.[a-z.]+$/i.test(url.hostname)) {
+          const redirected = url.searchParams.get('q') || url.searchParams.get('url');
+          return redirected && redirected.startsWith('http') ? redirected : '';
+        }
+      } catch {}
+      return href;
+    };
+    const sourceLabel = value => clean(value)
+      .replace(/\\s*\\(\\+\\d+\\)\\s*-\\s*View related links.*$/i, '')
+      .replace(/\\s*-\\s*Opens in new tab.*$/i, '').trim();
+    const readRecords = () => Array.from(document.querySelectorAll(SEL.item)).map(item => {
+      const question = clean(item.getAttribute(SEL.itemDataQ)
+        || item.getAttribute(SEL.itemDataInitQ)
+        || item.querySelector(SEL.itemQuestionEl)?.innerText);
+      const expanded = item.classList.contains(SEL.expandedClass)
+        || item.querySelector(SEL.clickTarget)?.getAttribute('aria-expanded') === 'true';
+      const container = expanded ? item.querySelector(SEL.answerContainer) : null;
+      const answerElement = container?.querySelector(SEL.aiAnswerBody) || container;
+      const anchors = expanded ? Array.from(answerElement?.querySelectorAll(
+        SEL.aiCitation + ',' + SEL.aiSourceCard + ',a[href]'
+      ) || []) : [];
+      const byUrl = new Map();
+      for (const anchor of anchors) {
+        const url = externalHref(anchor);
+        if (!url || byUrl.has(url)) continue;
+        let site = '';
+        try { site = new URL(url).hostname.replace(/^www\\./, ''); } catch {}
+        byUrl.set(url, { title: sourceLabel(anchor.getAttribute('aria-label')) || clean(anchor.textContent), site, url });
+      }
+      const sources = Array.from(byUrl.values());
+      let sourceTitle = expanded ? clean(item.querySelector(SEL.sourceTitle)?.textContent) : '';
+      let sourceSite = expanded ? clean(item.querySelector(SEL.sourceSite)?.textContent) : '';
+      let sourceCite = expanded ? externalHref(item.querySelector(SEL.sourceCite)) : '';
+      const primary = sources.find(source => source.title.length > 2) || sources[0];
+      if (!sourceCite && primary) {
+        sourceTitle ||= primary.title;
+        sourceSite ||= primary.site;
+        sourceCite = primary.url;
+      }
+      return {
+        question,
+        answer: clean(answerElement?.innerText || answerElement?.textContent),
+        sourceTitle,
+        sourceSite,
+        sourceCite,
+        sources,
+        depth: 1,
+        parentQuestion: null,
+      };
+    }).filter(record => record.question);
+  `;
+}
+function expansionCode(clickedQuestions) {
+  return `
+    const SEL = ${JSON.stringify(PAASelectors)};
+    ${recordReaderSource()}
+    const deliveryBlock = async () => {
+      if (/google\\.[^/]+\\/sorry\\//i.test(page.url())) return 'captcha';
+      if (await page.locator(SEL.captchaMarker).count().catch(() => 0)) return 'captcha';
+      const text = await page.locator('body').innerText({ timeout: 2000 }).catch(() => '');
+      if (/recaptcha|unusual traffic|are you a robot|about this page/i.test(text)) return 'captcha';
+      if (/\\b403\\b.{0,120}forbidden|access denied|permission to access/i.test(text.slice(0, 3000))) return 'soft_block';
+      return null;
+    };
+    const blocked = await deliveryBlock();
+    const records = await page.evaluate(({ SEL }) => {
+      ${recordReaderSource()}
+      return readRecords();
+    }, { SEL });
+    if (blocked) return {
+      outcome: blocked, targetQuestion: null, records, newQuestions: [],
+      finalUrl: page.url(), title: await page.title().catch(() => ''),
+      interactionTrusted: null, clickError: null,
+    };
+    const clicked = new Set(${JSON.stringify(clickedQuestions)});
+    const targetQuestion = records.map(record => record.question).find(question => !clicked.has(question)) || null;
+    if (!targetQuestion) return {
+      outcome: 'exhausted', targetQuestion: null, records, newQuestions: [],
+      finalUrl: page.url(), title: await page.title().catch(() => ''),
+      interactionTrusted: null, clickError: null,
+    };
+    const items = page.locator(SEL.item);
+    let targetIndex = -1;
+    for (let index = 0, count = await items.count().catch(() => 0); index < count; index += 1) {
+      const question = await items.nth(index).evaluate((item, SEL) =>
+        item.getAttribute(SEL.itemDataQ)
+        || item.getAttribute(SEL.itemDataInitQ)
+        || item.querySelector(SEL.itemQuestionEl)?.innerText?.trim()
+        || '', SEL).catch(() => '');
+      if (question.replace(/\\s+/g, ' ').trim() === targetQuestion) { targetIndex = index; break; }
+    }
+    if (targetIndex < 0) return {
+      outcome: 'exhausted', targetQuestion, records, newQuestions: [],
+      finalUrl: page.url(), title: await page.title().catch(() => ''),
+      interactionTrusted: null, clickError: 'question disappeared before click',
+    };
+    const beforeQuestions = new Set(records.map(record => record.question));
+    const item = items.nth(targetIndex);
+    await item.scrollIntoViewIfNeeded({ timeout: 5000 }).catch(() => {});
+    await page.waitForTimeout(180 + Math.floor(Math.random() * 420));
+    await page.evaluate(() => { window.__mcpLastPaaClickTrusted = null; }).catch(() => {});
+    let clickError = null;
+    try {
+      await item.locator(SEL.clickTarget).first().click({
+        timeout: 6000,
+        delay: 55 + Math.floor(Math.random() * 120),
+      });
+    } catch (error) {
+      clickError = String(error && error.message || error).slice(0, 240);
+    }
+    const interactionTrusted = await page.evaluate(() => window.__mcpLastPaaClickTrusted ?? null).catch(() => null);
+    await page.waitForTimeout(650 + Math.floor(Math.random() * 750));
+    const afterRecords = await page.evaluate(({ SEL }) => {
+      ${recordReaderSource()}
+      return readRecords();
+    }, { SEL });
+    return {
+      outcome: clickError ? 'exhausted' : 'clicked',
+      targetQuestion,
+      records: afterRecords,
+      newQuestions: afterRecords.map(record => record.question).filter(question => !beforeQuestions.has(question)),
+      finalUrl: page.url(),
+      title: await page.title().catch(() => ''),
+      interactionTrusted,
+      clickError,
+    };
+  `;
+}
+function finalCaptureCode(maxQuestions, parentByQuestion) {
+  const surfaces = {
+    aiOverview: AIOverviewSelectors,
+    aiMode: AIModeSelectors,
+    organic: OrganicSelectors,
+    localPack: LocalPackSelectors,
+    video: VideoSelectors,
+    forum: ForumSelectors,
+    whatPeopleSaying: WhatPeopleSayingSelectors
+  };
+  return `
+    const SEL = ${JSON.stringify(PAASelectors)};
+    const SURF = ${JSON.stringify(surfaces)};
+    const PARENTS = ${JSON.stringify(parentByQuestion)};
+    ${recordReaderSource()}
+    const capture = await page.evaluate(({ SEL, SURF, PARENTS, maxQuestions }) => {
+      ${recordReaderSource()}
+      const unique = (items, key) => {
+        const seen = new Set();
+        return items.filter(item => { const value = key(item); if (!value || seen.has(value)) return false; seen.add(value); return true; });
+      };
+      const paa = readRecords().map(record => {
+        const parentQuestion = PARENTS[record.question] || null;
+        let depth = 1, parent = parentQuestion;
+        const seen = new Set();
+        while (parent && !seen.has(parent)) { seen.add(parent); depth += 1; parent = PARENTS[parent] || null; }
+        return { ...record, depth, parentQuestion };
+      }).slice(0, maxQuestions);
+      const organicResults = [];
+      document.querySelectorAll(SURF.organic.result).forEach(card => {
+        const titleElement = card.querySelector(SURF.organic.title);
+        const title = clean(titleElement?.textContent);
+        const link = titleElement?.closest('a');
+        const url = externalHref(link);
+        if (!title || !url) return;
+        let domain = '';
+        try { domain = new URL(url).hostname.replace(/^www\\./, ''); } catch {}
+        const rating = card.querySelector(SURF.organic.ratingWrap);
+        organicResults.push({
+          position: organicResults.length + 1, title, url, domain,
+          cite: clean(card.querySelector(SURF.organic.cite)?.textContent) || null,
+          snippet: clean(card.querySelector(SURF.organic.snippet)?.textContent) || null,
+          isRedditStyle: Boolean(card.querySelector(SURF.organic.redditCite)),
+          inlineRating: rating ? {
+            value: clean(rating.querySelector(SURF.organic.ratingValue)?.textContent),
+            count: clean(rating.querySelector(SURF.organic.reviewCount)?.textContent),
+          } : null,
+        });
+      });
+      const localPack = [];
+      document.querySelectorAll(SURF.localPack.card).forEach(card => {
+        const name = clean(card.querySelector(SURF.localPack.name)?.textContent);
+        if (!name) return;
+        const links = Array.from(card.querySelectorAll('a[href]'));
+        let cid = card.querySelector('a[data-cid]')?.getAttribute('data-cid') || null;
+        for (const link of links) {
+          if (cid) break;
+          const match = link.href.match(/[?&]cid=(\\d+)/);
+          if (match) cid = match[1];
+        }
+        localPack.push({
+          position: localPack.length + 1, name, cid,
+          rating: clean(card.querySelector(SURF.localPack.ratingValue)?.textContent) || null,
+          reviewCount: clean(card.querySelector(SURF.localPack.reviewCount)?.textContent).replace(/[()]/g, '') || null,
+          metadata: [], websiteUrl: links.map(externalHref).find(Boolean) || null,
+          directionsUrl: links.find(link => link.href.includes('google.com/maps'))?.href || null,
+        });
+      });
+      const videos = unique(Array.from(document.querySelectorAll(SURF.video.item)).map(link => {
+        const url = externalHref(link);
+        const raw = clean(link.textContent);
+        const platform = /youtu/i.test(url) ? 'YouTube' : /tiktok/i.test(url) ? 'TikTok' : /instagram/i.test(url) ? 'Instagram' : /facebook/i.test(url) ? 'Facebook' : '';
+        return { type: 'video', title: raw, channel: '', platform, duration: raw.match(/\\b\\d{1,2}:\\d{2}\\b/)?.[0] || '', url };
+      }).filter(item => item.title && item.url), item => item.url);
+      const forums = unique(Array.from(document.querySelectorAll(SURF.forum.item)).map(link => ({
+        title: clean(link.querySelector(SURF.forum.title)?.textContent),
+        source: clean(link.querySelector(SURF.forum.source)?.textContent),
+        url: externalHref(link),
+      })).filter(item => item.title && item.url), item => item.url);
+      const socialCards = Array.from(document.querySelectorAll(SURF.whatPeopleSaying.card));
+      const whatPeopleSaying = unique(socialCards.map(card => {
+        const link = card.querySelector(SURF.whatPeopleSaying.cardLink);
+        const url = externalHref(link);
+        const title = clean(card.querySelector(SURF.whatPeopleSaying.titleH1)?.textContent || card.querySelector(SURF.whatPeopleSaying.titleDiv)?.textContent);
+        const source = clean(card.querySelector(SURF.whatPeopleSaying.ytChannel)?.textContent || card.querySelector(SURF.whatPeopleSaying.source)?.textContent);
+        const platform = clean(card.querySelector(SURF.whatPeopleSaying.platformBadge)?.textContent) || (/youtube/i.test(url) ? 'YouTube' : '');
+        const identity = (platform + source + url).toLowerCase();
+        const type = identity.includes('reddit') ? 'reddit' : identity.includes('facebook') ? 'facebook' : identity.includes('instagram') ? 'instagram' : identity.includes('tiktok') ? 'tiktok' : identity.includes('youtube') ? 'youtube' : 'unknown';
+        return { type, title, url, source, platform, popularComment: null, engagement: '', date: '', duration: null, authorNote: null };
+      }).filter(item => item.title || item.url), item => item.url || item.type + ':' + item.title);
+      const aioRoot = document.querySelector(SURF.aiOverview.root) || document.querySelector(SURF.aiOverview.legacyRoot);
+      const aimRoot = document.querySelector(SURF.aiMode.root);
+      const citations = root => unique(Array.from(root?.querySelectorAll('a[href]') || []).map(link => ({
+        text: clean(link.textContent || link.getAttribute('aria-label')), href: externalHref(link),
+      })).filter(item => item.href), item => item.href);
+      const aiOverview = { detected: Boolean(aioRoot), text: aioRoot ? clean(aioRoot.innerText || aioRoot.textContent) : null, citations: citations(aioRoot), expanded: true, fullyExpanded: true, sections: [] };
+      const aiMode = { detected: Boolean(aimRoot), text: aimRoot ? clean(aimRoot.innerText || aimRoot.textContent) : null, citations: citations(aimRoot) };
+      const html = document.documentElement.outerHTML;
+      const kgIds = unique(Array.from(html.matchAll(/\\/g\\/[a-zA-Z0-9_-]{5,20}/g)).map(match => match[0]), value => value);
+      const cids = unique([
+        ...localPack.map(item => item.cid).filter(Boolean),
+        ...Array.from(html.matchAll(/[?&]cid=(\\d+)/g)).map(match => match[1]),
+      ], value => value);
+      const gcids = unique(Array.from(html.matchAll(/gcid:[a-zA-Z0-9_]+/g)).map(match => match[0]), value => value);
+      const entities = localPack.filter(item => item.cid).map(item => ({ name: item.name, kgId: null, cid: item.cid, gcid: null }));
+      const headings = unique(Array.from(document.querySelectorAll('h1,h2,h3,[role="heading"]')).map(node => clean(node.textContent)).filter(text => text.length > 1 && text.length < 160), value => value);
+      const relatedSearches = unique(Array.from(document.querySelectorAll('a[href*="/search?"]')).map(link => ({
+        text: clean(link.textContent), url: link.href,
+      })).filter(item => item.text && /related/i.test(item.url + ' ' + item.text)), item => item.url);
+      const counts = {
+        peopleAlsoAsk: paa.length, organic: organicResults.length, localPack: localPack.length,
+        videos: videos.length, discussions: forums.length, whatPeopleSaying: whatPeopleSaying.length,
+        aiOverview: aiOverview.detected ? 1 : 0, aiMode: aiMode.detected ? 1 : 0,
+        relatedSearches: relatedSearches.length,
+      };
+      return {
+        paa, organicResults: unique(organicResults, item => item.url), localPack: unique(localPack, item => item.cid || item.name),
+        videos, forums, whatPeopleSaying, aiOverview, aiMode,
+        surface: window.google?.sn === 'aim' ? 'aim' : window.google?.sn === 'web' ? 'web' : 'unknown',
+        entityIds: { entities, kgIds, cids, gcids },
+        serpFeatures: { sectionHeadings: headings, detected: Object.fromEntries(Object.entries(counts).map(([key, count]) => [key, count > 0])), counts },
+        relatedSearches,
+      };
+    }, { SEL, SURF, PARENTS, maxQuestions: ${maxQuestions} });
+    return capture;
+  `;
+}
+function rawChunkCode(offset, length) {
+  return `return await page.evaluate(({ offset, length }) => ({ offset, chunk: window.__mcpPaaRawDom.slice(offset, offset + length) }), { offset: ${offset}, length: ${length} });`;
+}
+function buildPublicResult(input) {
+  const extractedAt = (/* @__PURE__ */ new Date()).toISOString();
+  const selected = input.records;
+  const flat = selected.map((record) => ({
+    seed_query: input.query,
+    question: record.question,
+    answer: record.answer,
+    source_title: record.sourceTitle,
+    source_site: record.sourceSite,
+    source_cite: record.sourceCite,
+    depth: record.depth,
+    parent_question: record.parentQuestion ?? "",
+    extracted_at: extractedAt
+  }));
+  const tree = selected.map((record) => ({
+    question: record.question,
+    answer: record.answer || null,
+    sourceTitle: record.sourceTitle || null,
+    sourceSite: record.sourceSite || null,
+    sourceCite: record.sourceCite || null,
+    depth: record.depth,
+    parentQuestion: record.parentQuestion,
+    children: []
+  }));
+  return {
+    seed: input.query,
+    location: input.location,
+    extractedAt,
+    diagnostics: {
+      completionStatus: selected.length > 0 ? "paa_found" : "no_paa",
+      problem: null,
+      resultQuality: input.partial ? "partial" : "complete",
+      degradedResult: input.partial,
+      retryRecommended: false,
+      completeness: {
+        paaWithoutAnswer: selected.filter((record) => !record.answer).length,
+        paaWithoutSource: selected.filter((record) => !record.sourceCite).length,
+        paaAnswersRecovered: 0,
+        aioShareCaptured: null
+      }
+    },
+    totalQuestions: selected.length,
+    surface: input.capture.surface,
+    aiOverview: input.capture.aiOverview,
+    aiMode: input.capture.aiMode,
+    whatPeopleSaying: input.capture.whatPeopleSaying,
+    tree,
+    flat,
+    videos: input.capture.videos,
+    forums: input.capture.forums,
+    organicResults: input.capture.organicResults,
+    localPack: input.capture.localPack,
+    entityIds: input.capture.entityIds,
+    serpFeatures: input.capture.serpFeatures,
+    relatedSearches: input.capture.relatedSearches,
+    stats: {
+      seed: input.query,
+      totalQuestions: selected.length,
+      maxDepthReached: selected.reduce((max, item) => Math.max(max, item.depth), 0),
+      durationMs: input.durationMs,
+      errorCount: input.partial ? 1 : 0
+    },
+    capture: {
+      execution: "kernel_colocated_playwright",
+      stealth: true,
+      managedProxy: "kernel_default",
+      metadataOverrides: false,
+      locationSignal: input.location ? "uule_only" : "none",
+      attempt: input.attempt,
+      finalUrl: input.navigation.finalUrl,
+      captchaObserved: input.navigation.captchaObserved,
+      solverCleared: input.navigation.solverCleared,
+      environment: input.navigation.environment,
+      rawDomSha256: input.rawDomSha256
+    }
+  };
+}
+async function runDurablePaaCapture(input) {
+  const startedAt = input.startedAtMs ?? Date.now();
+  const workDeadline = startedAt + PAA_BROWSER_WORK_BUDGET_MS;
+  const location2 = input.location?.trim() || null;
+  const params = new URLSearchParams({
+    q: input.query,
+    gl: input.gl ?? "us",
+    hl: input.hl ?? "en",
+    pws: "0"
+  });
+  if (location2) params.set("uule", encodeUule(normalizeLocation(location2)));
+  const searchUrl = `https://www.google.com/search?${params.toString()}`;
+  const kernel = new import_sdk8.default({ apiKey: input.apiKey });
+  let lastCheckpoint = {
+    phase: "navigating",
+    attempt: 1,
+    observedAt: (/* @__PURE__ */ new Date()).toISOString(),
+    records: [],
+    clickedQuestions: [],
+    finalUrl: null,
+    captchaObserved: false,
+    solverCleared: false,
+    error: null
+  };
+  const persist = async (patch) => {
+    lastCheckpoint = { ...lastCheckpoint, ...patch, observedAt: (/* @__PURE__ */ new Date()).toISOString() };
+    await input.onCheckpoint?.(lastCheckpoint);
+  };
+  for (let attempt = 1; attempt <= 2; attempt += 1) {
+    if (Date.now() >= workDeadline) break;
+    let sessionId = null;
+    const records = /* @__PURE__ */ new Map();
+    const clicked = /* @__PURE__ */ new Set();
+    const parents = {};
+    let navigation = null;
+    try {
+      await persist({ phase: "navigating", attempt, records: [], clickedQuestions: [], error: null });
+      const browser = await kernel.browsers.create({
+        stealth: true,
+        timeout_seconds: Math.max(60, Math.min(280, Math.ceil((workDeadline - Date.now()) / 1e3) + 20))
+      });
+      sessionId = browser.session_id;
+      navigation = await execute(kernel, sessionId, navigationCode(searchUrl), workDeadline, 110);
+      await persist({
+        phase: navigation.outcome === "ready" ? "expanding" : "blocked",
+        finalUrl: navigation.finalUrl,
+        captchaObserved: navigation.captchaObserved,
+        solverCleared: navigation.solverCleared
+      });
+      if (navigation.outcome === "captcha" || navigation.outcome === "soft_block") {
+        if (attempt === 1 && records.size === 0) continue;
+        throw new Error(navigation.outcome);
+      }
+      let stagnant = 0;
+      for (let step = 0; step < input.maxQuestions * 2 && Date.now() < workDeadline - 35e3; step += 1) {
+        const observed = await execute(
+          kernel,
+          sessionId,
+          expansionCode(Array.from(clicked)),
+          workDeadline,
+          25
+        );
+        const beforeSize = records.size;
+        for (const record of observed.records) {
+          const existing = records.get(record.question);
+          records.set(record.question, {
+            ...record,
+            answer: record.answer || existing?.answer || "",
+            sourceTitle: record.sourceTitle || existing?.sourceTitle || "",
+            sourceSite: record.sourceSite || existing?.sourceSite || "",
+            sourceCite: record.sourceCite || existing?.sourceCite || "",
+            sources: Array.from(new Map([...existing?.sources ?? [], ...record.sources].map((source) => [source.url, source])).values()),
+            parentQuestion: parents[record.question] ?? null,
+            depth: parents[record.question] ? 2 : 1
+          });
+        }
+        if (observed.outcome === "clicked" && observed.targetQuestion) {
+          clicked.add(observed.targetQuestion);
+          for (const question of observed.newQuestions) {
+            if (!parents[question]) parents[question] = observed.targetQuestion;
+          }
+        }
+        const selected2 = Array.from(records.values()).slice(0, input.maxQuestions);
+        await persist({
+          phase: "expanding",
+          records: selected2,
+          clickedQuestions: Array.from(clicked),
+          finalUrl: observed.finalUrl,
+          captchaObserved: lastCheckpoint.captchaObserved || observed.outcome === "captcha"
+        });
+        if (observed.outcome === "captcha" || observed.outcome === "soft_block") break;
+        if (selected2.length >= input.maxQuestions && selected2.every((record) => clicked.has(record.question))) break;
+        stagnant = records.size === beforeSize || observed.outcome === "exhausted" ? stagnant + 1 : 0;
+        if (stagnant >= 4) break;
+      }
+      const finalCapture = await execute(
+        kernel,
+        sessionId,
+        finalCaptureCode(input.maxQuestions, parents),
+        workDeadline,
+        45
+      );
+      for (const record of finalCapture.paa) {
+        const existing = records.get(record.question);
+        records.set(record.question, {
+          ...record,
+          answer: record.answer || existing?.answer || "",
+          sourceTitle: record.sourceTitle || existing?.sourceTitle || "",
+          sourceSite: record.sourceSite || existing?.sourceSite || "",
+          sourceCite: record.sourceCite || existing?.sourceCite || "",
+          sources: Array.from(new Map([...existing?.sources ?? [], ...record.sources].map((source) => [source.url, source])).values()),
+          parentQuestion: parents[record.question] ?? record.parentQuestion,
+          depth: record.depth
+        });
+      }
+      let rawDomGzip = null;
+      let rawDomSha256 = null;
+      if (Date.now() < workDeadline - 12e3) {
+        const prepared = await execute(
+          kernel,
+          sessionId,
+          RAW_PREPARE_CODE,
+          workDeadline,
+          35
+        );
+        const chunks = [];
+        for (let offset = 0; offset < prepared.chars && Date.now() < workDeadline - 5e3; offset += 18e4) {
+          const part = await execute(
+            kernel,
+            sessionId,
+            rawChunkCode(offset, 18e4),
+            workDeadline,
+            15
+          );
+          if (part.offset !== offset) throw new Error("raw_dom_chunk_offset_mismatch");
+          chunks.push(part.chunk);
+        }
+        if (chunks.join("").length === prepared.chars) {
+          const transported = Buffer.from(chunks.join(""), "base64");
+          if (prepared.encoding === "gzip") rawDomGzip = transported;
+          else {
+            const { gzipSync } = await import("zlib");
+            rawDomGzip = gzipSync(transported);
+          }
+          rawDomSha256 = (0, import_node_crypto11.createHash)("sha256").update(rawDomGzip).digest("hex");
+        }
+      }
+      const selected = Array.from(records.values()).slice(0, input.maxQuestions);
+      const partial = selected.length < input.maxQuestions || selected.some((record) => !record.answer || !record.sourceCite);
+      await persist({ phase: "captured", records: selected, clickedQuestions: Array.from(clicked) });
+      return {
+        result: buildPublicResult({
+          query: input.query,
+          location: location2,
+          capture: finalCapture,
+          records: selected,
+          navigation,
+          durationMs: Date.now() - startedAt,
+          partial,
+          attempt,
+          rawDomSha256
+        }),
+        rawDomGzip,
+        rawDomSha256,
+        attempt,
+        partial,
+        checkpoint: lastCheckpoint
+      };
+    } catch (error) {
+      const message = error instanceof Error ? error.message : String(error);
+      await persist({
+        phase: records.size > 0 ? "captured" : "failed",
+        records: Array.from(records.values()).slice(0, input.maxQuestions),
+        clickedQuestions: Array.from(clicked),
+        error: message.slice(0, 500)
+      });
+      if (records.size > 0) {
+        const emptyCapture = {
+          paa: [],
+          organicResults: [],
+          localPack: [],
+          videos: [],
+          forums: [],
+          whatPeopleSaying: [],
+          aiOverview: { detected: false, text: null, citations: [] },
+          aiMode: { detected: false, text: null, citations: [] },
+          surface: "unknown",
+          entityIds: { entities: [], kgIds: [], cids: [], gcids: [] },
+          serpFeatures: { sectionHeadings: [], detected: {}, counts: {} },
+          relatedSearches: []
+        };
+        return {
+          result: buildPublicResult({
+            query: input.query,
+            location: location2,
+            capture: emptyCapture,
+            records: Array.from(records.values()).slice(0, input.maxQuestions),
+            navigation: navigation ?? {
+              outcome: "soft_block",
+              finalUrl: lastCheckpoint.finalUrl ?? "",
+              title: "",
+              captchaObserved: lastCheckpoint.captchaObserved,
+              solverCleared: lastCheckpoint.solverCleared,
+              environment: null
+            },
+            durationMs: Date.now() - startedAt,
+            partial: true,
+            attempt,
+            rawDomSha256: null
+          }),
+          rawDomGzip: null,
+          rawDomSha256: null,
+          attempt,
+          partial: true,
+          checkpoint: lastCheckpoint
+        };
+      }
+      if (attempt === 2 || Date.now() >= workDeadline - 35e3) throw error;
+    } finally {
+      if (sessionId) {
+        await kernel.browsers.deleteByID(sessionId).catch(() => void 0);
+      }
+    }
+  }
+  throw new Error("paa_work_deadline_exhausted_before_capture");
+}
+var import_sdk8, import_node_crypto11, PAA_INVOCATION_BUDGET_MS, PAA_BROWSER_WORK_BUDGET_MS, PAA_SOLVER_BUDGET_MS, RAW_PREPARE_CODE;
+var init_durable_capture = __esm({
+  "src/paa/durable-capture.ts"() {
+    "use strict";
+    import_sdk8 = __toESM(require("@onkernel/sdk"), 1);
+    import_node_crypto11 = require("crypto");
+    init_selectors();
+    init_uule();
+    PAA_INVOCATION_BUDGET_MS = 28e4;
+    PAA_BROWSER_WORK_BUDGET_MS = 25e4;
+    PAA_SOLVER_BUDGET_MS = 6e4;
+    RAW_PREPARE_CODE = `
+  const result = await page.evaluate(async () => {
+    const source = new TextEncoder().encode(document.documentElement.outerHTML);
+    const compressed = typeof CompressionStream === 'undefined'
+      ? source
+      : new Uint8Array(await new Response(new Blob([source]).stream().pipeThrough(new CompressionStream('gzip'))).arrayBuffer());
+    const pieces = [];
+    for (let offset = 0; offset < compressed.length; offset += 32768) {
+      pieces.push(String.fromCharCode(...compressed.subarray(offset, offset + 32768)));
+    }
+    window.__mcpPaaRawDom = btoa(pieces.join(''));
+    return { encoding: typeof CompressionStream === 'undefined' ? 'plain' : 'gzip', chars: window.__mcpPaaRawDom.length };
+  });
+  return result;
+`;
+  }
+});
+
+// src/inngest/functions/paa-harvest.ts
+function questionCount(result) {
+  if (!result || typeof result !== "object") return 0;
+  const value = result;
+  if (typeof value.totalQuestions === "number") return value.totalQuestions;
+  return Array.isArray(value.progress?.records) ? value.progress.records.length : 0;
+}
+var paaHarvestFn;
+var init_paa_harvest = __esm({
+  "src/inngest/functions/paa-harvest.ts"() {
+    "use strict";
+    init_client();
+    init_browser_service_env();
+    init_db();
+    init_paa_capture_artifacts();
+    init_paa_harvest_settlement();
+    init_webhook();
+    init_durable_capture();
+    paaHarvestFn = inngest.createFunction(
+      {
+        id: "paa-harvest",
+        retries: 0,
+        triggers: [{ event: "mcp-scraper/paa.requested" }],
+        onFailure: async ({ event }) => {
+          const jobId2 = event?.data?.event?.data?.jobId;
+          if (!jobId2) return;
+          const current = await getJob(jobId2);
+          if (!current) return;
+          if (current.status === "done" || current.status === "failed" || current.status === "cancelled") {
+            await settlePaaHarvestJob(jobId2).catch((error) => {
+              console.error("[paa-harvest/onFailure] terminal settlement pending:", error instanceof Error ? error.message : String(error));
+            });
+            return;
+          }
+          const message = String(event?.data?.error?.message ?? "durable PAA invocation failed").slice(0, 1e3);
+          await failJob(jobId2, message);
+          await settlePaaHarvestJob(jobId2).catch((error) => {
+            console.error("[paa-harvest/onFailure] settlement pending:", error instanceof Error ? error.message : String(error));
+          });
+        }
+      },
+      async ({ event }) => {
+        const invocationStartedAt = Date.now();
+        const job = await claimInngestPaaJob(event.data.jobId);
+        if (!job) return { jobId: event.data.jobId, status: "missing_or_not_paa" };
+        if (job.status === "done" || job.status === "failed" || job.status === "cancelled") {
+          await settlePaaHarvestJob(job.id);
+          return { jobId: job.id, status: job.status };
+        }
+        const options = job.options;
+        const maxQuestions = Math.max(1, Math.min(100, Number(options.maxQuestions ?? 30)));
+        const apiKey = browserServiceApiKey();
+        if (!apiKey) throw new Error("browser service is not configured");
+        const attemptStartedAt = (/* @__PURE__ */ new Date()).toISOString();
+        await startHarvestAttempt({
+          jobId: job.id,
+          userId: job.user_id,
+          attemptNumber: 1,
+          maxAttempts: 2,
+          query: options.query ?? job.query,
+          location: options.location ?? null,
+          maxQuestions,
+          startedAt: attemptStartedAt
+        });
+        const checkpointState = { value: null };
+        try {
+          const capture = await runDurablePaaCapture({
+            apiKey,
+            query: options.query ?? job.query,
+            location: options.location ?? null,
+            gl: options.gl ?? "us",
+            hl: options.hl ?? "en",
+            maxQuestions,
+            startedAtMs: invocationStartedAt,
+            onCheckpoint: async (checkpoint) => {
+              checkpointState.value = checkpoint;
+              const persisted = await checkpointJob(job.id, {
+                progress: checkpoint,
+                durable: {
+                  invocationBudgetMs: PAA_INVOCATION_BUDGET_MS,
+                  workBudgetMs: 25e4,
+                  cleanupReserveMs: 3e4
+                }
+              });
+              if (!persisted) throw new Error("job_left_running_state_during_capture");
+            }
+          });
+          const artifactResult = capture.rawDomGzip ? await tryCreatePaaRawDomArtifact({
+            userId: job.user_id,
+            jobId: job.id,
+            attempt: capture.attempt,
+            gzip: capture.rawDomGzip
+          }) : { artifact: null, status: "unavailable" };
+          const artifact = artifactResult.artifact;
+          const artifactMissing = capture.rawDomGzip !== null && artifactResult.status !== "stored";
+          const result = {
+            ...capture.result,
+            diagnostics: {
+              ...capture.result.diagnostics,
+              ...artifactMissing ? {
+                resultQuality: "partial",
+                degradedResult: true,
+                retryRecommended: false
+              } : {}
+            },
+            capture: {
+              ...capture.result.capture,
+              rawDomArtifact: artifact,
+              rawDomArtifactStatus: artifactResult.status
+            }
+          };
+          await completeJob(job.id, result);
+          await finishHarvestAttempt({
+            jobId: job.id,
+            attemptNumber: 1,
+            outcome: capture.partial ? "partial" : "paa_found",
+            kernelSessionId: null,
+            questionCount: questionCount(result),
+            durationMs: Date.now() - invocationStartedAt,
+            error: capture.checkpoint.error,
+            willRetry: false,
+            kernelDeleteStarted: true,
+            kernelDeleteSucceeded: true,
+            kernelDeleteError: null,
+            browserCloseSucceeded: true,
+            browserCloseError: null,
+            debug: {
+              execution: "kernel_colocated_playwright",
+              stealth: true,
+              attemptUsed: capture.attempt,
+              rawDomStored: Boolean(artifact)
+            },
+            completedAt: (/* @__PURE__ */ new Date()).toISOString()
+          });
+          await settlePaaHarvestJob(job.id);
+          if (job.callback_url) {
+            await deliverWebhook(job.callback_url, { job_id: job.id, status: "done", result });
+          }
+          return {
+            jobId: job.id,
+            status: "done",
+            totalQuestions: questionCount(result),
+            partial: capture.partial,
+            artifactStored: Boolean(artifact)
+          };
+        } catch (error) {
+          const message = error instanceof Error ? error.message : String(error);
+          const latestCheckpoint = checkpointState.value;
+          await finishHarvestAttempt({
+            jobId: job.id,
+            attemptNumber: 1,
+            outcome: latestCheckpoint?.records.length ? "partial_session_lost" : "failed_before_capture",
+            kernelSessionId: null,
+            questionCount: latestCheckpoint?.records.length ?? 0,
+            durationMs: Date.now() - invocationStartedAt,
+            error: message.slice(0, 1e3),
+            willRetry: false,
+            kernelDeleteStarted: true,
+            kernelDeleteSucceeded: null,
+            kernelDeleteError: null,
+            browserCloseSucceeded: null,
+            browserCloseError: null,
+            debug: latestCheckpoint,
+            completedAt: (/* @__PURE__ */ new Date()).toISOString()
+          });
+          await failJob(job.id, message.slice(0, 1e3));
+          await settlePaaHarvestJob(job.id).catch((settlementError) => {
+            console.error("[paa-harvest] settlement pending:", settlementError instanceof Error ? settlementError.message : String(settlementError));
+          });
+          if (job.callback_url) {
+            await deliverWebhook(job.callback_url, {
+              job_id: job.id,
+              status: "failed",
+              error: message,
+              progress: latestCheckpoint
+            });
+          }
+          throw error;
+        }
+      }
+    );
+  }
+});
+
 // src/api/site-extract-start.ts
 async function prepareSiteExtractStart(input) {
   const existing = await getExtractJobByIdempotencyKey(input.userId, input.idempotencyKey);
@@ -23953,15 +25062,15 @@ function normalizeIdempotencyKey(value) {
   return key;
 }
 function tokenFor(id, idempotencyKey2) {
-  return (0, import_node_crypto11.createHmac)("sha256", billingSecret()).update(id).update(":").update(idempotencyKey2).digest("base64url");
+  return (0, import_node_crypto12.createHmac)("sha256", billingSecret()).update(id).update(":").update(idempotencyKey2).digest("base64url");
 }
 function tokenHash(token2) {
-  return (0, import_node_crypto11.createHash)("sha256").update(token2).digest("hex");
+  return (0, import_node_crypto12.createHash)("sha256").update(token2).digest("hex");
 }
 function verifyToken(row, token2) {
   const expected = Buffer.from(row.token_hash, "hex");
   const actual = Buffer.from(tokenHash(token2), "hex");
-  if (expected.length !== actual.length || !(0, import_node_crypto11.timingSafeEqual)(expected, actual)) {
+  if (expected.length !== actual.length || !(0, import_node_crypto12.timingSafeEqual)(expected, actual)) {
     throw new UnifiedBillingError("unauthorized", "invalid billing authorization token", 401);
   }
 }
@@ -24076,7 +25185,7 @@ async function authorizeScheduledRun(args) {
       { balanceMc, requiredMc: SCHEDULED_RUN_BASE_MC }
     );
   }
-  const id = (0, import_node_crypto11.randomUUID)();
+  const id = (0, import_node_crypto12.randomUUID)();
   const token2 = tokenFor(id, idempotencyKey2);
   const expiresAt = new Date(Date.now() + AUTHORIZATION_TTL_MS).toISOString();
   const inserted = await getDb().execute({
@@ -24144,7 +25253,7 @@ async function startScheduledRun(args) {
   if (!authorization || !["starting", "started"].includes(authorization.status)) {
     throw new UnifiedBillingError("authorization_closed", "billing authorization is no longer startable", 409);
   }
-  const eventId = existing?.id ?? (0, import_node_crypto11.randomUUID)();
+  const eventId = existing?.id ?? (0, import_node_crypto12.randomUUID)();
   if (!existing) {
     await getDb().execute({
       sql: "INSERT OR IGNORE INTO billing_events (id, user_id, authorization_id, idempotency_key, billing_class, source_surface, status, amount_mc, multiplier_bps, metadata) VALUES (?, ?, ?, ?, ?, ?, 'capturing', ?, ?, ?)",
@@ -24281,7 +25390,7 @@ async function settleScheduledRun(args) {
     chargeMode: "model_delta",
     ...pendingReason ? { reason: pendingReason } : {}
   });
-  const eventId = existing?.id ?? (0, import_node_crypto11.randomUUID)();
+  const eventId = existing?.id ?? (0, import_node_crypto12.randomUUID)();
   const status = pendingReason ? "cost_pending" : "settling";
   const eventValues = [
     modelMc,
@@ -24340,11 +25449,11 @@ async function voidScheduledRunAuthorization(args) {
   }
   return { ok: true, status: authorization.status };
 }
-var import_node_crypto11, SCHEDULED_RUN_BILLING_CLASS, SCHEDULED_RUN_SOURCE_SURFACE, AUTHORIZATION_TTL_MS, UnifiedBillingError;
+var import_node_crypto12, SCHEDULED_RUN_BILLING_CLASS, SCHEDULED_RUN_SOURCE_SURFACE, AUTHORIZATION_TTL_MS, UnifiedBillingError;
 var init_unified_billing = __esm({
   "src/api/unified-billing.ts"() {
     "use strict";
-    import_node_crypto11 = require("crypto");
+    import_node_crypto12 = require("crypto");
     init_db();
     init_rates();
     init_scheduling_access();
@@ -24376,14 +25485,14 @@ function getSessionSecret() {
 function safeEqualHex(a, b) {
   if (a.length !== b.length) return false;
   try {
-    return (0, import_node_crypto12.timingSafeEqual)(Buffer.from(a, "hex"), Buffer.from(b, "hex"));
+    return (0, import_node_crypto13.timingSafeEqual)(Buffer.from(a, "hex"), Buffer.from(b, "hex"));
   } catch {
     return false;
   }
 }
 function signSession(userId) {
   const payload = String(userId);
-  const sig = (0, import_node_crypto12.createHmac)("sha256", secret()).update(payload).digest("hex");
+  const sig = (0, import_node_crypto13.createHmac)("sha256", secret()).update(payload).digest("hex");
   return `${payload}.${sig}`;
 }
 function verifySession(token2) {
@@ -24391,16 +25500,16 @@ function verifySession(token2) {
   if (dot === -1) return null;
   const payload = token2.slice(0, dot);
   const sig = token2.slice(dot + 1);
-  const expected = (0, import_node_crypto12.createHmac)("sha256", secret()).update(payload).digest("hex");
+  const expected = (0, import_node_crypto13.createHmac)("sha256", secret()).update(payload).digest("hex");
   if (!safeEqualHex(sig, expected)) return null;
   const id = parseInt(payload);
   return isNaN(id) ? null : id;
 }
-var import_node_crypto12, isProduction, secret;
+var import_node_crypto13, isProduction, secret;
 var init_session = __esm({
   "src/api/session.ts"() {
     "use strict";
-    import_node_crypto12 = require("crypto");
+    import_node_crypto13 = require("crypto");
     isProduction = () => process.env.NODE_ENV === "production" || process.env.VERCEL === "1";
     secret = () => getSessionSecret();
   }
@@ -24418,11 +25527,11 @@ function isMemoryOperator(email) {
   return ops.includes(email.trim().toLowerCase());
 }
 function encKey() {
-  return (0, import_node_crypto13.scryptSync)(getSessionSecret(), "mcp-memory-key-v1", 32);
+  return (0, import_node_crypto14.scryptSync)(getSessionSecret(), "mcp-memory-key-v1", 32);
 }
 function encryptMemoryKey(secret2) {
-  const iv = (0, import_node_crypto13.randomBytes)(12);
-  const cipher = (0, import_node_crypto13.createCipheriv)("aes-256-gcm", encKey(), iv);
+  const iv = (0, import_node_crypto14.randomBytes)(12);
+  const cipher = (0, import_node_crypto14.createCipheriv)("aes-256-gcm", encKey(), iv);
   const enc = Buffer.concat([cipher.update(secret2, "utf8"), cipher.final()]);
   const tag = cipher.getAuthTag();
   return `${iv.toString("base64")}:${tag.toString("base64")}:${enc.toString("base64")}`;
@@ -24430,7 +25539,7 @@ function encryptMemoryKey(secret2) {
 function decryptMemoryKey(stored) {
   try {
     const [ivB, tagB, dataB] = stored.split(":");
-    const decipher = (0, import_node_crypto13.createDecipheriv)("aes-256-gcm", encKey(), Buffer.from(ivB, "base64"));
+    const decipher = (0, import_node_crypto14.createDecipheriv)("aes-256-gcm", encKey(), Buffer.from(ivB, "base64"));
     decipher.setAuthTag(Buffer.from(tagB, "base64"));
     return Buffer.concat([decipher.update(Buffer.from(dataB, "base64")), decipher.final()]).toString("utf8");
   } catch {
@@ -24544,11 +25653,11 @@ async function syncScheduledActionCredentials(user) {
   }, {});
   return { ok: res.ok, error: res.error };
 }
-var import_node_crypto13, import_provision_defaults, import_set_schedule_entitlement, MEMORY_BASE_URL, ADMIN_KEY;
+var import_node_crypto14, import_provision_defaults, import_set_schedule_entitlement, MEMORY_BASE_URL, ADMIN_KEY;
 var init_memory = __esm({
   "src/api/memory.ts"() {
     "use strict";
-    import_node_crypto13 = require("crypto");
+    import_node_crypto14 = require("crypto");
     init_session();
     init_db();
     init_rates();
@@ -24598,7 +25707,7 @@ var init_connected_cost_telemetry = __esm({
 
 // src/api/connected-usage-billing.ts
 function hash(value) {
-  return (0, import_node_crypto14.createHash)("sha256").update(value).digest("hex");
+  return (0, import_node_crypto15.createHash)("sha256").update(value).digest("hex");
 }
 function eventKey(idempotencyKey2) {
   return `connected-usage:${hash(idempotencyKey2)}`;
@@ -24870,7 +25979,7 @@ async function settleConnectedUsage(rawInput) {
     sql: `INSERT OR IGNORE INTO billing_events
             (id, user_id, idempotency_key, billing_class, source_surface, status, amount_mc, metadata)
           VALUES (?, ?, ?, ?, ?, 'settling', ?, ?)`,
-    args: [(0, import_node_crypto14.randomUUID)(), user.id, key, CONNECTED_USAGE_BILLING_CLASS, input.sourceSurface, charge2.amountMc, encodeMetadata(storedMetadata)]
+    args: [(0, import_node_crypto15.randomUUID)(), user.id, key, CONNECTED_USAGE_BILLING_CLASS, input.sourceSurface, charge2.amountMc, encodeMetadata(storedMetadata)]
   });
   let event = await readEvent(key);
   if (!event) throw new Error("connected usage receipt insert completed without a readable event");
@@ -24959,11 +26068,11 @@ async function listConnectedUsageHistory(userId, limit = 100) {
   }
   return history;
 }
-var import_node_crypto14, import_zod14, CONNECTED_USAGE_BILLING_CLASS, CONNECTED_USAGE_DEFAULT_SOURCE_SURFACE, ConnectedUsageSafeMetadataSchema, ConnectedUsageSettlementInputSchema, ConnectedUsagePreflightInputSchema, ConnectedUsageBillingError;
+var import_node_crypto15, import_zod14, CONNECTED_USAGE_BILLING_CLASS, CONNECTED_USAGE_DEFAULT_SOURCE_SURFACE, ConnectedUsageSafeMetadataSchema, ConnectedUsageSettlementInputSchema, ConnectedUsagePreflightInputSchema, ConnectedUsageBillingError;
 var init_connected_usage_billing = __esm({
   "src/api/connected-usage-billing.ts"() {
     "use strict";
-    import_node_crypto14 = require("crypto");
+    import_node_crypto15 = require("crypto");
     import_zod14 = require("zod");
     init_connected_cost_telemetry();
     init_db();
@@ -27854,7 +28963,7 @@ async function kernelLaunchOptsResidential() {
   }
   return { headless: true, kernelApiKey: browserServiceApiKey(), kernelProxyId: proxyId, viewport: { width: 1280, height: 900 }, locale: "en-US" };
 }
-var import_hono7, import_zod21, import_client5, FacebookAdBodySchema, FacebookPageIntelBodySchema, FacebookTranscribeBodySchema, FacebookVideoTranscribeBodySchema, FacebookSearchBodySchema, FacebookMediaBodySchema, AD_LIBRARY_APP_CHROME, AUTH_WALL_URL, MIN_RENDERED_BODY_CHARS, facebookAdApp, ALLOWED_MEDIA_HOSTS;
+var import_hono7, import_zod21, import_client6, FacebookAdBodySchema, FacebookPageIntelBodySchema, FacebookTranscribeBodySchema, FacebookVideoTranscribeBodySchema, FacebookSearchBodySchema, FacebookMediaBodySchema, AD_LIBRARY_APP_CHROME, AUTH_WALL_URL, MIN_RENDERED_BODY_CHARS, facebookAdApp, ALLOWED_MEDIA_HOSTS;
 var init_facebook_ad_routes = __esm({
   "src/api/facebook-ad-routes.ts"() {
     "use strict";
@@ -27869,7 +28978,7 @@ var init_facebook_ad_routes = __esm({
     init_FacebookOrganicVideoExtractor();
     init_kernel_proxy_resolver();
     init_schemas2();
-    import_client5 = require("@fal-ai/client");
+    import_client6 = require("@fal-ai/client");
     init_api_auth();
     init_url_utils();
     init_concurrency_gates();
@@ -28016,7 +29125,7 @@ var init_facebook_ad_routes = __esm({
         metadata: { videoUrl }
       });
       if (!gate.ok) return c.json(concurrencyLimitExceededResponse(gate), 429, { "Retry-After": String(gate.retryAfterSeconds) });
-      import_client5.fal.config({ credentials: process.env.FAL_KEY });
+      import_client6.fal.config({ credentials: process.env.FAL_KEY });
       const holdMc = MEDIA_TRANSCRIBE_HOLD_MC;
       let debited = false;
       try {
@@ -28060,7 +29169,7 @@ var init_facebook_ad_routes = __esm({
         metadata: { url: sourceUrl.href }
       });
       if (!gate.ok) return c.json(concurrencyLimitExceededResponse(gate), 429, { "Retry-After": String(gate.retryAfterSeconds) });
-      import_client5.fal.config({ credentials: process.env.FAL_KEY });
+      import_client6.fal.config({ credentials: process.env.FAL_KEY });
       const driver = new BrowserDriver();
       const holdMc = MEDIA_TRANSCRIBE_HOLD_MC;
       let debited = false;
@@ -28512,7 +29621,7 @@ async function kernelLaunchOptsResidential2() {
 function isBlockedMessage(msg) {
   return msg.toLowerCase().includes("blocked") || msg.toLowerCase().includes("captcha");
 }
-var import_hono8, import_zod22, import_client6, GoogleAdsSearchBodySchema, GoogleAdsPageIntelBodySchema, GoogleAdsTranscribeBodySchema, googleAdsApp;
+var import_hono8, import_zod22, import_client7, GoogleAdsSearchBodySchema, GoogleAdsPageIntelBodySchema, GoogleAdsTranscribeBodySchema, googleAdsApp;
 var init_google_ads_routes = __esm({
   "src/api/google-ads-routes.ts"() {
     "use strict";
@@ -28525,7 +29634,7 @@ var init_google_ads_routes = __esm({
     init_GoogleAdsExtractor();
     init_kernel_proxy_resolver();
     init_schemas2();
-    import_client6 = require("@fal-ai/client");
+    import_client7 = require("@fal-ai/client");
     init_api_auth();
     init_url_utils();
     init_concurrency_gates();
@@ -28637,7 +29746,7 @@ var init_google_ads_routes = __esm({
       const user = c.get("user");
       const gate = await acquireConcurrencyGate(user, "google_ads_transcribe", { reuseLockId: c.req.header("x-mcp-scraper-concurrency-lock"), metadata: { videoUrl } });
       if (!gate.ok) return c.json(concurrencyLimitExceededResponse(gate), 429, { "Retry-After": String(gate.retryAfterSeconds) });
-      import_client6.fal.config({ credentials: process.env.FAL_KEY });
+      import_client7.fal.config({ credentials: process.env.FAL_KEY });
       const holdMc = MEDIA_TRANSCRIBE_HOLD_MC;
       let debited = false;
       try {
@@ -28813,7 +29922,7 @@ async function applyAdjustment(input) {
   const credits = validateCredits(input.credits, input.confirmLarge === true);
   const reason = validateReason(input.reason);
   const actor = validateActor(input.actor);
-  const reference = input.reference?.trim() || `adj_${(0, import_node_crypto15.randomUUID)()}`;
+  const reference = input.reference?.trim() || `adj_${(0, import_node_crypto16.randomUUID)()}`;
   if (reference.length > 120) throw new AdminCreditError(400, "reference must be at most 120 characters");
   const db = getDb();
   const existing = await db.execute({
@@ -28958,11 +30067,11 @@ async function lookupAccount(target, limit = 20) {
     }))
   };
 }
-var import_node_crypto15, MIN_ADJUSTMENT_CREDITS, LARGE_ADJUSTMENT_CREDITS, MAX_ADJUSTMENT_CREDITS, MIN_REASON_LENGTH, MAX_REASON_LENGTH, MAX_ACTOR_LENGTH, AdminCreditError;
+var import_node_crypto16, MIN_ADJUSTMENT_CREDITS, LARGE_ADJUSTMENT_CREDITS, MAX_ADJUSTMENT_CREDITS, MIN_REASON_LENGTH, MAX_REASON_LENGTH, MAX_ACTOR_LENGTH, AdminCreditError;
 var init_admin_credits = __esm({
   "src/api/admin-credits.ts"() {
     "use strict";
-    import_node_crypto15 = require("crypto");
+    import_node_crypto16 = require("crypto");
     init_db();
     init_rates();
     MIN_ADJUSTMENT_CREDITS = 1;
@@ -30487,14 +31596,28 @@ var init_PAAExtractor = __esm({
             }
             return parts.join(" ").replace(/\s+/g, " ").trim();
           }
+          function cleanSourceLabel(value) {
+            return (value ?? "").replace(/\s*\(\+\d+\)\s*-\s*View related links.*$/i, "").replace(/\s*-\s*Opens in new tab.*$/i, "").trim();
+          }
           return Array.from(document.querySelectorAll(selectors.item)).map((pair) => {
-            let sourceTitle = pair.querySelector(selectors.sourceTitle)?.innerText?.trim() || void 0;
-            let sourceSite = pair.querySelector(selectors.sourceSite)?.innerText?.trim() || void 0;
-            let sourceCite = pair.querySelector(selectors.sourceCite)?.innerText?.trim() || void 0;
-            if (!sourceCite) {
+            const clickTarget = pair.querySelector(selectors.clickTarget);
+            const expanded = pair.classList.contains(selectors.expandedClass) || clickTarget?.getAttribute("aria-expanded") === "true";
+            const answerContainer = expanded ? pair.querySelector(selectors.answerContainer) : null;
+            const aiAnswerBody = answerContainer?.querySelector(selectors.aiAnswerBody);
+            const answerElement = aiAnswerBody ?? answerContainer;
+            let sourceTitle = expanded ? pair.querySelector(selectors.sourceTitle)?.innerText?.trim() || void 0 : void 0;
+            let sourceSite = expanded ? pair.querySelector(selectors.sourceSite)?.innerText?.trim() || void 0 : void 0;
+            let sourceCite = expanded ? pair.querySelector(selectors.sourceCite)?.innerText?.trim() || void 0 : void 0;
+            if (expanded && !sourceCite) {
               const seenHrefs = /* @__PURE__ */ new Set();
               const anchors = [];
-              for (const a of Array.from(pair.querySelectorAll("a[href]"))) {
+              const anchorRoot = answerElement ?? pair;
+              const prioritized = [
+                ...Array.from(anchorRoot.querySelectorAll(selectors.aiCitation)),
+                ...Array.from(anchorRoot.querySelectorAll(selectors.aiSourceCard)),
+                ...Array.from(anchorRoot.querySelectorAll("a[href]"))
+              ];
+              for (const a of prioritized) {
                 const href = a.href;
                 if (!/^https?:\/\//.test(href) || seenHrefs.has(href)) continue;
                 let host = "";
@@ -30505,18 +31628,23 @@ var init_PAAExtractor = __esm({
                 }
                 if (/(^|\.)google(usercontent)?\.[a-z.]+$/.test(host)) continue;
                 seenHrefs.add(href);
-                anchors.push({ text: (a.textContent || "").trim(), href, host });
+                anchors.push({
+                  text: (a.textContent || "").trim(),
+                  label: cleanSourceLabel(a.getAttribute("aria-label")),
+                  href,
+                  host
+                });
               }
-              const primary = anchors.find((x) => x.text.length > 2) ?? anchors[0];
+              const primary = anchors.find((x) => x.label.length > 2 || x.text.length > 2) ?? anchors[0];
               if (primary) {
-                sourceTitle = sourceTitle || primary.text || void 0;
+                sourceTitle = sourceTitle || primary.label || primary.text || void 0;
                 sourceSite = sourceSite || primary.host.replace(/^www\./, "");
                 sourceCite = primary.href;
               }
             }
             return {
               question: pair.getAttribute(selectors.itemDataQ) || pair.getAttribute(selectors.itemDataInitQ) || pair.querySelector(selectors.itemQuestionEl)?.innerText?.trim() || "",
-              answer: cleanText(pair.querySelector(selectors.answerContainer)) || void 0,
+              answer: cleanText(answerElement) || void 0,
               sourceTitle,
               sourceSite,
               sourceCite
@@ -33129,12 +34257,15 @@ function mapsErrorResponse(c, err, errorCode) {
   const msg = err instanceof Error ? err.message : String(err);
   const rotationError = err instanceof MapsSearchRotationError ? err : null;
   const blocked = msg.includes("CAPTCHA") || msg.includes("blocked");
-  const retryable = rotationError?.retryable ?? blocked;
-  const message = sanitizeVendorName(msg);
+  const publicCode = normalizePublicErrorCode(
+    rotationError?.errorCode ?? (blocked ? "captcha_or_blocked" : "service_unavailable")
+  );
+  const retryable = publicCode === "service_unavailable" || rotationError?.retryable === true || blocked;
+  const message = publicErrorMessage(publicCode);
   return c.json({
     error: message,
     message,
-    error_code: rotationError?.errorCode ?? (blocked ? "captcha_or_blocked" : errorCode),
+    error_code: publicCode,
     retryable
   }, retryable ? 503 : 500);
 }
@@ -33693,7 +34824,7 @@ function retryDelaySeconds(attempts) {
 }
 async function dispatchPendingDirectoryWorkflows(limit = 25) {
   const rows = await claimDirectoryWorkflowOutbox({
-    workerId: `directory-dispatch-${process.pid}-${(0, import_node_crypto16.randomUUID)().slice(0, 8)}`,
+    workerId: `directory-dispatch-${process.pid}-${(0, import_node_crypto17.randomUUID)().slice(0, 8)}`,
     limit
   });
   const result = { claimed: rows.length, dispatched: 0, failed: 0 };
@@ -33715,11 +34846,11 @@ async function dispatchPendingDirectoryWorkflows(limit = 25) {
   }
   return result;
 }
-var import_node_crypto16;
+var import_node_crypto17;
 var init_directory_workflow_dispatch = __esm({
   "src/api/directory-workflow-dispatch.ts"() {
     "use strict";
-    import_node_crypto16 = require("crypto");
+    import_node_crypto17 = require("crypto");
     init_client();
     init_directory_workflow_repository();
   }
@@ -33731,7 +34862,7 @@ function safeOptions(options) {
   return safe2;
 }
 function requestFingerprint(options) {
-  return (0, import_node_crypto17.createHash)("sha256").update(JSON.stringify(safeOptions(options))).digest("hex");
+  return (0, import_node_crypto18.createHash)("sha256").update(JSON.stringify(safeOptions(options))).digest("hex");
 }
 function idempotencyKey(raw) {
   if (raw !== void 0) {
@@ -33740,14 +34871,14 @@ function idempotencyKey(raw) {
     if (trimmed.length > 500) return { ok: false, message: "Idempotency-Key must be 500 characters or fewer." };
     return { ok: true, key: trimmed };
   }
-  return { ok: true, key: `directory-${(0, import_node_crypto17.randomUUID)()}` };
+  return { ok: true, key: `directory-${(0, import_node_crypto18.randomUUID)()}` };
 }
 function debitKeyFor(userId, responseKey) {
-  const digest = (0, import_node_crypto17.createHash)("sha256").update(String(userId)).update("\0").update(responseKey).digest("hex");
+  const digest = (0, import_node_crypto18.createHash)("sha256").update(String(userId)).update("\0").update(responseKey).digest("hex");
   return `directory-workflow:${userId}:${digest}`;
 }
 function jobId() {
-  return `dir_${(0, import_node_crypto17.randomUUID)().replace(/-/g, "")}`;
+  return `dir_${(0, import_node_crypto18.randomUUID)().replace(/-/g, "")}`;
 }
 function publicStatus(job, result) {
   if (job.status === "failed") return "failed";
@@ -33856,7 +34987,7 @@ async function runSynchronously(c, user, options, plan, responseKey) {
         const csv = renderDirectoryWorkflowCsv(result);
         const artifact = await createDirectoryCsvArtifact({
           ownerId: String(user.id),
-          jobId: (0, import_node_crypto17.createHash)("sha256").update(debitKey2).digest("hex").slice(0, 32),
+          jobId: (0, import_node_crypto18.createHash)("sha256").update(debitKey2).digest("hex").slice(0, 32),
           createdAt: result.extractedAt,
           filename: `${options.state}-${options.query}-directory.csv`,
           csv,
@@ -33912,11 +35043,11 @@ async function runSynchronously(c, user, options, plan, responseKey) {
     await releaseConcurrencyGate(gate.lockId);
   }
 }
-var import_node_crypto17, import_hono16, directoryApp;
+var import_node_crypto18, import_hono16, directoryApp;
 var init_directory_routes = __esm({
   "src/api/directory-routes.ts"() {
     "use strict";
-    import_node_crypto17 = require("crypto");
+    import_node_crypto18 = require("crypto");
     import_hono16 = require("hono");
     init_api_auth();
     init_db();
@@ -34303,6 +35434,67 @@ var init_location_data_routes = __esm({
   }
 });
 
+// src/api/paa-harvest-dispatch.ts
+async function dispatchPaaHarvest(jobId2) {
+  await inngest.send({
+    id: `paa-harvest:${jobId2}`,
+    name: "mcp-scraper/paa.requested",
+    data: { jobId: jobId2 }
+  });
+}
+async function redispatchPendingPaaHarvests(limit = 25) {
+  const jobs = await listPendingInngestPaaJobs(limit);
+  let dispatched = 0;
+  let failed = 0;
+  for (const job of jobs) {
+    try {
+      await dispatchPaaHarvest(job.id);
+      dispatched += 1;
+    } catch {
+      failed += 1;
+    }
+  }
+  return { checked: jobs.length, dispatched, failed };
+}
+var init_paa_harvest_dispatch = __esm({
+  "src/api/paa-harvest-dispatch.ts"() {
+    "use strict";
+    init_client();
+    init_db();
+  }
+});
+
+// src/api/paa-harvest-reconciliation.ts
+async function reconcilePaaHarvestSettlements(limit = 25) {
+  const stale = await listStaleRunningInngestPaaJobs(limit);
+  let staleFailed = 0;
+  for (const job of stale) {
+    try {
+      await failJob(job.id, "durable PAA invocation exceeded its recovery window; preserved progress remains in result");
+      staleFailed += 1;
+    } catch {
+    }
+  }
+  const jobs = await listRecentTerminalInngestPaaJobs(limit);
+  let settled = 0;
+  let failed = 0;
+  for (const job of jobs) {
+    try {
+      if (await settlePaaHarvestJob(job)) settled += 1;
+    } catch {
+      failed += 1;
+    }
+  }
+  return { checked: jobs.length, staleFailed, settled, failed };
+}
+var init_paa_harvest_reconciliation = __esm({
+  "src/api/paa-harvest-reconciliation.ts"() {
+    "use strict";
+    init_db();
+    init_paa_harvest_settlement();
+  }
+});
+
 // src/api/directory-workflow-reconciliation.ts
 async function reconcileDirectoryWorkflowSettlements(limit = 25) {
   const expiredStarts = await listExpiredDirectoryWorkflowStarts(limit);
@@ -36337,7 +37529,7 @@ async function readManifestFromSummary(summary) {
 function webhookSignature(body, timestamp2) {
   const secret2 = process.env.MCP_SCRAPER_WEBHOOK_SECRET?.trim();
   if (!secret2) return null;
-  return (0, import_node_crypto18.createHmac)("sha256", secret2).update(`${timestamp2}.${body}`).digest("hex");
+  return (0, import_node_crypto19.createHmac)("sha256", secret2).update(`${timestamp2}.${body}`).digest("hex");
 }
 async function deliverWorkflowWebhook(input) {
   if (!input.webhookUrl) return;
@@ -36544,11 +37736,11 @@ async function dispatchDueWorkflowSchedules(apiUrl, limit = 3) {
   }
   return { dispatched: results.length, results };
 }
-var import_node_crypto18, import_promises12, import_hono18, import_zod36, workflowApp, WorkflowInputSchema, WorkflowIdSchema, CadenceSchema, ScheduleStatusSchema, RunBodySchema, ScheduleCreateSchema, SchedulePatchSchema, TERMINAL_RUN_STATUSES;
+var import_node_crypto19, import_promises12, import_hono18, import_zod36, workflowApp, WorkflowInputSchema, WorkflowIdSchema, CadenceSchema, ScheduleStatusSchema, RunBodySchema, ScheduleCreateSchema, SchedulePatchSchema, TERMINAL_RUN_STATUSES;
 var init_workflow_routes = __esm({
   "src/api/workflow-routes.ts"() {
     "use strict";
-    import_node_crypto18 = require("crypto");
+    import_node_crypto19 = require("crypto");
     import_promises12 = require("fs/promises");
     import_hono18 = require("hono");
     import_zod36 = require("zod");
@@ -36829,7 +38021,7 @@ var init_workflow_routes = __esm({
 // src/serp-intelligence/page-snapshot-extractor.ts
 function sha256(value) {
   if (!value) return null;
-  return (0, import_node_crypto19.createHash)("sha256").update(value).digest("hex");
+  return (0, import_node_crypto20.createHash)("sha256").update(value).digest("hex");
 }
 function countWords(markdown) {
   const matches = markdown.trim().match(/\b[\p{L}\p{N}][\p{L}\p{N}'-]*\b/gu);
@@ -37129,11 +38321,11 @@ async function capturePageSnapshots(targets, options = {}) {
     }
   };
 }
-var import_node_crypto19, import_p_limit5, DEFAULT_TIMEOUT_MS, DEFAULT_MAX_CONCURRENCY, DEFAULT_MAX_CONTENT_CHARS;
+var import_node_crypto20, import_p_limit5, DEFAULT_TIMEOUT_MS, DEFAULT_MAX_CONCURRENCY, DEFAULT_MAX_CONTENT_CHARS;
 var init_page_snapshot_extractor = __esm({
   "src/serp-intelligence/page-snapshot-extractor.ts"() {
     "use strict";
-    import_node_crypto19 = require("crypto");
+    import_node_crypto20 = require("crypto");
     import_p_limit5 = __toESM(require("p-limit"), 1);
     init_kpo_extractor();
     init_url_utils();
@@ -37160,13 +38352,16 @@ function looksLikeProxyTunnelFailure3(message) {
 function looksLikeProxyUnavailable3(message) {
   return /proxy unavailable|proxy_unavailable|connection_test_failed|did not return a proxy id|configured fallback/i.test(message);
 }
+function looksLikeInternalServiceUnavailable(message) {
+  return /(?:spending|billing|organization|account).{0,80}(?:cap|limit|blocked|disabled)|(?:quota|capacity).{0,40}(?:reached|exceeded)|https?:\/\/\S*dashboard/i.test(message);
+}
 function classifyHarvestProblem(err) {
   const message = errorMessage3(err);
   if (err instanceof RequestAbortedError) {
     return {
       error_code: "request_aborted",
       error_type: "request_aborted",
-      message,
+      message: publicErrorMessage("request_aborted"),
       retryable: true,
       httpStatus: 408,
       terminalStatus: "cancelled"
@@ -37176,7 +38371,7 @@ function classifyHarvestProblem(err) {
     return {
       error_code: "captcha_exhausted",
       error_type: "captcha",
-      message,
+      message: publicErrorMessage("captcha_exhausted"),
       retryable: true,
       httpStatus: 503,
       terminalStatus: "failed"
@@ -37186,7 +38381,7 @@ function classifyHarvestProblem(err) {
     return {
       error_code: "location_mismatch",
       error_type: "location_mismatch",
-      message,
+      message: publicErrorMessage("location_mismatch"),
       retryable: true,
       httpStatus: 503,
       terminalStatus: "failed"
@@ -37196,7 +38391,7 @@ function classifyHarvestProblem(err) {
     return {
       error_code: "proxy_tunnel_failed",
       error_type: "proxy_tunnel_failed",
-      message,
+      message: publicErrorMessage("proxy_tunnel_failed"),
       retryable: true,
       httpStatus: 503,
       terminalStatus: "failed"
@@ -37206,7 +38401,7 @@ function classifyHarvestProblem(err) {
     return {
       error_code: "proxy_unavailable",
       error_type: "proxy_unavailable",
-      message,
+      message: publicErrorMessage("proxy_unavailable"),
       retryable: true,
       httpStatus: 503,
       terminalStatus: "failed"
@@ -37216,16 +38411,26 @@ function classifyHarvestProblem(err) {
     return {
       error_code: "harvest_timeout",
       error_type: "timeout",
-      message,
+      message: publicErrorMessage("harvest_timeout"),
       retryable: true,
       httpStatus: 504,
       terminalStatus: "failed"
     };
   }
+  if (looksLikeInternalServiceUnavailable(message)) {
+    return {
+      error_code: "service_unavailable",
+      error_type: "service_unavailable",
+      message: PUBLIC_SERVICE_UNAVAILABLE_MESSAGE,
+      retryable: true,
+      httpStatus: 503,
+      terminalStatus: "failed"
+    };
+  }
   return {
     error_code: "extraction_failed",
     error_type: "extraction",
-    message,
+    message: PUBLIC_SERVICE_UNAVAILABLE_MESSAGE,
     retryable: false,
     httpStatus: 500,
     terminalStatus: "failed"
@@ -37740,21 +38945,21 @@ async function logRequestEventBestEffort(input) {
   }
 }
 function captureBillingKeys(userId, suppliedKey, body) {
-  const responseKey = suppliedKey?.trim() || (0, import_node_crypto20.randomUUID)();
-  const requestFingerprint2 = (0, import_node_crypto20.createHash)("sha256").update(JSON.stringify(body)).digest("hex");
-  const keyDigest = (0, import_node_crypto20.createHash)("sha256").update(String(userId)).update("\0").update(responseKey).digest("hex");
+  const responseKey = suppliedKey?.trim() || (0, import_node_crypto21.randomUUID)();
+  const requestFingerprint2 = (0, import_node_crypto21.createHash)("sha256").update(JSON.stringify(body)).digest("hex");
+  const keyDigest = (0, import_node_crypto21.createHash)("sha256").update(String(userId)).update("\0").update(responseKey).digest("hex");
   return {
     responseKey,
     debitKey: `serp-capture:${userId}:${keyDigest}`,
     debitDescription: `${body.query} [request:${requestFingerprint2}]`
   };
 }
-var import_hono19, import_node_crypto20, SERP_INTELLIGENCE_RATE_LIMIT, SERP_INTELLIGENCE_RATE_WINDOW_SECONDS, POST_CAPTURE_ROUTE_LABEL, POST_PAGE_SNAPSHOTS_ROUTE_LABEL, SERP_CAPTURE_BILLING_SOURCE, serpIntelligenceApp;
+var import_hono19, import_node_crypto21, SERP_INTELLIGENCE_RATE_LIMIT, SERP_INTELLIGENCE_RATE_WINDOW_SECONDS, POST_CAPTURE_ROUTE_LABEL, POST_PAGE_SNAPSHOTS_ROUTE_LABEL, SERP_CAPTURE_BILLING_SOURCE, serpIntelligenceApp;
 var init_serp_intelligence_routes = __esm({
   "src/api/serp-intelligence-routes.ts"() {
     "use strict";
     import_hono19 = require("hono");
-    import_node_crypto20 = require("crypto");
+    import_node_crypto21 = require("crypto");
     init_browser_service_env();
     init_page_snapshot_extractor();
     init_serp_capture_service();
@@ -37991,7 +39196,7 @@ var PACKAGE_VERSION;
 var init_version = __esm({
   "src/version.ts"() {
     "use strict";
-    PACKAGE_VERSION = "0.40.2";
+    PACKAGE_VERSION = "0.40.3";
   }
 });
 
@@ -40799,7 +42004,7 @@ var init_editorial_reading_room = __esm({
 
 // src/mcp/paa-mcp-server.ts
 function hashOwnerId(callerKey) {
-  return (0, import_node_crypto21.createHash)("sha256").update(callerKey).digest("hex").slice(0, 24);
+  return (0, import_node_crypto22.createHash)("sha256").update(callerKey).digest("hex").slice(0, 24);
 }
 function liveWebToolAnnotations(title) {
   return {
@@ -41347,14 +42552,14 @@ function registerPaaExtractorMcpTools(server, executor, options = {}) {
     annotations: { title: "Set Scheduled Action Connections", readOnlyHint: false, destructiveHint: false, idempotentHint: true, openWorldHint: false }
   }, async (input) => executor.setScheduledActionConnections(input));
 }
-var import_mcp, import_node_fs11, import_node_path15, import_node_crypto21;
+var import_mcp, import_node_fs11, import_node_path15, import_node_crypto22;
 var init_paa_mcp_server = __esm({
   "src/mcp/paa-mcp-server.ts"() {
     "use strict";
     import_mcp = require("@modelcontextprotocol/sdk/server/mcp.js");
     import_node_fs11 = require("fs");
     import_node_path15 = require("path");
-    import_node_crypto21 = require("crypto");
+    import_node_crypto22 = require("crypto");
     init_version();
     init_mcp_response_formatter();
     init_server_instructions();
@@ -41403,7 +42608,20 @@ async function readResponseData(res) {
 function httpErrorPayload(path6, res, data) {
   const objectData = data && typeof data === "object" && !Array.isArray(data) ? data : null;
   const rawCode = objectData?.code ?? objectData?.errorCode ?? objectData?.error_code;
-  const safeCode = typeof rawCode === "string" && /^[a-z0-9][a-z0-9_-]{0,99}$/.test(rawCode) ? rawCode : "mcp_http_error";
+  const candidateCode = typeof rawCode === "string" && /^[a-z0-9][a-z0-9_-]{0,99}$/.test(rawCode) ? rawCode : "mcp_http_error";
+  if (res.status >= 500) {
+    const safeCode2 = normalizePublicErrorCode(candidateCode);
+    return {
+      error: safeCode2,
+      error_code: safeCode2,
+      error_type: "http",
+      retryable: true,
+      status: res.status,
+      path: path6,
+      message: publicErrorMessage(safeCode2)
+    };
+  }
+  const safeCode = candidateCode;
   const bodyMessage = objectData ? objectData.message ?? objectData.error ?? rawCode : data;
   return {
     ...objectData ?? { body: data },
@@ -41426,13 +42644,15 @@ function withDefaultHostedProfile(input) {
     ...typeof saveProfileChanges === "boolean" ? { saveProfileChanges } : {}
   };
 }
-var import_node_crypto22, HttpMcpToolExecutor;
+var import_node_crypto23, HttpMcpToolExecutor;
 var init_http_mcp_tool_executor = __esm({
   "src/mcp/http-mcp-tool-executor.ts"() {
     "use strict";
-    import_node_crypto22 = require("crypto");
+    import_node_crypto23 = require("crypto");
     init_harvest_timeout();
     init_browser_service_env();
+    init_errors();
+    init_outbound_sanitize();
     HttpMcpToolExecutor = class {
       baseUrl;
       apiKey;
@@ -41469,7 +42689,6 @@ var init_http_mcp_tool_executor = __esm({
           }
           return { content: [{ type: "text", text: JSON.stringify(data) }] };
         } catch (err) {
-          const msg = err instanceof Error ? err.message : String(err);
           if (err instanceof DOMException && err.name === "TimeoutError") {
             return {
               content: [{
@@ -41486,17 +42705,17 @@ var init_http_mcp_tool_executor = __esm({
               isError: true
             };
           }
-          return { content: [{ type: "text", text: msg }], isError: true };
+          return { content: [{ type: "text", text: publicErrorMessage("service_unavailable") }], isError: true };
         }
       }
       async callConnectedMutation(path6, body, timeoutMs = this.timeoutMs) {
-        const fingerprint = (0, import_node_crypto22.createHash)("sha256").update("POST").update("\0").update(path6).update("\0").update(JSON.stringify(body)).digest("hex");
+        const fingerprint = (0, import_node_crypto23.createHash)("sha256").update("POST").update("\0").update(path6).update("\0").update(JSON.stringify(body)).digest("hex");
         const now = Date.now();
         for (const [pendingFingerprint, pendingEntry] of this.pendingConnectedMutationKeys) {
           if (pendingEntry.expiresAt <= now) this.pendingConnectedMutationKeys.delete(pendingFingerprint);
         }
         const pending = this.pendingConnectedMutationKeys.get(fingerprint);
-        const idempotencyKey2 = pending && pending.expiresAt > now ? pending.key : (0, import_node_crypto22.randomUUID)();
+        const idempotencyKey2 = pending && pending.expiresAt > now ? pending.key : (0, import_node_crypto23.randomUUID)();
         this.pendingConnectedMutationKeys.set(fingerprint, {
           key: idempotencyKey2,
           expiresAt: now + 15 * 6e4
@@ -41510,13 +42729,13 @@ var init_http_mcp_tool_executor = __esm({
         return result;
       }
       async callDirectoryWorkflowStart(body, explicitIdempotencyKey) {
-        const idempotencyKey2 = `mcp-directory-${(0, import_node_crypto22.createHash)("sha256").update(explicitIdempotencyKey).digest("hex")}`;
+        const idempotencyKey2 = `mcp-directory-${(0, import_node_crypto23.createHash)("sha256").update(explicitIdempotencyKey).digest("hex")}`;
         return this.call("/directory/run", body, this.timeoutMs, "POST", {
           "Idempotency-Key": idempotencyKey2
         });
       }
       async callSiteExtractStart(toolName, body, explicitIdempotencyKey) {
-        const idempotencyKey2 = `mcp-site-${(0, import_node_crypto22.createHash)("sha256").update(toolName).update("\0").update(explicitIdempotencyKey).digest("hex")}`;
+        const idempotencyKey2 = `mcp-site-${(0, import_node_crypto23.createHash)("sha256").update(toolName).update("\0").update(explicitIdempotencyKey).digest("hex")}`;
         return this.call("/extract-site", body, this.timeoutMs, "POST", {
           "Idempotency-Key": idempotencyKey2
         });
@@ -41535,9 +42754,8 @@ var init_http_mcp_tool_executor = __esm({
             return { content: [{ type: "text", text: JSON.stringify(httpErrorPayload(path6, res, data)) }], isError: true };
           }
           return { content: [{ type: "text", text: JSON.stringify(data) }] };
-        } catch (err) {
-          const msg = err instanceof Error ? err.message : String(err);
-          return { content: [{ type: "text", text: msg }], isError: true };
+        } catch {
+          return { content: [{ type: "text", text: publicErrorMessage("service_unavailable") }], isError: true };
         }
       }
       async getTextArtifact(path6, maxBytes, timeoutMs = this.timeoutMs) {
@@ -41551,7 +42769,13 @@ var init_http_mcp_tool_executor = __esm({
           });
           if (!res.ok) {
             const data = await res.json().catch(async () => ({ error: await res.text().catch(() => `HTTP ${res.status}`) }));
-            return { content: [{ type: "text", text: JSON.stringify(data) }], isError: true };
+            return {
+              content: [{
+                type: "text",
+                text: JSON.stringify(res.status >= 500 ? httpErrorPayload(path6, res, data) : sanitizeOutboundDiagnostics(data))
+              }],
+              isError: true
+            };
           }
           const bytes = Buffer.from(await res.arrayBuffer());
           const sliced = bytes.subarray(0, Math.min(maxBytes, bytes.length));
@@ -41568,8 +42792,7 @@ var init_http_mcp_tool_executor = __esm({
             }]
           };
         } catch (err) {
-          const msg = err instanceof Error ? err.message : String(err);
-          return { content: [{ type: "text", text: msg }], isError: true };
+          return { content: [{ type: "text", text: publicErrorMessage("service_unavailable") }], isError: true };
         }
       }
       harvestPaa(input) {
@@ -41789,13 +43012,13 @@ var init_http_mcp_tool_executor = __esm({
         return this.call("/editorial-reading-room/renew-download", input);
       }
       async captureSerpSnapshot(input) {
-        const fingerprint = (0, import_node_crypto22.createHash)("sha256").update(JSON.stringify(input)).digest("hex");
+        const fingerprint = (0, import_node_crypto23.createHash)("sha256").update(JSON.stringify(input)).digest("hex");
         const now = Date.now();
         for (const [pendingFingerprint, pendingEntry] of this.pendingSerpCaptureBillingKeys) {
           if (pendingEntry.expiresAt <= now) this.pendingSerpCaptureBillingKeys.delete(pendingFingerprint);
         }
         const pending = this.pendingSerpCaptureBillingKeys.get(fingerprint);
-        const idempotencyKey2 = pending && pending.expiresAt > now ? pending.key : (0, import_node_crypto22.randomUUID)();
+        const idempotencyKey2 = pending && pending.expiresAt > now ? pending.key : (0, import_node_crypto23.randomUUID)();
         this.pendingSerpCaptureBillingKeys.set(fingerprint, {
           key: idempotencyKey2,
           expiresAt: now + 15 * 6e4
@@ -42632,8 +43855,7 @@ function errorResult(tool, value, sessionId = null, replayId = null) {
     tool,
     session_id: sessionId,
     ...replayId !== null ? { replay_id: replayId } : {},
-    error: errorMessage4(value),
-    raw: value && typeof value === "object" ? value : { value }
+    error: errorMessage4(value)
   }, true);
 }
 function actionResult(tool, sessionId, ok, data, nextRecommendedTool = "browser_screenshot") {
@@ -42718,8 +43940,8 @@ function registerBrowserAgentMcpTools(server, opts) {
       });
       const data = await res.json().catch(() => ({}));
       return { ok: res.ok, data };
-    } catch (err) {
-      return { ok: false, data: { error: err instanceof Error ? err.message : String(err) } };
+    } catch {
+      return { ok: false, data: { error: publicErrorMessage("service_unavailable") } };
     }
   }
   async function downloadReplay(sessionId, replayId, filename) {
@@ -42748,8 +43970,8 @@ function registerBrowserAgentMcpTools(server, opts) {
           download_url: `${baseUrl}${path6}`
         }
       };
-    } catch (err) {
-      return { ok: false, data: { error: err instanceof Error ? err.message : String(err) } };
+    } catch {
+      return { ok: false, data: { error: publicErrorMessage("service_unavailable") } };
     }
   }
   const annotations = (title, readOnly = false) => ({
@@ -43421,6 +44643,7 @@ var init_browser_agent_mcp_server = __esm({
     init_browser_agent_tool_schemas();
     init_replay_annotator();
     init_outbound_sanitize();
+    init_errors();
     init_output_schema_registry();
   }
 });
@@ -46812,7 +48035,7 @@ async function runBrowserAgentMigration() {
 }
 async function createExtensionRow(input) {
   const db = getDb();
-  const id = `bext_${(0, import_node_crypto23.randomUUID)().replace(/-/g, "").slice(0, 20)}`;
+  const id = `bext_${(0, import_node_crypto24.randomUUID)().replace(/-/g, "").slice(0, 20)}`;
   await db.execute({
     sql: `INSERT INTO browser_agent_extensions (id, user_id, name, backend_id, backend_name, source, source_url, size_bytes)
           VALUES (?, ?, ?, ?, ?, ?, ?, ?)`,
@@ -46847,7 +48070,7 @@ async function deleteExtensionRow(userId, name) {
 }
 async function createAuthConnectionRow(input) {
   const db = getDb();
-  const connectionId = `authc_${(0, import_node_crypto23.randomUUID)().replace(/-/g, "").slice(0, 20)}`;
+  const connectionId = `authc_${(0, import_node_crypto24.randomUUID)().replace(/-/g, "").slice(0, 20)}`;
   await db.execute({
     sql: `INSERT INTO browser_auth_connections (connection_id, domain, profile, account_email, note, status, browser_agent_session_id)
           VALUES (?, ?, ?, ?, ?, 'NEEDS_AUTH', ?)`,
@@ -46932,7 +48155,7 @@ async function deleteProfileLabel(userId, profile) {
 }
 async function createSessionRow(input) {
   const db = getDb();
-  const id = `bas_${(0, import_node_crypto23.randomUUID)().replace(/-/g, "").slice(0, 20)}`;
+  const id = `bas_${(0, import_node_crypto24.randomUUID)().replace(/-/g, "").slice(0, 20)}`;
   await db.execute({
     sql: `INSERT INTO browser_agent_sessions (id, runtime_session_id, live_view_url, cdp_ws_url, status, label, user_id, concurrency_lock_id, last_action_at)
           VALUES (?, ?, ?, ?, 'open', ?, ?, ?, datetime('now'))`,
@@ -47001,7 +48224,7 @@ async function recordAction(input) {
     sql: `INSERT INTO browser_agent_actions (id, session_id, type, params_json, ok, error)
           VALUES (?, ?, ?, ?, ?, ?)`,
     args: [
-      `baa_${(0, import_node_crypto23.randomUUID)().replace(/-/g, "").slice(0, 20)}`,
+      `baa_${(0, import_node_crypto24.randomUUID)().replace(/-/g, "").slice(0, 20)}`,
       input.sessionId,
       input.type,
       input.params == null ? null : JSON.stringify(input.params),
@@ -47041,11 +48264,11 @@ async function listReplayRows(sessionId) {
   });
   return res.rows;
 }
-var import_node_crypto23, _ready2, _migrationPromise2;
+var import_node_crypto24, _ready2, _migrationPromise2;
 var init_browser_agent_db = __esm({
   "src/api/browser-agent-db.ts"() {
     "use strict";
-    import_node_crypto23 = require("crypto");
+    import_node_crypto24 = require("crypto");
     init_db();
     _ready2 = false;
     _migrationPromise2 = null;
@@ -47807,7 +49030,7 @@ function keepHostedBrowserAlive(_browser) {
 function client() {
   const apiKey = browserServiceApiKey();
   if (!apiKey) throw new Error("Browser backend API key is required");
-  return new import_sdk8.default({ apiKey });
+  return new import_sdk9.default({ apiKey });
 }
 function isProfileConflict(err) {
   const message = err instanceof Error ? err.message : String(err);
@@ -48165,11 +49388,11 @@ async function replayList(runtimeSessionId) {
     finishedAt: r.finished_at ?? null
   }));
 }
-var import_sdk8, import_playwright5, DEFAULT_TIMEOUT_SECONDS;
+var import_sdk9, import_playwright5, DEFAULT_TIMEOUT_SECONDS;
 var init_browser_agent_service = __esm({
   "src/services/browser-agent/browser-agent-service.ts"() {
     "use strict";
-    import_sdk8 = __toESM(require("@onkernel/sdk"), 1);
+    import_sdk9 = __toESM(require("@onkernel/sdk"), 1);
     import_playwright5 = require("playwright");
     init_browser_service_env();
     init_run_capture();
@@ -48801,7 +50024,7 @@ function buildBrowserAgentRoutes() {
     }
     const existing = await getExtensionRow(user.id, name);
     if (existing) return c.json({ error: `an extension named "${name}" already exists \u2014 delete it first or pick another name` }, 409);
-    const backendName = `u${user.id}_${(0, import_node_crypto24.randomUUID)().replace(/-/g, "")}`;
+    const backendName = `u${user.id}_${(0, import_node_crypto25.randomUUID)().replace(/-/g, "")}`;
     try {
       const imported = await importExtensionFromStore(storeUrl, backendName);
       const row = await createExtensionRow({
@@ -48860,11 +50083,11 @@ function buildBrowserAgentRoutes() {
   });
   return app2;
 }
-var import_node_crypto24, import_hono21, auth, DEFAULT_BROWSER_SESSION_LOCK_TTL_SECONDS, EXTENSION_NAME_RE;
+var import_node_crypto25, import_hono21, auth, DEFAULT_BROWSER_SESSION_LOCK_TTL_SECONDS, EXTENSION_NAME_RE;
 var init_browser_agent_routes = __esm({
   "src/api/browser-agent-routes.ts"() {
     "use strict";
-    import_node_crypto24 = require("crypto");
+    import_node_crypto25 = require("crypto");
     import_hono21 = require("hono");
     init_api_auth();
     init_errors();
@@ -49343,7 +50566,7 @@ async function getKeys() {
   const privateKey = await (0, import_jose2.importPKCS8)(pem, "RS256", { extractable: true });
   const full = await (0, import_jose2.exportJWK)(privateKey);
   const publicJwk = { kty: full.kty, n: full.n, e: full.e };
-  const kid = (0, import_node_crypto25.createHash)("sha256").update(JSON.stringify({ e: publicJwk.e, kty: publicJwk.kty, n: publicJwk.n })).digest("base64url").slice(0, 16);
+  const kid = (0, import_node_crypto26.createHash)("sha256").update(JSON.stringify({ e: publicJwk.e, kty: publicJwk.kty, n: publicJwk.n })).digest("base64url").slice(0, 16);
   publicJwk.kid = kid;
   publicJwk.alg = "RS256";
   publicJwk.use = "sig";
@@ -49522,23 +50745,23 @@ async function validateAuthRequest(p) {
 }
 function pkceMatches(verifier, challenge) {
   if (!verifier) return false;
-  const computed = (0, import_node_crypto25.createHash)("sha256").update(verifier).digest("base64url");
+  const computed = (0, import_node_crypto26.createHash)("sha256").update(verifier).digest("base64url");
   return computed === challenge;
 }
 async function mintAccessToken(identity, scope, plan, audience) {
   const { privateKey, kid } = await getKeys();
-  return new import_jose2.SignJWT({ scope, plan }).setProtectedHeader({ alg: "RS256", kid }).setIssuer(ISSUER).setSubject(identity).setAudience(audience).setIssuedAt().setJti((0, import_node_crypto25.randomUUID)()).setExpirationTime(`${ACCESS_TTL_SECONDS}s`).sign(privateKey);
+  return new import_jose2.SignJWT({ scope, plan }).setProtectedHeader({ alg: "RS256", kid }).setIssuer(ISSUER).setSubject(identity).setAudience(audience).setIssuedAt().setJti((0, import_node_crypto26.randomUUID)()).setExpirationTime(`${ACCESS_TTL_SECONDS}s`).sign(privateKey);
 }
 function tokenErrorResponse(c, error, description, status) {
   return c.json({ error, error_description: description }, status);
 }
-var import_hono23, import_cookie, import_node_crypto25, import_jose2, ISSUER, RESOURCE, SCRAPER_RESOURCE, MEMORY_SCOPES, SCRAPER_SCOPES, SUPPORTED_SCOPES, ACCESS_TTL_SECONDS, REFRESH_TTL_SECONDS, CODE_TTL_SECONDS, ROTATION_GRACE_SECONDS, secureCookies, sessionCookieOptions, cachedKeys, oauthApp;
+var import_hono23, import_cookie, import_node_crypto26, import_jose2, ISSUER, RESOURCE, SCRAPER_RESOURCE, MEMORY_SCOPES, SCRAPER_SCOPES, SUPPORTED_SCOPES, ACCESS_TTL_SECONDS, REFRESH_TTL_SECONDS, CODE_TTL_SECONDS, ROTATION_GRACE_SECONDS, secureCookies, sessionCookieOptions, cachedKeys, oauthApp;
 var init_oauth_routes = __esm({
   "src/api/oauth-routes.ts"() {
     "use strict";
     import_hono23 = require("hono");
     import_cookie = require("hono/cookie");
-    import_node_crypto25 = require("crypto");
+    import_node_crypto26 = require("crypto");
     import_jose2 = require("jose");
     init_session();
     init_db();
@@ -49624,7 +50847,7 @@ var init_oauth_routes = __esm({
         }
       }
       const clientName = typeof body.client_name === "string" ? body.client_name : null;
-      const clientId = `client_${(0, import_node_crypto25.randomBytes)(16).toString("hex")}`;
+      const clientId = `client_${(0, import_node_crypto26.randomBytes)(16).toString("hex")}`;
       await registerClient(clientId, redirectUris, clientName);
       console.log("[oauth-dcr] register OK client_id=%s redirect_uris=%s", clientId, JSON.stringify(redirectUris));
       return c.json({
@@ -49677,7 +50900,7 @@ var init_oauth_routes = __esm({
       if (action === "deny") return redirectWithError(p.redirect_uri, p.state, "access_denied");
       if (action !== "approve") return c.text("unsupported action", 400);
       const scope = negotiateScope(p.scope, user, p.resource);
-      const code = `code_${(0, import_node_crypto25.randomBytes)(32).toString("base64url")}`;
+      const code = `code_${(0, import_node_crypto26.randomBytes)(32).toString("base64url")}`;
       const expiresAt = new Date(Date.now() + CODE_TTL_SECONDS * 1e3).toISOString();
       await putCode({
         code,
@@ -49716,7 +50939,7 @@ var init_oauth_routes = __esm({
         const plan = user ? resolvePlan(user) : "free";
         const audience = record.resource ?? RESOURCE();
         const accessToken = await mintAccessToken(record.identity, record.scope, plan, audience);
-        const refreshToken = `rt_${(0, import_node_crypto25.randomBytes)(40).toString("base64url")}`;
+        const refreshToken = `rt_${(0, import_node_crypto26.randomBytes)(40).toString("base64url")}`;
         await putRefresh({
           refresh_token: refreshToken,
           client_id: clientId,
@@ -49746,7 +50969,7 @@ var init_oauth_routes = __esm({
         const plan = user ? resolvePlan(user) : "free";
         const audience = record.resource ?? RESOURCE();
         const accessToken = await mintAccessToken(record.identity, record.scope, plan, audience);
-        const nextRefresh = `rt_${(0, import_node_crypto25.randomBytes)(40).toString("base64url")}`;
+        const nextRefresh = `rt_${(0, import_node_crypto26.randomBytes)(40).toString("base64url")}`;
         await rotateRefresh(refreshToken, {
           refresh_token: nextRefresh,
           client_id: record.client_id,
@@ -51166,7 +52389,7 @@ function quoteUntrusted(value) {
   return clean2.split("\n").map((line) => `> ${line}`).join("\n");
 }
 function shortHash(value, length = 24) {
-  return (0, import_node_crypto26.createHash)("sha256").update(value).digest("hex").slice(0, length);
+  return (0, import_node_crypto27.createHash)("sha256").update(value).digest("hex").slice(0, length);
 }
 function safePathPart(value) {
   return value.toLowerCase().replace(/[^a-z0-9]+/g, "-").replace(/^-+|-+$/g, "").slice(0, 48) || "contact";
@@ -51654,11 +52877,11 @@ async function captureSupportMessage(memoryKey, email, options) {
     direction: options.direction
   };
 }
-var import_node_crypto26, SUPPORT_TAGS, ISSUE_TAGS;
+var import_node_crypto27, SUPPORT_TAGS, ISSUE_TAGS;
 var init_resend_support_thread = __esm({
   "src/api/resend-support-thread.ts"() {
     "use strict";
-    import_node_crypto26 = require("crypto");
+    import_node_crypto27 = require("crypto");
     init_memory();
     SUPPORT_TAGS = [
       {
@@ -52243,7 +53466,7 @@ async function claimWorkshopRegistration(input) {
       ) < ?
     `,
     args: [
-      (0, import_node_crypto27.randomUUID)(),
+      (0, import_node_crypto28.randomUUID)(),
       input.eventSlug,
       input.email,
       input.firstName,
@@ -52260,7 +53483,7 @@ async function claimWorkshopRegistration(input) {
         id, event_slug, email, first_name, last_name, status
       ) VALUES (?, ?, ?, ?, ?, 'waitlisted')
     `,
-    args: [(0, import_node_crypto27.randomUUID)(), input.eventSlug, input.email, input.firstName, input.lastName || null]
+    args: [(0, import_node_crypto28.randomUUID)(), input.eventSlug, input.email, input.firstName, input.lastName || null]
   });
   const waitlisted = await getWorkshopRegistration(input.eventSlug, input.email);
   if (!waitlisted) throw new Error("workshop registration could not be claimed");
@@ -52275,7 +53498,7 @@ async function registerWorkshopInterest(input) {
         id, event_slug, email, first_name, last_name, status
       ) VALUES (?, ?, ?, ?, ?, 'interested')
     `,
-    args: [(0, import_node_crypto27.randomUUID)(), input.eventSlug, input.email, input.firstName, input.lastName || null]
+    args: [(0, import_node_crypto28.randomUUID)(), input.eventSlug, input.email, input.firstName, input.lastName || null]
   });
   const registration = await getWorkshopRegistration(input.eventSlug, input.email);
   if (!registration) throw new Error("workshop interest could not be recorded");
@@ -52305,11 +53528,11 @@ async function updateWorkshopRegistration(id, patch) {
     args: [...entries.map(([, value]) => value), id]
   });
 }
-var import_node_crypto27;
+var import_node_crypto28;
 var init_workshop_registration_repository = __esm({
   "src/api/workshop-registration-repository.ts"() {
     "use strict";
-    import_node_crypto27 = require("crypto");
+    import_node_crypto28 = require("crypto");
     init_db();
   }
 });
@@ -52854,15 +54077,15 @@ function renderEditorialReadingRoom(input, now = /* @__PURE__ */ new Date()) {
     articleCount: articles.length,
     wordCount: totalWordCount,
     bytes,
-    sha256: (0, import_node_crypto28.createHash)("sha256").update(html).digest("hex"),
+    sha256: (0, import_node_crypto29.createHash)("sha256").update(html).digest("hex"),
     warnings
   };
 }
-var import_node_crypto28, import_node_fs14, import_node_path19, import_marked, runtimeEntryDir, assetCache;
+var import_node_crypto29, import_node_fs14, import_node_path19, import_marked, runtimeEntryDir, assetCache;
 var init_render = __esm({
   "src/editorial-reading-room/render.ts"() {
     "use strict";
-    import_node_crypto28 = require("crypto");
+    import_node_crypto29 = require("crypto");
     import_node_fs14 = require("fs");
     import_node_path19 = require("path");
     import_marked = require("marked");
@@ -53137,7 +54360,7 @@ var init_site_extract_reconciliation = __esm({
 
 // src/api/page-diff.ts
 function sha256Hex(value) {
-  return (0, import_node_crypto29.createHash)("sha256").update(value).digest("hex");
+  return (0, import_node_crypto30.createHash)("sha256").update(value).digest("hex");
 }
 function truncateForStorage(value, maxChars = MAX_SNAPSHOT_CONTENT_CHARS) {
   if (value.length <= maxChars) return { value, truncated: false };
@@ -53194,11 +54417,11 @@ function diffPageContent(oldContent, newContent) {
     totalChangedLineCount
   };
 }
-var import_node_crypto29, import_diff, MAX_SNAPSHOT_CONTENT_CHARS, MAX_DIFF_HUNKS, MAX_DIFF_LINES_PER_RESPONSE;
+var import_node_crypto30, import_diff, MAX_SNAPSHOT_CONTENT_CHARS, MAX_DIFF_HUNKS, MAX_DIFF_LINES_PER_RESPONSE;
 var init_page_diff = __esm({
   "src/api/page-diff.ts"() {
     "use strict";
-    import_node_crypto29 = require("crypto");
+    import_node_crypto30 = require("crypto");
     import_diff = require("diff");
     MAX_SNAPSHOT_CONTENT_CHARS = 25e4;
     MAX_DIFF_HUNKS = 200;
@@ -53697,7 +54920,7 @@ function canonicalJson(value) {
   return JSON.stringify(value);
 }
 function sha2562(value) {
-  return (0, import_node_crypto30.createHash)("sha256").update(value).digest("hex");
+  return (0, import_node_crypto31.createHash)("sha256").update(value).digest("hex");
 }
 function sensitiveKey(key) {
   const normalized = key.toLowerCase().replace(/[^a-z0-9]/g, "");
@@ -53912,11 +55135,11 @@ async function importServiceConnectionToMemory(identity, input, dependencies) {
     ...!searchReady ? { warning: "The snapshot was stored, but no search chunks were indexed yet." } : {}
   };
 }
-var import_node_crypto30, CONNECTION_MEMORY_IMPORT_MAX_ARGS_BYTES, CONNECTION_MEMORY_IMPORT_MAX_RESULT_BYTES, CONNECTION_MEMORY_IMPORT_MAX_STRING_CHARS, CONNECTION_MEMORY_IMPORT_MAX_DEPTH, ConnectionMemoryImportError;
+var import_node_crypto31, CONNECTION_MEMORY_IMPORT_MAX_ARGS_BYTES, CONNECTION_MEMORY_IMPORT_MAX_RESULT_BYTES, CONNECTION_MEMORY_IMPORT_MAX_STRING_CHARS, CONNECTION_MEMORY_IMPORT_MAX_DEPTH, ConnectionMemoryImportError;
 var init_connection_memory_import = __esm({
   "src/api/connection-memory-import.ts"() {
     "use strict";
-    import_node_crypto30 = require("crypto");
+    import_node_crypto31 = require("crypto");
     init_slugify();
     CONNECTION_MEMORY_IMPORT_MAX_ARGS_BYTES = 64 * 1024;
     CONNECTION_MEMORY_IMPORT_MAX_RESULT_BYTES = 1e6;
@@ -54090,7 +55313,7 @@ function finitePositive(value, fallback) {
   return Number.isFinite(value) && value > 0 ? value : fallback;
 }
 async function collectConnectedDataExport(args) {
-  const exportId = (0, import_node_crypto31.randomUUID)();
+  const exportId = (0, import_node_crypto32.randomUUID)();
   const now = args.now ?? Date.now;
   const startedAt = now();
   const budgetMs = finitePositive(CONNECTED_DATA_EXPORT_BUDGET_MS, 24e4);
@@ -54200,11 +55423,11 @@ ${lines.length ? `${lines.join("\n")}
     untrustedContent: true
   };
 }
-var import_node_crypto31, CONNECTED_DATA_INLINE_BUDGET_BYTES, CONNECTED_DATA_MAX_EXPORT_BYTES, CONNECTED_DATA_EXPORT_BUDGET_MS, CONNECTED_DATA_PAGE_START_HEADROOM_MS, CONNECTED_DATA_DATASETS, ConnectedDataExportValidationError;
+var import_node_crypto32, CONNECTED_DATA_INLINE_BUDGET_BYTES, CONNECTED_DATA_MAX_EXPORT_BYTES, CONNECTED_DATA_EXPORT_BUDGET_MS, CONNECTED_DATA_PAGE_START_HEADROOM_MS, CONNECTED_DATA_DATASETS, ConnectedDataExportValidationError;
 var init_connected_data_export = __esm({
   "src/api/connected-data-export.ts"() {
     "use strict";
-    import_node_crypto31 = require("crypto");
+    import_node_crypto32 = require("crypto");
     CONNECTED_DATA_INLINE_BUDGET_BYTES = Number(
       process.env.MCP_SCRAPER_CONNECTED_DATA_INLINE_BUDGET_BYTES ?? 5e4
     );
@@ -54317,7 +55540,7 @@ async function exportSearchConsoleTableData(args) {
     offset += rows.length;
     if (stoppedForBytes || rows.length < limit || offset >= matchedRows) break;
   }
-  const exportId = (0, import_node_crypto32.randomUUID)();
+  const exportId = (0, import_node_crypto33.randomUUID)();
   const artifact = await args.writeArtifact({
     ownerId: args.ownerId,
     exportId,
@@ -54339,11 +55562,11 @@ async function exportSearchConsoleTableData(args) {
     warnings
   };
 }
-var import_node_crypto32, SEARCH_CONSOLE_TABLE_EXPORT_MAX_ROWS, SEARCH_CONSOLE_TABLE_EXPORT_PAGE_SIZE, SEARCH_CONSOLE_TABLE_EXPORT_MAX_BYTES, SEARCH_CONSOLE_TABLE_COLUMNS, SearchConsoleTableExportValidationError;
+var import_node_crypto33, SEARCH_CONSOLE_TABLE_EXPORT_MAX_ROWS, SEARCH_CONSOLE_TABLE_EXPORT_PAGE_SIZE, SEARCH_CONSOLE_TABLE_EXPORT_MAX_BYTES, SEARCH_CONSOLE_TABLE_COLUMNS, SearchConsoleTableExportValidationError;
 var init_search_console_table_export = __esm({
   "src/api/search-console-table-export.ts"() {
     "use strict";
-    import_node_crypto32 = require("crypto");
+    import_node_crypto33 = require("crypto");
     SEARCH_CONSOLE_TABLE_EXPORT_MAX_ROWS = 5e4;
     SEARCH_CONSOLE_TABLE_EXPORT_PAGE_SIZE = 2e3;
     SEARCH_CONSOLE_TABLE_EXPORT_MAX_BYTES = 50 * 1024 * 1024;
@@ -54771,7 +55994,7 @@ async function reconcileDiscoveredNangoConnections(identity, discovered) {
           updated_at = excluded.updated_at
       `,
       args: [
-        (0, import_node_crypto33.randomUUID)(),
+        (0, import_node_crypto34.randomUUID)(),
         userId,
         connection.providerConfigKey,
         connection.provider,
@@ -54842,7 +56065,7 @@ async function recordServiceConnectionHealth(args) {
   });
   await getDb().execute({
     sql: `INSERT INTO service_connection_health_events (id, connection_id, operational_status, failure_code, retryable, evidence_source) VALUES (?, ?, ?, ?, ?, ?)`,
-    args: [(0, import_node_crypto33.randomUUID)(), args.connectionId, args.operationalStatus, args.failureCode ?? null, args.retryable == null ? null : args.retryable ? 1 : 0, args.evidenceSource]
+    args: [(0, import_node_crypto34.randomUUID)(), args.connectionId, args.operationalStatus, args.failureCode ?? null, args.retryable == null ? null : args.retryable ? 1 : 0, args.evidenceSource]
   });
 }
 async function setServiceConnectionActions(identity, connectionId, enabled) {
@@ -54882,7 +56105,7 @@ async function claimServiceConnectionAction(args) {
   if (!connection) throw new Error("service_connection_not_found");
   const inserted = await getDb().execute({
     sql: `INSERT OR IGNORE INTO service_connection_action_audit (id, connection_id, user_id, tool, request_id, status) VALUES (?, ?, ?, ?, ?, 'started')`,
-    args: [(0, import_node_crypto33.randomUUID)(), connection.id, connection.userId, args.tool, args.requestId]
+    args: [(0, import_node_crypto34.randomUUID)(), connection.id, connection.userId, args.tool, args.requestId]
   });
   if (Number(inserted.rowsAffected ?? 0) === 1) return { claimed: true };
   const existing = await getDb().execute({
@@ -54895,11 +56118,11 @@ async function claimServiceConnectionAction(args) {
     errorCode: typeof existing.rows[0]?.error_code === "string" ? existing.rows[0].error_code : null
   };
 }
-var import_node_crypto33, schemaReady2, schemaDb3;
+var import_node_crypto34, schemaReady2, schemaDb3;
 var init_service_connections = __esm({
   "src/api/service-connections.ts"() {
     "use strict";
-    import_node_crypto33 = require("crypto");
+    import_node_crypto34 = require("crypto");
     init_db();
     schemaReady2 = null;
     schemaDb3 = null;
@@ -55163,7 +56386,7 @@ async function withNangoClient(connection, run) {
       }
     }
   });
-  const client2 = new import_client9.Client({ name: "mcp-scraper-integrations", version: "1.0.0" }, { capabilities: {} });
+  const client2 = new import_client11.Client({ name: "mcp-scraper-integrations", version: "1.0.0" }, { capabilities: {} });
   try {
     await client2.connect(transport);
     const value = await run(client2);
@@ -55216,7 +56439,7 @@ async function listNangoToolsDirect(identity, connectionId) {
   });
   const readTools = tools.filter((tool) => classifyTool(tool) === "read").map((tool) => tool.name);
   const actionTools = tools.filter((tool) => classifyTool(tool) === "action").map((tool) => tool.name);
-  const revision = (0, import_node_crypto34.createHash)("sha256").update(JSON.stringify(tools.map((tool) => ({ name: tool.name, inputSchema: tool.inputSchema })))).digest("hex");
+  const revision = (0, import_node_crypto35.createHash)("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 };
@@ -55236,8 +56459,8 @@ async function callNangoToolDirect(args) {
     identity: args.identity,
     ratePolicyVersion: CONNECTED_USAGE_RATE_POLICY_VERSION
   });
-  const requestId = args.requestId?.trim() || (0, import_node_crypto34.randomUUID)();
-  const idempotencyKey2 = `main-nango:${(0, import_node_crypto34.createHash)("sha256").update(args.identity.toLowerCase()).update("\0").update(connection.id).update("\0").update(args.tool).update("\0").update(requestId).digest("hex")}`;
+  const requestId = args.requestId?.trim() || (0, import_node_crypto35.randomUUID)();
+  const idempotencyKey2 = `main-nango:${(0, import_node_crypto35.createHash)("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;
@@ -55262,7 +56485,7 @@ async function callNangoToolDirect(args) {
       toolName: args.tool,
       operationKind: args.operationKind ?? args.classification,
       outcome: providerError ? "error" : "partial",
-      requestId: requestId.length <= 200 ? requestId : (0, import_node_crypto34.createHash)("sha256").update(requestId).digest("hex"),
+      requestId: requestId.length <= 200 ? requestId : (0, import_node_crypto35.createHash)("sha256").update(requestId).digest("hex"),
       startedAt: startedAt.toISOString(),
       completedAt: completedAt.toISOString()
     }
@@ -55299,16 +56522,16 @@ async function describeNangoToolDirect(identity, connectionId, toolName) {
     providerContractHash: MAIN_INTEGRATION_CONTRACT_HASH,
     protocolVersion: null,
     schemaSource: "live_tools_list",
-    schemaHash: (0, import_node_crypto34.createHash)("sha256").update(JSON.stringify(projected)).digest("hex"),
+    schemaHash: (0, import_node_crypto35.createHash)("sha256").update(JSON.stringify(projected)).digest("hex"),
     fetchedAt: (/* @__PURE__ */ new Date()).toISOString()
   };
 }
-var import_node_crypto34, import_client9, import_streamableHttp, DEFAULT_NANGO_MCP_URL, NANGO_TIMEOUT_MS, NANGO_CONNECTION_PAGE_SIZE, NANGO_CONNECTION_MAX_PAGES, MAIN_INTEGRATION_CONTRACT_VERSION, MAIN_INTEGRATION_CONTRACT_HASH, MainNangoTransportError;
+var import_node_crypto35, import_client11, import_streamableHttp, DEFAULT_NANGO_MCP_URL, NANGO_TIMEOUT_MS, NANGO_CONNECTION_PAGE_SIZE, NANGO_CONNECTION_MAX_PAGES, MAIN_INTEGRATION_CONTRACT_VERSION, MAIN_INTEGRATION_CONTRACT_HASH, MainNangoTransportError;
 var init_main_nango_transport = __esm({
   "src/api/main-nango-transport.ts"() {
     "use strict";
-    import_node_crypto34 = require("crypto");
-    import_client9 = require("@modelcontextprotocol/sdk/client/index.js");
+    import_node_crypto35 = require("crypto");
+    import_client11 = require("@modelcontextprotocol/sdk/client/index.js");
     import_streamableHttp = require("@modelcontextprotocol/sdk/client/streamableHttp.js");
     init_service_connections();
     init_connected_usage_billing();
@@ -55929,7 +57152,7 @@ async function setScheduleConnectionActionsEnabled(identity, connectionId, enabl
   return data.connection.actionsEnabled === true;
 }
 async function callScheduleConnectionAction(identity, connectionId, input, tool, idempotencyKey2) {
-  const requestId = `main-connected-action:${(0, import_node_crypto35.createHash)("sha256").update(identity).update("\0").update(idempotencyKey2?.trim() || (0, import_node_crypto35.randomUUID)()).digest("hex")}`;
+  const requestId = `main-connected-action:${(0, import_node_crypto36.createHash)("sha256").update(identity).update("\0").update(idempotencyKey2?.trim() || (0, import_node_crypto36.randomUUID)()).digest("hex")}`;
   if (mainOwnsIntegrations()) {
     const selectedTool = tool?.trim();
     if (!selectedTool) throw new NangoControlError("An action tool is required.", 400, "invalid_request", false);
@@ -56071,7 +57294,7 @@ function canonicalJson2(value) {
   return JSON.stringify(value);
 }
 function projectedToolSchemaHash(tool) {
-  return (0, import_node_crypto35.createHash)("sha256").update(canonicalJson2(tool)).digest("hex");
+  return (0, import_node_crypto36.createHash)("sha256").update(canonicalJson2(tool)).digest("hex");
 }
 async function describeNangoTool(identity, connectionId, tool, fresh) {
   if (mainOwnsIntegrations()) {
@@ -56332,11 +57555,11 @@ async function callMainOwnedExportPage(identity, input) {
     untrustedContent: true
   };
 }
-var import_node_crypto35, DEFAULT_NANGO_CONTROL_URL, DISABLED_NANGO_TOOLS, CONNECTION_SYNC_REQUIRED_TOOLS, CONNECTION_SYNC_OPTIONAL_TOOLS, NangoControlError, ScheduleConnectionValidationError, SAFE_CONTROL_ERROR_CODES, FIXED_CONTROL_ERROR_MESSAGES, CONTROL_ERROR_CODE_ALIASES;
+var import_node_crypto36, DEFAULT_NANGO_CONTROL_URL, DISABLED_NANGO_TOOLS, CONNECTION_SYNC_REQUIRED_TOOLS, CONNECTION_SYNC_OPTIONAL_TOOLS, NangoControlError, ScheduleConnectionValidationError, SAFE_CONTROL_ERROR_CODES, FIXED_CONTROL_ERROR_MESSAGES, CONTROL_ERROR_CODE_ALIASES;
 var init_nango_control = __esm({
   "src/api/nango-control.ts"() {
     "use strict";
-    import_node_crypto35 = require("crypto");
+    import_node_crypto36 = require("crypto");
     init_connected_data_export();
     init_main_nango_transport();
     init_service_connections();
@@ -56804,8 +58027,8 @@ function signingSecret() {
   return secret2;
 }
 function schedulerIntegrationSignature(args) {
-  const bodyHash = (0, import_node_crypto36.createHash)("sha256").update(args.body).digest("hex");
-  return (0, import_node_crypto36.createHmac)("sha256", args.secret).update(`${args.method.toUpperCase()}
+  const bodyHash = (0, import_node_crypto37.createHash)("sha256").update(args.body).digest("hex");
+  return (0, import_node_crypto37.createHmac)("sha256", args.secret).update(`${args.method.toUpperCase()}
 ${args.path}
 ${args.timestamp}
 ${args.nonce}
@@ -56852,17 +58075,17 @@ async function verifySchedulerIntegrationRequest(request, rawBody) {
   });
   const suppliedBytes = Buffer.from(signature, "hex");
   const expectedBytes = Buffer.from(expected, "hex");
-  if (suppliedBytes.length !== expectedBytes.length || !(0, import_node_crypto36.timingSafeEqual)(suppliedBytes, expectedBytes)) {
+  if (suppliedBytes.length !== expectedBytes.length || !(0, import_node_crypto37.timingSafeEqual)(suppliedBytes, expectedBytes)) {
     throw new SchedulerIntegrationAuthError("invalid_signature");
   }
   await claimNonce(nonce, timestampMs);
   return { requestId };
 }
-var import_node_crypto36, MAX_CLOCK_SKEW_MS, SchedulerIntegrationAuthError;
+var import_node_crypto37, MAX_CLOCK_SKEW_MS, SchedulerIntegrationAuthError;
 var init_scheduler_integration_auth = __esm({
   "src/api/scheduler-integration-auth.ts"() {
     "use strict";
-    import_node_crypto36 = require("crypto");
+    import_node_crypto37 = require("crypto");
     init_db();
     init_service_connections();
     MAX_CLOCK_SKEW_MS = 5 * 60 * 1e3;
@@ -56877,31 +58100,6 @@ var init_scheduler_integration_auth = __esm({
   }
 });
 
-// src/api/webhook.ts
-async function deliverWebhook(url, payload, retries = 3) {
-  for (let attempt = 1; attempt <= retries; attempt++) {
-    try {
-      const res = await fetch(url, {
-        method: "POST",
-        headers: { "content-type": "application/json" },
-        body: JSON.stringify(payload),
-        signal: AbortSignal.timeout(1e4)
-      });
-      if (res.ok) return;
-      console.warn(`[webhook] attempt ${attempt} \u2192 ${res.status} from ${url}`);
-    } catch (err) {
-      console.warn(`[webhook] attempt ${attempt} failed:`, err instanceof Error ? err.message : err);
-    }
-    if (attempt < retries) await new Promise((r) => setTimeout(r, 1e3 * attempt * 2));
-  }
-  console.error(`[webhook] gave up after ${retries} attempts for ${url}`);
-}
-var init_webhook = __esm({
-  "src/api/webhook.ts"() {
-    "use strict";
-  }
-});
-
 // src/api/worker.ts
 var worker_exports = {};
 __export(worker_exports, {
@@ -56915,8 +58113,8 @@ function countPaaQuestions(result) {
   if (typeof value.totalQuestions === "number") return value.totalQuestions;
   return Array.isArray(value.flat) ? value.flat.length : 0;
 }
-function paaCostForQuestionCount(questionCount) {
-  return MC_COSTS.paa_base + Math.max(1, questionCount) * MC_COSTS.paa;
+function paaCostForQuestionCount(questionCount2) {
+  return MC_COSTS.paa_base + Math.max(1, questionCount2) * MC_COSTS.paa;
 }
 async function processJob(job) {
   running++;
@@ -56948,9 +58146,18 @@ async function processJob(job) {
       else if (diff < 0) await debitMc(job.user_id, -diff, "serp", opts.query ?? job.query);
     }
     if (job.callback_url) {
-      await deliverWebhook(job.callback_url, { job_id: job.id, status: "done", result, attempts });
+      await deliverWebhook(job.callback_url, {
+        job_id: job.id,
+        status: "done",
+        result: sanitizeHarvestResult(result),
+        attempts: sanitizeAttempts(attempts)
+      });
     }
   } catch (err) {
+    console.error("[harvest/worker] failed", {
+      jobId: job.id,
+      error: err instanceof Error ? err.message : String(err)
+    });
     const problem = classifyHarvestProblem(err);
     await failJob(job.id, serializeHarvestProblem(problem));
     const attempts = await listHarvestAttempts(job.id, job.user_id);
@@ -56962,7 +58169,12 @@ async function processJob(job) {
     } catch {
     }
     if (job.callback_url) {
-      await deliverWebhook(job.callback_url, { job_id: job.id, status: "failed", ...harvestProblemResponse(problem), attempts });
+      await deliverWebhook(job.callback_url, {
+        job_id: job.id,
+        status: "failed",
+        ...harvestProblemResponse(problem),
+        attempts: sanitizeAttempts(attempts)
+      });
     }
   } finally {
     running--;
@@ -57005,6 +58217,7 @@ var init_worker = __esm({
     init_harvest_problems();
     init_harvest_attempt_events();
     init_cost_context();
+    init_outbound_sanitize();
     MAX_CONCURRENT = 2;
     running = 0;
   }
@@ -57324,8 +58537,8 @@ function countPaaQuestions2(result) {
   if (typeof value.totalQuestions === "number") return value.totalQuestions;
   return Array.isArray(value.flat) ? value.flat.length : 0;
 }
-function paaCostForQuestionCount2(questionCount) {
-  return MC_COSTS.paa_base + Math.max(1, questionCount) * MC_COSTS.paa;
+function paaCostForQuestionCount2(questionCount2) {
+  return MC_COSTS.paa_base + Math.max(1, questionCount2) * MC_COSTS.paa;
 }
 async function checkHarvestLimits(user, reuseLockId) {
   if (reuseLockId && await reuseExistingConcurrencyGate(user.id, reuseLockId, 30 * 60)) return null;
@@ -57359,7 +58572,7 @@ async function chargeTierChangeNow(stripeClient, subscriptionId, customerId) {
     return { ok: false, amountDue: 0, error: err instanceof Error ? err.message : "Unable to charge the plan change immediately." };
   }
 }
-var import_resend3, import_hono30, import_hono31, import_factory7, import_cookie2, import_stripe2, secureCookies2, isProduction2, sessionCookieOptions2, requireAllowedOrigin, auth2, sessionAuth, requireIntegrationsTier, requirePaidSchedulingTier, app, STRIPE_API_VERSION, SYNC_HARVEST_TIMEOUT_OVERRIDE_MS;
+var import_resend3, import_node_crypto38, import_hono30, import_hono31, import_factory7, import_cookie2, import_stripe2, secureCookies2, isProduction2, sessionCookieOptions2, requireAllowedOrigin, auth2, sessionAuth, requireIntegrationsTier, requirePaidSchedulingTier, app, STRIPE_API_VERSION, SYNC_HARVEST_TIMEOUT_OVERRIDE_MS;
 var init_server = __esm({
   "src/api/server.ts"() {
     "use strict";
@@ -57372,6 +58585,7 @@ var init_server = __esm({
     init_og();
     import_resend3 = require("resend");
     init_url_utils();
+    import_node_crypto38 = require("crypto");
     init_kpo_extractor();
     init_screenshot();
     init_media_extractor();
@@ -57383,6 +58597,7 @@ var init_server = __esm({
     init_site_audit();
     init_site_extract();
     init_directory_workflow2();
+    init_paa_harvest();
     init_site_extract_repository();
     init_site_extract_start();
     init_catalog_seed();
@@ -57407,6 +58622,8 @@ var init_server = __esm({
     init_directory_routes();
     init_location_data_routes();
     init_directory_workflow_dispatch();
+    init_paa_harvest_dispatch();
+    init_paa_harvest_reconciliation();
     init_directory_workflow_reconciliation();
     init_directory_artifacts();
     init_workflow_routes();
@@ -57516,6 +58733,18 @@ var init_server = __esm({
     STRIPE_API_VERSION = "2026-02-25.clover";
     app.use("*", async (c, next) => {
       await next();
+      if (c.res.status >= 500 && c.res.headers.get("content-type")?.includes("application/json")) {
+        try {
+          const payload = await c.res.clone().json();
+          const headers = new Headers(c.res.headers);
+          c.res = new Response(JSON.stringify(sanitizeOutboundDiagnostics(payload)), {
+            status: c.res.status,
+            statusText: c.res.statusText,
+            headers
+          });
+        } catch {
+        }
+      }
       c.header("Cache-Control", "no-store");
       c.header("X-Content-Type-Options", "nosniff");
       c.header("Referrer-Policy", "same-origin");
@@ -58828,9 +60057,50 @@ var init_server = __esm({
         pages: Math.min(2, Math.max(1, body.pages ?? 1))
       };
       const harvestCost = options.serpOnly ? MC_COSTS.serp_headful : paaCostForQuestionCount2(options.maxQuestions);
-      const { ok: harvestOk, balance_mc: harvestBal } = await debitMc(user.id, harvestCost, options.serpOnly ? LedgerOperation.SERP : LedgerOperation.PAA, options.query);
-      if (!harvestOk) return c.json(insufficientBalanceResponse(harvestBal, harvestCost), 402);
-      const jobId2 = await createJob(user.id, options.query, { ...options, billingHoldMc: harvestCost }, body.callback_url);
+      let jobId2;
+      if (options.serpOnly) {
+        const { ok: harvestOk, balance_mc: harvestBal } = await debitMc(
+          user.id,
+          harvestCost,
+          LedgerOperation.SERP,
+          options.query
+        );
+        if (!harvestOk) return c.json(insufficientBalanceResponse(harvestBal, harvestCost), 402);
+        jobId2 = await createJob(user.id, options.query, { ...options, billingHoldMc: harvestCost }, body.callback_url);
+      } else {
+        jobId2 = (0, import_node_crypto38.randomUUID)();
+        const billingDebitKey = `paa-harvest:${jobId2}:hold`;
+        const description = `PAA harvest: ${options.query}`.slice(0, 500);
+        const hold = await debitMcIdempotent(
+          user.id,
+          harvestCost,
+          LedgerOperation.PAA,
+          description,
+          billingDebitKey
+        );
+        if (!hold.ok) return c.json(insufficientBalanceResponse(hold.balance_mc, harvestCost), 402);
+        try {
+          await createJobWithId(jobId2, user.id, options.query, {
+            ...options,
+            executionOwner: "inngest",
+            billingHoldMc: harvestCost,
+            billingDebitKey
+          }, body.callback_url);
+        } catch (error) {
+          await settleDebitMcIdempotent(
+            user.id,
+            billingDebitKey,
+            0,
+            LedgerOperation.PAA_REFUND,
+            "PAA job creation failed",
+            "paa_harvest"
+          ).catch(() => void 0);
+          throw error;
+        }
+        await dispatchPaaHarvest(jobId2).catch((error) => {
+          console.error("[harvest] durable PAA dispatch pending reconciliation:", error instanceof Error ? error.message : String(error));
+        });
+      }
       if (process.env.CRON_SECRET) {
         const url = new URL(c.req.url);
         void fetch(`${url.origin}/cron/tick`, {
@@ -58905,6 +60175,10 @@ var init_server = __esm({
         }
         return c.json({ job_id: jobId2, status: "done", result: sanitizeHarvestResult(result), attempts: sanitizeAttempts(attempts) });
       } catch (err) {
+        console.error("[harvest/sync] failed", {
+          jobId: jobId2,
+          error: err instanceof Error ? err.message : String(err)
+        });
         const problem = classifyHarvestProblem(err);
         const response = harvestProblemResponse(problem);
         const attempts = await listHarvestAttempts(jobId2, user.id);
@@ -59935,7 +61209,7 @@ var init_server = __esm({
       const { drainQueue: drainQueue2 } = await Promise.resolve().then(() => (init_worker(), worker_exports));
       const budget = { maxJobs: 10, deadlineMs: Date.now() + 28e4 };
       const workflowDispatchResult = await dispatchDueWorkflowSchedules(`${new URL(c.req.url).protocol}//${new URL(c.req.url).host}`);
-      const [results, sweepResult, reapResult, expiredResult, blobCleanup, connectedDataArtifactCleanup, connectedAccountBilling, directoryWorkflowDispatch, directoryWorkflowReconciliation, directoryArtifactCleanup, siteExtractArtifactCleanup, siteExtractRedispatch, siteExtractReconciliation] = await Promise.all([
+      const [results, sweepResult, reapResult, expiredResult, blobCleanup, connectedDataArtifactCleanup, connectedAccountBilling, directoryWorkflowDispatch, directoryWorkflowReconciliation, directoryArtifactCleanup, siteExtractArtifactCleanup, siteExtractRedispatch, siteExtractReconciliation, paaHarvestRedispatch, paaHarvestReconciliation] = await Promise.all([
         drainQueue2(budget),
         runMonthlyRefreshSweep(),
         reapIdleBrowserSessions(120).catch(() => ({ reaped: 0 })),
@@ -59948,7 +61222,9 @@ var init_server = __esm({
         cleanupExpiredDirectoryArtifacts().catch(() => ({ deleted: 0, store: "none" })),
         cleanupExpiredSiteExtractArtifacts().catch(() => ({ deleted: 0, store: "none" })),
         redispatchFundedSiteExtractJobs(25).catch(() => ({ checked: 0, dispatched: 0, failed: 0 })),
-        reconcileSiteExtractSettlements(25).catch(() => ({ checked: 0, settled: 0, failed: 0 }))
+        reconcileSiteExtractSettlements(25).catch(() => ({ checked: 0, settled: 0, failed: 0 })),
+        redispatchPendingPaaHarvests(25).catch(() => ({ checked: 0, dispatched: 0, failed: 0 })),
+        reconcilePaaHarvestSettlements(25).catch(() => ({ checked: 0, staleFailed: 0, settled: 0, failed: 0 }))
       ]);
       return c.json({
         drained: results.length,
@@ -59965,6 +61241,8 @@ var init_server = __esm({
         siteExtractArtifactCleanup,
         siteExtractRedispatch,
         siteExtractReconciliation,
+        paaHarvestRedispatch,
+        paaHarvestReconciliation,
         workflowDispatch: workflowDispatchResult
       });
     });
@@ -60024,7 +61302,10 @@ var init_server = __esm({
       const bundle = stored.find((a) => a.contentType === "application/zip" || a.filename?.endsWith(".zip"));
       return c.json({ ok: true, jobId: jobId2, artifacts: stored.length, settlement, bundleUrl: bundle?.url ?? null, bundleBytes: bundle?.bytes ?? null });
     });
-    app.on(["GET", "POST", "PUT"], "/api/inngest", (0, import_hono31.serve)({ client: inngest, functions: [siteAuditFn, siteExtractFn, directoryWorkflowFn] }));
+    app.on(["GET", "POST", "PUT"], "/api/inngest", (0, import_hono31.serve)({
+      client: inngest,
+      functions: [siteAuditFn, siteExtractFn, directoryWorkflowFn, paaHarvestFn]
+    }));
     app.route("/admin/credits", adminCreditsApp);
     app.route("/api/internal/site-architecture-auditor", siteAuditApp);
     app.route("/api/internal/memory", internalMemoryApp);