mcp-scraper 0.40.2 → 0.40.3

package/dist/{server-KM3CFWCF.js → server-W76RUYD3.js}

@@ -9,27 +9,38 @@ import {
   importHostedCensusPlacesCsv,
   importHostedZipGroupsCsv,
   listActiveHostedLocationDatasets
-} from "./chunk-XORPNO3Z.js";
+} from "./chunk-27DUCRAZ.js";
 import {
   classifyHarvestProblem,
   createHarvestAttemptRecorder,
+  deliverWebhook,
   harvestProblemResponse,
   serializeHarvestProblem
-} from "./chunk-NVXNEOUQ.js";
+} from "./chunk-CS4HE6QY.js";
 import {
+  AIModeSelectors,
+  AIOverviewSelectors,
   BACKUP_LAST_RESORT_ATTEMPTS,
   BrowserDriver,
+  ForumSelectors,
+  LocalPackSelectors,
   MapsSelectors,
+  OrganicSelectors,
+  PAASelectors,
+  VideoSelectors,
+  WhatPeopleSayingSelectors,
   backupProxyAvailable,
   buildYouTubeChannelVideosUrl,
   cleanupBackupProxyId,
   createBackupProxyIdSafe,
   deleteKernelProxyId,
+  encodeUule,
   harvest,
+  normalizeLocation,
   resolveBackupKernelProxyId,
   resolveKernelProxyId,
   serpArrivalUrl
-} from "./chunk-7XBBFBYY.js";
+} from "./chunk-JVIW4GK2.js";
 import {
   CreateEditorialReadingRoomInputSchema,
   HttpMcpToolExecutor,
@@ -55,10 +66,8 @@ import {
   registerSerpIntelligenceCaptureTools,
   renewConnectedDataArtifactDownload,
   renewDirectoryArtifactDownload,
-  sanitizeAttempts,
-  sanitizeHarvestResult,
   transcribeMediaUrl
-} from "./chunk-LP6E462I.js";
+} from "./chunk-6SZ52BQ5.js";
 import {
   auditImageUrls,
   auditImages,
@@ -69,6 +78,11 @@ import {
   renewPrivateArtifactDownload,
   validatePublicHttpUrl
 } from "./chunk-345BQXZH.js";
+import {
+  sanitizeAttempts,
+  sanitizeHarvestResult,
+  sanitizeOutboundDiagnostics
+} from "./chunk-BBI7RGOT.js";
 import {
   browserServiceApiKey,
   browserServiceProfileName,
@@ -78,7 +92,7 @@ import {
   recordKernelSession,
   recordVendorUsage,
   runWithCostContext
-} from "./chunk-3PIWJS6Y.js";
+} from "./chunk-EHES33KB.js";
 import {
   listWorkflowDefinitions,
   runWorkflow,
@@ -105,7 +119,7 @@ import {
   RawMapsOverviewSchema,
   RawMapsReviewStatsSchema
 } from "./chunk-CB5C3BPB.js";
-import "./chunk-ZUJLSICT.js";
+import "./chunk-XU4ZLIB2.js";
 import {
   abandonExtractSettlement,
   countSuccessfulPages,
@@ -128,7 +142,7 @@ import {
   setExtractJobTotal,
   settleExtractJob,
   terminalExtractJobStatus
-} from "./chunk-X2LKCX6H.js";
+} from "./chunk-6J57U6HA.js";
 import {
   BROWSER_OPEN_MIN_BALANCE_MC,
   CONCURRENCY_PRICE_ID,
@@ -181,14 +195,18 @@ import {
   CaptchaError,
   MapsSearchIncompletePageError,
   RECAPTCHA_INSTRUCTIONS,
+  normalizePublicErrorCode,
+  publicErrorMessage,
   sanitizeVendorName
-} from "./chunk-44HZLHDV.js";
+} from "./chunk-5UN33CGU.js";
 import {
   SiteAuditJobRowSchema,
   advanceWorkflowRunStep,
   appendWorkflowArtifacts,
   cancelJob,
   checkRateLimit,
+  checkpointJob,
+  claimInngestPaaJob,
   claimStripeEvent,
   completeJob,
   completeStripeEvent,
@@ -197,6 +215,7 @@ import {
   consumePasswordResetToken,
   countActiveUsers,
   createJob,
+  createJobWithId,
   createPasswordResetToken,
   createRunningJob,
   createUser,
@@ -212,6 +231,7 @@ import {
   failJob,
   failStripeEvent,
   failWorkflowRunRecord,
+  finishHarvestAttempt,
   getBillingLedgerSummary,
   getClient,
   getDb,
@@ -240,7 +260,10 @@ import {
   listHarvestAttempts,
   listInboxMessages,
   listJobs,
+  listPendingInngestPaaJobs,
+  listRecentTerminalInngestPaaJobs,
   listRequestEvents,
+  listStaleRunningInngestPaaJobs,
   listUsers,
   listUsersDueForConnectedAccountBillingReconciliation,
   listWorkflowArtifacts,
@@ -248,6 +271,7 @@ import {
   listWorkflowSchedules,
   logRequestEvent,
   markInboxMessageOpened,
+  markJobBillingSettled,
   markWorkflowRunRunning,
   markWorkflowScheduleRan,
   patchWorkflowSchedule,
@@ -271,9 +295,10 @@ import {
   setUserMemoryCreds,
   settleDebitMcIdempotent,
   softDeleteInboxMessage,
+  startHarvestAttempt,
   upsertPageSnapshot,
   verifyPassword
-} from "./chunk-GUVKHCKE.js";
+} from "./chunk-IQTT7CAB.js";
 
 // src/blog/registry.ts
 var posts = [
@@ -3590,6 +3615,7 @@ async function generateOgImage(post) {
 
 // src/api/server.ts
 import { Resend as Resend3 } from "resend";
+import { randomUUID as randomUUID18 } from "crypto";
 
 // src/api/kpo-extractor.ts
 import TurndownService from "turndown";
@@ -8618,7 +8644,7 @@ var siteExtractFn = inngest.createFunction(
       });
     }) : null;
     const finalized = await step.run("finalize", async () => {
-      const { assembleExtractArtifacts } = await import("./extract-bundle-K4PG3RZJ.js");
+      const { assembleExtractArtifacts } = await import("./extract-bundle-SKXEDG4Z.js");
       const current = await getExtractJob(jobId2);
       if (!current) throw new Error("extract job disappeared before finalization");
       const stored = await assembleExtractArtifacts(current, { branding, imageAudit });
@@ -9560,7 +9586,7 @@ async function resolveUsZipsPath(requestedPath) {
 async function loadZipGroups(stateAbbr, requestedPath, warnings, sourceMode) {
   const mode = resolvedLocationDataMode({ zipSource: sourceMode });
   if (mode === "hosted") {
-    const { getHostedZipGroups } = await import("./location-data-repository-RLQX6SNM.js");
+    const { getHostedZipGroups } = await import("./location-data-repository-NBTCOA7B.js");
     const hosted = await getHostedZipGroups(stateAbbr);
     if (!hosted.dataset) {
       throw new DirectoryLocationError(
@@ -9623,7 +9649,7 @@ async function resolveDirectoryMarkets(options, config = {}) {
   const sourceUrl = censusStateUrl(state.fips);
   const warnings = [];
   if (resolvedLocationDataMode(config) === "hosted") {
-    const { queryHostedLocationMarkets } = await import("./location-data-repository-RLQX6SNM.js");
+    const { queryHostedLocationMarkets } = await import("./location-data-repository-NBTCOA7B.js");
     const hosted = await queryHostedLocationMarkets({
       state: state.abbr,
       minPopulation: options.minPopulation,
@@ -10957,6 +10983,908 @@ var directoryWorkflowFn = inngest.createFunction(
   }
 );
 
+// src/api/paa-capture-artifacts.ts
+var DAY_MS = 24 * 60 * 60 * 1e3;
+var PAA_CAPTURE_ARTIFACT_PREFIX = "paa-captures";
+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" };
+  }
+}
+
+// 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;
+}
+
+// src/paa/durable-capture.ts
+import Kernel4 from "@onkernel/sdk";
+import { createHash as createHash2 } from "crypto";
+var PAA_INVOCATION_BUDGET_MS = 28e4;
+var PAA_BROWSER_WORK_BUDGET_MS = 25e4;
+var PAA_SOLVER_BUDGET_MS = 6e4;
+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;
+  `;
+}
+var 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;
+`;
+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 Kernel4({ 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 = createHash2("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");
+}
+
+// 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 = 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);
@@ -11607,7 +12535,7 @@ import { Hono as Hono3 } from "hono";
 import { z as z12 } from "zod";
 
 // src/api/unified-billing.ts
-import { createHash as createHash2, createHmac, randomUUID as randomUUID3, timingSafeEqual } from "crypto";
+import { createHash as createHash3, createHmac, randomUUID as randomUUID3, timingSafeEqual } from "crypto";
 
 // src/api/scheduling-access.ts
 var PAID_PLAN_REQUIRED_CODE = "paid_plan_required";
@@ -11708,7 +12636,7 @@ function tokenFor(id, idempotencyKey2) {
   return createHmac("sha256", billingSecret()).update(id).update(":").update(idempotencyKey2).digest("base64url");
 }
 function tokenHash(token2) {
-  return createHash2("sha256").update(token2).digest("hex");
+  return createHash3("sha256").update(token2).digest("hex");
 }
 function verifyToken(row, token2) {
   const expected = Buffer.from(row.token_hash, "hex");
@@ -12274,7 +13202,7 @@ async function syncScheduledActionCredentials(user) {
 }
 
 // src/api/connected-usage-billing.ts
-import { createHash as createHash3, randomUUID as randomUUID4 } from "crypto";
+import { createHash as createHash4, randomUUID as randomUUID4 } from "crypto";
 import { z as z11 } from "zod";
 
 // src/api/connected-cost-telemetry.ts
@@ -12349,7 +13277,7 @@ var ConnectedUsageBillingError = class extends Error {
   details;
 };
 function hash(value) {
-  return createHash3("sha256").update(value).digest("hex");
+  return createHash4("sha256").update(value).digest("hex");
 }
 function eventKey(idempotencyKey2) {
   return `connected-usage:${hash(idempotencyKey2)}`;
@@ -18363,12 +19291,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);
 }
@@ -18879,7 +19810,7 @@ g2App.post("/reviews", createApiKeyAuth(), async (c) => {
 });
 
 // src/api/directory-routes.ts
-import { createHash as createHash4, randomUUID as randomUUID7 } from "crypto";
+import { createHash as createHash5, randomUUID as randomUUID7 } from "crypto";
 import { Hono as Hono16 } from "hono";
 
 // src/api/directory-workflow-dispatch.ts
@@ -18919,7 +19850,7 @@ function safeOptions(options) {
   return safe;
 }
 function requestFingerprint(options) {
-  return createHash4("sha256").update(JSON.stringify(safeOptions(options))).digest("hex");
+  return createHash5("sha256").update(JSON.stringify(safeOptions(options))).digest("hex");
 }
 function idempotencyKey(raw) {
   if (raw !== void 0) {
@@ -18931,7 +19862,7 @@ function idempotencyKey(raw) {
   return { ok: true, key: `directory-${randomUUID7()}` };
 }
 function debitKeyFor(userId, responseKey) {
-  const digest = createHash4("sha256").update(String(userId)).update("\0").update(responseKey).digest("hex");
+  const digest = createHash5("sha256").update(String(userId)).update("\0").update(responseKey).digest("hex");
   return `directory-workflow:${userId}:${digest}`;
 }
 function jobId() {
@@ -19044,7 +19975,7 @@ async function runSynchronously(c, user, options, plan, responseKey) {
         const csv = renderDirectoryWorkflowCsv(result);
         const artifact = await createDirectoryCsvArtifact({
           ownerId: String(user.id),
-          jobId: createHash4("sha256").update(debitKey2).digest("hex").slice(0, 32),
+          jobId: createHash5("sha256").update(debitKey2).digest("hex").slice(0, 32),
           createdAt: result.extractedAt,
           filename: `${options.state}-${options.query}-directory.csv`,
           csv,
@@ -19460,6 +20391,53 @@ locationDataApp.post("/admin/sync-census", async (c) => {
   }
 });
 
+// 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 };
+}
+
+// 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 };
+}
+
 // src/api/directory-workflow-reconciliation.ts
 async function reconcileDirectoryWorkflowSettlements(limit = 25) {
   const expiredStarts = await listExpiredDirectoryWorkflowStarts(limit);
@@ -20060,17 +21038,17 @@ workflowApp.post("/cron/dispatch", async (c) => {
 
 // src/api/serp-intelligence-routes.ts
 import { Hono as Hono19 } from "hono";
-import { createHash as createHash6, randomUUID as randomUUID8 } from "crypto";
+import { createHash as createHash7, randomUUID as randomUUID8 } from "crypto";
 
 // src/serp-intelligence/page-snapshot-extractor.ts
-import { createHash as createHash5 } from "crypto";
+import { createHash as createHash6 } from "crypto";
 import pLimit4 from "p-limit";
 var DEFAULT_TIMEOUT_MS = 15e3;
 var DEFAULT_MAX_CONCURRENCY = 2;
 var DEFAULT_MAX_CONTENT_CHARS = 25e4;
 function sha256(value) {
   if (!value) return null;
-  return createHash5("sha256").update(value).digest("hex");
+  return createHash6("sha256").update(value).digest("hex");
 }
 function countWords(markdown) {
   const matches = markdown.trim().match(/\b[\p{L}\p{N}][\p{L}\p{N}'-]*\b/gu);
@@ -20846,8 +21824,8 @@ async function logRequestEventBestEffort(input) {
 }
 function captureBillingKeys(userId, suppliedKey, body) {
   const responseKey = suppliedKey?.trim() || randomUUID8();
-  const requestFingerprint2 = createHash6("sha256").update(JSON.stringify(body)).digest("hex");
-  const keyDigest = createHash6("sha256").update(String(userId)).update("\0").update(responseKey).digest("hex");
+  const requestFingerprint2 = createHash7("sha256").update(JSON.stringify(body)).digest("hex");
+  const keyDigest = createHash7("sha256").update(String(userId)).update("\0").update(responseKey).digest("hex");
   return {
     responseKey,
     debitKey: `serp-capture:${userId}:${keyDigest}`,
@@ -22116,7 +23094,7 @@ async function listReplayRows(sessionId) {
 }
 
 // src/services/browser-agent/browser-agent-service.ts
-import Kernel4 from "@onkernel/sdk";
+import Kernel5 from "@onkernel/sdk";
 import { chromium as playwrightChromium } from "playwright";
 
 // src/services/fanout/cdp-capture.ts
@@ -22819,7 +23797,7 @@ var DEFAULT_TIMEOUT_SECONDS = 600;
 function client() {
   const apiKey = browserServiceApiKey();
   if (!apiKey) throw new Error("Browser backend API key is required");
-  return new Kernel4({ apiKey });
+  return new Kernel5({ apiKey });
 }
 function isProfileConflict(err) {
   const message = err instanceof Error ? err.message : String(err);
@@ -24299,7 +25277,7 @@ async function resolveUser3(customerId, emailFallback) {
 // src/api/oauth-routes.ts
 import { Hono as Hono23 } from "hono";
 import { getCookie, setCookie } from "hono/cookie";
-import { createHash as createHash7, randomBytes as randomBytes2, randomUUID as randomUUID11 } from "crypto";
+import { createHash as createHash8, randomBytes as randomBytes2, randomUUID as randomUUID11 } from "crypto";
 import { importPKCS8, exportJWK, SignJWT } from "jose";
 var ISSUER = "https://mcpscraper.dev";
 var RESOURCE = () => process.env.MCP_MEMORY_RESOURCE_URL ?? "https://memory.mcpscraper.dev/mcp";
@@ -24332,7 +25310,7 @@ async function getKeys() {
   const privateKey = await importPKCS8(pem, "RS256", { extractable: true });
   const full = await exportJWK(privateKey);
   const publicJwk = { kty: full.kty, n: full.n, e: full.e };
-  const kid = createHash7("sha256").update(JSON.stringify({ e: publicJwk.e, kty: publicJwk.kty, n: publicJwk.n })).digest("base64url").slice(0, 16);
+  const kid = createHash8("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";
@@ -24642,7 +25620,7 @@ oauthApp.post("/oauth/authorize", async (c) => {
 });
 function pkceMatches(verifier, challenge) {
   if (!verifier) return false;
-  const computed = createHash7("sha256").update(verifier).digest("base64url");
+  const computed = createHash8("sha256").update(verifier).digest("base64url");
   return computed === challenge;
 }
 async function mintAccessToken(identity, scope, plan, audience) {
@@ -26095,7 +27073,7 @@ import { Hono as Hono27 } from "hono";
 import { Resend } from "resend";
 
 // src/api/resend-support-thread.ts
-import { createHash as createHash8 } from "crypto";
+import { createHash as createHash9 } from "crypto";
 var SUPPORT_TAGS = [
   {
     tag: "support",
@@ -26135,7 +27113,7 @@ function quoteUntrusted(value) {
   return clean2.split("\n").map((line) => `> ${line}`).join("\n");
 }
 function shortHash(value, length = 24) {
-  return createHash8("sha256").update(value).digest("hex").slice(0, length);
+  return createHash9("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";
@@ -27634,7 +28612,7 @@ import { Hono as Hono29 } from "hono";
 import { z as z29 } from "zod";
 
 // src/editorial-reading-room/render.ts
-import { createHash as createHash9 } from "crypto";
+import { createHash as createHash10 } from "crypto";
 import { readFileSync as readFileSync3 } from "fs";
 import { dirname as dirname2, join as join5, resolve } from "path";
 import { Marked, Renderer } from "marked";
@@ -27767,7 +28745,7 @@ function renderEditorialReadingRoom(input, now = /* @__PURE__ */ new Date()) {
     articleCount: articles.length,
     wordCount: totalWordCount,
     bytes,
-    sha256: createHash9("sha256").update(html).digest("hex"),
+    sha256: createHash10("sha256").update(html).digest("hex"),
     warnings
   };
 }
@@ -28000,13 +28978,13 @@ async function reconcileSiteExtractSettlements(limit = 25) {
 }
 
 // src/api/page-diff.ts
-import { createHash as createHash10 } from "crypto";
+import { createHash as createHash11 } from "crypto";
 import { diffLines } from "diff";
 var MAX_SNAPSHOT_CONTENT_CHARS = 25e4;
 var MAX_DIFF_HUNKS = 200;
 var MAX_DIFF_LINES_PER_RESPONSE = 2e3;
 function sha256Hex(value) {
-  return createHash10("sha256").update(value).digest("hex");
+  return createHash11("sha256").update(value).digest("hex");
 }
 function truncateForStorage(value, maxChars = MAX_SNAPSHOT_CONTENT_CHARS) {
   if (value.length <= maxChars) return { value, truncated: false };
@@ -28528,7 +29506,7 @@ function inferredWaybackCapturedAt(content) {
 }
 
 // src/api/connection-memory-import.ts
-import { createHash as createHash11 } from "crypto";
+import { createHash as createHash12 } from "crypto";
 var CONNECTION_MEMORY_IMPORT_MAX_ARGS_BYTES = 64 * 1024;
 var CONNECTION_MEMORY_IMPORT_MAX_RESULT_BYTES = 1e6;
 var CONNECTION_MEMORY_IMPORT_MAX_STRING_CHARS = 256e3;
@@ -28558,7 +29536,7 @@ function canonicalJson(value) {
   return JSON.stringify(value);
 }
 function sha2562(value) {
-  return createHash11("sha256").update(value).digest("hex");
+  return createHash12("sha256").update(value).digest("hex");
 }
 function sensitiveKey(key) {
   const normalized = key.toLowerCase().replace(/[^a-z0-9]/g, "");
@@ -29400,10 +30378,10 @@ async function dbUsage(identity, plan) {
 }
 
 // src/api/nango-control.ts
-import { createHash as createHash13, randomUUID as randomUUID17 } from "crypto";
+import { createHash as createHash14, randomUUID as randomUUID17 } from "crypto";
 
 // src/api/main-nango-transport.ts
-import { createHash as createHash12, randomUUID as randomUUID16 } from "crypto";
+import { createHash as createHash13, randomUUID as randomUUID16 } from "crypto";
 import { Client } from "@modelcontextprotocol/sdk/client/index.js";
 import { StreamableHTTPClientTransport } from "@modelcontextprotocol/sdk/client/streamableHttp.js";
 
@@ -29995,7 +30973,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 = createHash12("sha256").update(JSON.stringify(tools.map((tool) => ({ name: tool.name, inputSchema: tool.inputSchema })))).digest("hex");
+  const revision = createHash13("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 };
@@ -30016,7 +30994,7 @@ async function callNangoToolDirect(args) {
     ratePolicyVersion: CONNECTED_USAGE_RATE_POLICY_VERSION
   });
   const requestId = args.requestId?.trim() || randomUUID16();
-  const idempotencyKey2 = `main-nango:${createHash12("sha256").update(args.identity.toLowerCase()).update("\0").update(connection.id).update("\0").update(args.tool).update("\0").update(requestId).digest("hex")}`;
+  const idempotencyKey2 = `main-nango:${createHash13("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;
@@ -30041,7 +31019,7 @@ async function callNangoToolDirect(args) {
       toolName: args.tool,
       operationKind: args.operationKind ?? args.classification,
       outcome: providerError ? "error" : "partial",
-      requestId: requestId.length <= 200 ? requestId : createHash12("sha256").update(requestId).digest("hex"),
+      requestId: requestId.length <= 200 ? requestId : createHash13("sha256").update(requestId).digest("hex"),
       startedAt: startedAt.toISOString(),
       completedAt: completedAt.toISOString()
     }
@@ -30078,7 +31056,7 @@ async function describeNangoToolDirect(identity, connectionId, toolName) {
     providerContractHash: MAIN_INTEGRATION_CONTRACT_HASH,
     protocolVersion: null,
     schemaSource: "live_tools_list",
-    schemaHash: createHash12("sha256").update(JSON.stringify(projected)).digest("hex"),
+    schemaHash: createHash13("sha256").update(JSON.stringify(projected)).digest("hex"),
     fetchedAt: (/* @__PURE__ */ new Date()).toISOString()
   };
 }
@@ -30802,7 +31780,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:${createHash13("sha256").update(identity).update("\0").update(idempotencyKey2?.trim() || randomUUID17()).digest("hex")}`;
+  const requestId = `main-connected-action:${createHash14("sha256").update(identity).update("\0").update(idempotencyKey2?.trim() || randomUUID17()).digest("hex")}`;
   if (mainOwnsIntegrations()) {
     const selectedTool = tool?.trim();
     if (!selectedTool) throw new NangoControlError("An action tool is required.", 400, "invalid_request", false);
@@ -30944,7 +31922,7 @@ function canonicalJson2(value) {
   return JSON.stringify(value);
 }
 function projectedToolSchemaHash(tool) {
-  return createHash13("sha256").update(canonicalJson2(tool)).digest("hex");
+  return createHash14("sha256").update(canonicalJson2(tool)).digest("hex");
 }
 async function describeNangoTool(identity, connectionId, tool, fresh) {
   if (mainOwnsIntegrations()) {
@@ -31530,7 +32508,7 @@ async function callResendExportPage(identity, input) {
 }
 
 // src/api/scheduler-integration-auth.ts
-import { createHash as createHash14, createHmac as createHmac4, timingSafeEqual as timingSafeEqual3 } from "crypto";
+import { createHash as createHash15, createHmac as createHmac4, timingSafeEqual as timingSafeEqual3 } from "crypto";
 var MAX_CLOCK_SKEW_MS = 5 * 60 * 1e3;
 var SchedulerIntegrationAuthError = class extends Error {
   code;
@@ -31546,7 +32524,7 @@ function signingSecret() {
   return secret2;
 }
 function schedulerIntegrationSignature(args) {
-  const bodyHash = createHash14("sha256").update(args.body).digest("hex");
+  const bodyHash = createHash15("sha256").update(args.body).digest("hex");
   return createHmac4("sha256", args.secret).update(`${args.method.toUpperCase()}
 ${args.path}
 ${args.timestamp}
@@ -31713,6 +32691,18 @@ async function createSignupStripeCustomer(email) {
 }
 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");
@@ -33253,8 +34243,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 checkHarvestLimits(user, reuseLockId) {
   if (reuseLockId && await reuseExistingConcurrencyGate(user.id, reuseLockId, 30 * 60)) return null;
@@ -33301,9 +34291,50 @@ app.post("/harvest", auth2, async (c) => {
     pages: Math.min(2, Math.max(1, body.pages ?? 1))
   };
   const harvestCost = options.serpOnly ? MC_COSTS.serp_headful : paaCostForQuestionCount(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 = randomUUID18();
+    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`, {
@@ -33378,6 +34409,10 @@ app.post("/harvest/sync", auth2, async (c) => {
     }
     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);
@@ -34421,10 +35456,10 @@ app.get("/cron/tick", async (c) => {
   if (!process.env.CRON_SECRET || secret2 !== `Bearer ${process.env.CRON_SECRET}`) {
     return c.json({ error: "Unauthorized" }, 401);
   }
-  const { drainQueue } = await import("./worker-FXAGFYOE.js");
+  const { drainQueue } = await import("./worker-5RWLFSAJ.js");
   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([
     drainQueue(budget),
     runMonthlyRefreshSweep(),
     reapIdleBrowserSessions(120).catch(() => ({ reaped: 0 })),
@@ -34437,7 +35472,9 @@ app.get("/cron/tick", async (c) => {
     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,
@@ -34454,6 +35491,8 @@ app.get("/cron/tick", async (c) => {
     siteExtractArtifactCleanup,
     siteExtractRedispatch,
     siteExtractReconciliation,
+    paaHarvestRedispatch,
+    paaHarvestReconciliation,
     workflowDispatch: workflowDispatchResult
   });
 });
@@ -34470,8 +35509,8 @@ app.post("/api/internal/extract-refinalize/:id", async (c) => {
     finishExtractJob: finishExtractJob2,
     terminalExtractJobStatus: terminalExtractJobStatus2,
     extractJobLimitInfo: extractJobLimitInfo2
-  } = await import("./site-extract-repository-2SMMFKKL.js");
-  const { assembleExtractArtifacts } = await import("./extract-bundle-K4PG3RZJ.js");
+  } = await import("./site-extract-repository-6GX72U4N.js");
+  const { assembleExtractArtifacts } = await import("./extract-bundle-SKXEDG4Z.js");
   const existing = await getExtractJob2(jobId2);
   if (!existing) return c.json({ error: "job not found" }, 404);
   if (existing.status !== "failed") {
@@ -34498,7 +35537,7 @@ app.post("/api/internal/extract-refinalize/:id", async (c) => {
   if (!updated) return c.json({ error: "job state changed during re-finalization" }, 409);
   let settlement = "already_settled_or_refunded";
   if (job.billedMc == null && job.userId != null) {
-    const { settleExtractJob: settleExtractJob3, countSuccessfulPages: countSuccessfulPages2 } = await import("./site-extract-repository-2SMMFKKL.js");
+    const { settleExtractJob: settleExtractJob3, countSuccessfulPages: countSuccessfulPages2 } = await import("./site-extract-repository-6GX72U4N.js");
     const heldMc = Number(job.options.heldMc ?? 0);
     const successful = await countSuccessfulPages2(jobId2);
     const usedMc = Math.min(successful * MC_COSTS.page_scrape, heldMc);
@@ -34513,7 +35552,10 @@ app.post("/api/internal/extract-refinalize/:id", async (c) => {
   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", serveInngest({ client: inngest, functions: [siteAuditFn, siteExtractFn, directoryWorkflowFn] }));
+app.on(["GET", "POST", "PUT"], "/api/inngest", serveInngest({
+  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);
@@ -34671,4 +35713,4 @@ app.get("/blog/:slug/", (c) => {
 export {
   app
 };
-//# sourceMappingURL=server-KM3CFWCF.js.map
+//# sourceMappingURL=server-W76RUYD3.js.map