mcp-scraper 0.40.2 → 0.41.0

package/dist/{server-KM3CFWCF.js → server-2JJPCZH4.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-SIE5LZ2V.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-OOB35KFT.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, "");
@@ -28846,6 +29824,7 @@ var CONNECTED_DATA_DATASETS = [
   "calendar_events",
   "zoom_recordings",
   "zoom_transcripts",
+  "slack_channel_messages",
   "meta_ads_insights",
   "search_console_performance",
   "resend_data",
@@ -28872,8 +29851,9 @@ function resolveConnectedDataRange(args) {
   const from = args.from ? new Date(args.from) : new Date(to.getTime() - (args.lastDays ?? 7) * 864e5);
   if (!Number.isFinite(from.getTime())) throw new ConnectedDataExportValidationError("from must be an RFC3339 timestamp.");
   if (from.getTime() >= to.getTime()) throw new ConnectedDataExportValidationError("from must be earlier than to.");
-  if (to.getTime() - from.getTime() > 90 * 864e5) {
-    throw new ConnectedDataExportValidationError("A connected-data export can cover at most 90 days per request.");
+  const maxRangeDays = args.maxRangeDays === void 0 ? 90 : args.maxRangeDays;
+  if (maxRangeDays !== null && to.getTime() - from.getTime() > maxRangeDays * 864e5) {
+    throw new ConnectedDataExportValidationError(`A connected-data export can cover at most ${maxRangeDays} days per request.`);
   }
   if (to.getTime() > now.getTime() + 5 * 6e4) {
     throw new ConnectedDataExportValidationError("to cannot be in the future.");
@@ -28883,10 +29863,18 @@ function resolveConnectedDataRange(args) {
 function resolveConnectedDataExportRequest(args) {
   const continuation = args.continuation;
   if (!continuation) {
+    const scope2 = resolveConnectedDataExportScope(args.requestedDataset, args.scope);
     return {
       dataset: args.requestedDataset,
-      range: resolveConnectedDataRange({ from: args.from, to: args.to, lastDays: args.lastDays, now: args.now }),
-      ...args.cursor ? { cursor: args.cursor } : {}
+      range: resolveConnectedDataRange({
+        from: args.from,
+        to: args.to,
+        lastDays: args.lastDays,
+        now: args.now,
+        maxRangeDays: args.requestedDataset === "slack_channel_messages" ? null : 90
+      }),
+      ...args.cursor ? { cursor: args.cursor } : {},
+      ...scope2 ? { scope: scope2 } : {}
     };
   }
   const supported = CONNECTED_DATA_DATASETS.filter((dataset2) => dataset2 !== "auto");
@@ -28909,10 +29897,38 @@ function resolveConnectedDataExportRequest(args) {
     throw new ConnectedDataExportValidationError("dataset conflicts with continuation.");
   }
   const dataset = continuation.dataset;
+  const scope = resolveConnectedDataExportScope(dataset, continuation.scope);
+  if (args.scope && JSON.stringify(resolveConnectedDataExportScope(dataset, args.scope)) !== JSON.stringify(scope)) {
+    throw new ConnectedDataExportValidationError("scope conflicts with continuation.");
+  }
   return {
     dataset,
-    range: resolveConnectedDataRange({ from: continuation.from, to: continuation.to, now: args.now }),
-    cursor: continuation.cursor
+    range: resolveConnectedDataRange({
+      from: continuation.from,
+      to: continuation.to,
+      now: args.now,
+      maxRangeDays: dataset === "slack_channel_messages" ? null : 90
+    }),
+    cursor: continuation.cursor,
+    ...scope ? { scope } : {}
+  };
+}
+function resolveConnectedDataExportScope(dataset, scope) {
+  if (dataset !== "slack_channel_messages") {
+    if (scope?.slack) {
+      throw new ConnectedDataExportValidationError("Slack export scope requires dataset slack_channel_messages.");
+    }
+    return void 0;
+  }
+  const channelId = scope?.slack?.channelId?.trim();
+  if (!channelId || !/^[A-Za-z0-9_-]{2,100}$/.test(channelId)) {
+    throw new ConnectedDataExportValidationError("Slack channel export requires a valid channelId.");
+  }
+  return {
+    slack: {
+      channelId,
+      includeThreads: scope?.slack?.includeThreads !== false
+    }
   };
 }
 function previewRecord(value) {
@@ -28941,7 +29957,14 @@ function previewRecord(value) {
     "createdAt",
     "updatedAt",
     "hasTranscript",
-    "contentTruncated"
+    "contentTruncated",
+    "channelId",
+    "threadTs",
+    "parentMessageTs",
+    "occurredAt",
+    "userId",
+    "text",
+    "replyCount"
   ]) {
     if (record[key] === void 0) continue;
     const item = record[key];
@@ -28984,7 +30007,8 @@ async function collectConnectedDataExport(args) {
       dataset: args.dataset,
       from: args.range.from,
       to: args.range.to,
-      pageSize: Math.min(25, maxItems - records.length),
+      pageSize: Math.min(args.dataset === "slack_channel_messages" ? 200 : 25, maxItems - records.length),
+      ...args.scope ? { scope: args.scope } : {},
       ...cursor !== void 0 && cursor !== null ? { cursor } : {}
     });
     pages++;
@@ -29029,6 +30053,7 @@ async function collectConnectedDataExport(args) {
     providerConfigKey,
     dataset,
     range: args.range,
+    ...args.scope ? { scope: args.scope } : {},
     complete,
     counts: { pages, listed, exported: records.length, failed },
     untrustedContent: true,
@@ -29048,6 +30073,7 @@ ${lines.length ? `${lines.join("\n")}
     providerConfigKey,
     dataset,
     range: args.range,
+    ...args.scope ? { scope: args.scope } : {},
     counts: { pages, listed, exported: records.length, failed, bytes },
     complete,
     ...!artifact ? { records } : {},
@@ -29057,7 +30083,8 @@ ${lines.length ? `${lines.join("\n")}
       cursor: continuationCursor,
       from: args.range.from,
       to: args.range.to,
-      dataset
+      dataset,
+      ...args.scope ? { scope: args.scope } : {}
     } : null,
     warnings: [...warnings],
     untrustedContent: true
@@ -29227,6 +30254,97 @@ async function getFreeCreditBreakdown(userId) {
 
 // src/api/memory-db.ts
 import { neon } from "@neondatabase/serverless";
+
+// src/api/memory-universe.ts
+var SEP = "\n";
+var WIKILINK = /\[\[([^\][]+)\]\]/g;
+var HASH = /#[^]*$/;
+var CONNECTION_RE = /^Connection - (.+) - ([A-Za-z0-9_-]+)$/;
+function stripExt(value) {
+  return value.replace(/\.(md|markdown|txt)$/i, "");
+}
+function vaultLabel(vault) {
+  const provider = vault.match(CONNECTION_RE)?.[1];
+  if (!provider) return vault;
+  return provider.split(/[\s_-]+/).filter(Boolean).map((word) => word.charAt(0).toUpperCase() + word.slice(1)).join(" ");
+}
+function noteTags(props) {
+  const tags = props.tags;
+  return Array.isArray(tags) ? tags.filter((tag) => typeof tag === "string") : [];
+}
+function wikiTargets(content) {
+  const targets = [];
+  for (const match of content.matchAll(WIKILINK)) {
+    const target = match[1].split("|", 1)[0].replace(HASH, "").trim();
+    if (target) targets.push(target);
+  }
+  return targets;
+}
+function buildResolver(notes) {
+  const index = /* @__PURE__ */ new Map();
+  const add = (key, note) => {
+    const normalized = key.trim().toLowerCase();
+    if (normalized && !index.has(normalized)) index.set(normalized, note);
+  };
+  for (const note of notes) add(`${note.vault}/${note.path}`, note);
+  for (const note of notes) add(note.path, note);
+  for (const note of notes) add(stripExt(note.path), note);
+  for (const note of notes) if (note.title) add(note.title, note);
+  for (const note of notes) {
+    const base = note.path.split("/").pop() ?? note.path;
+    add(base, note);
+    add(stripExt(base), note);
+  }
+  return (target) => {
+    const normalized = target.trim().toLowerCase();
+    return index.get(normalized) ?? index.get(stripExt(normalized)) ?? null;
+  };
+}
+function buildUniverseData(notes) {
+  const resolver = buildResolver(notes);
+  const nodes = [];
+  const indexById = /* @__PURE__ */ new Map();
+  const nodeFor = (id, label, group, ghost, extra) => {
+    const existing = indexById.get(id);
+    if (existing !== void 0) return existing;
+    const index = nodes.length;
+    indexById.set(id, index);
+    nodes.push({ id, label, group, ghost, ...extra });
+    return index;
+  };
+  for (const note of notes) {
+    nodeFor(
+      `${note.vault}${SEP}${note.path}`,
+      note.title.trim() || note.path.split("/").pop() || note.path,
+      vaultLabel(note.vault),
+      false,
+      { sub: note.path, tags: noteTags(note.props), updatedAt: note.updatedAt }
+    );
+  }
+  const links = [];
+  const seenEdges = /* @__PURE__ */ new Set();
+  for (const note of notes) {
+    const from = indexById.get(`${note.vault}${SEP}${note.path}`);
+    if (from === void 0) continue;
+    for (const target of wikiTargets(note.content)) {
+      const resolved = resolver(target);
+      const to = resolved ? nodeFor(
+        `${resolved.vault}${SEP}${resolved.path}`,
+        resolved.title.trim() || resolved.path.split("/").pop() || resolved.path,
+        vaultLabel(resolved.vault),
+        false
+      ) : nodeFor(`ghost:${target.toLowerCase()}`, target, "", true);
+      if (to === from) continue;
+      const edgeKey = from < to ? `${from}:${to}` : `${to}:${from}`;
+      if (seenEdges.has(edgeKey)) continue;
+      seenEdges.add(edgeKey);
+      links.push({ s: from, t: to });
+    }
+  }
+  return { nodes, links, total: notes.length, built: notes.length, failed: 0 };
+}
+
+// src/api/memory-db.ts
 var _sql = null;
 function sql() {
   if (_sql) return _sql;
@@ -29371,6 +30489,35 @@ async function dbNote(identity, vault, path5) {
     capturedAt: r.captured_at
   };
 }
+async function dbUniverse(identity, includeConnections = false) {
+  const entitled = await entitledVaultRows(identity);
+  const selected = entitled.filter(
+    (entry) => includeConnections || !/^Connection - (.+) - ([A-Za-z0-9_-]+)$/.test(entry.vault)
+  );
+  if (selected.length === 0) return buildUniverseData([]);
+  const logicalByPhysical = new Map(selected.map((entry) => [entry.physical, entry.vault]));
+  const physicals = [...logicalByPhysical.keys()];
+  const rows = await sql().query(
+    `SELECT vault, path, title, content, updated_at, props
+     FROM mem_notes
+     WHERE vault = ANY($1)
+     ORDER BY updated_at DESC`,
+    [physicals]
+  );
+  const notes = rows.flatMap((row) => {
+    const vault = logicalByPhysical.get(row.vault);
+    if (!vault) return [];
+    return [{
+      vault,
+      path: row.path,
+      title: row.title,
+      content: row.content,
+      updatedAt: row.updated_at,
+      props: row.props && typeof row.props === "object" ? row.props : {}
+    }];
+  });
+  return buildUniverseData(notes);
+}
 var FREE_COST_CAP_USD = 1;
 async function dbUsage(identity, plan) {
   const now = /* @__PURE__ */ new Date();
@@ -29400,10 +30547,379 @@ 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/slack-archive-analysis.ts
+function isRecord2(value) {
+  return !!value && typeof value === "object" && !Array.isArray(value);
+}
+function cleanString(value) {
+  return typeof value === "string" && value.trim() ? value.trim() : null;
+}
+function slackWeekStart(value) {
+  if (!value) return null;
+  const date = new Date(value);
+  if (!Number.isFinite(date.getTime())) return null;
+  const daysSinceMonday = (date.getUTCDay() + 6) % 7;
+  date.setUTCDate(date.getUTCDate() - daysSinceMonday);
+  return date.toISOString().slice(0, 10);
+}
+function normalizedUrl(value) {
+  const candidate = cleanString(value)?.split("|", 1)[0]?.replace(/[),.;!?]+$/, "");
+  if (!candidate || !/^https?:\/\//i.test(candidate)) return null;
+  try {
+    return new URL(candidate).toString();
+  } catch {
+    return null;
+  }
+}
+function deriveSlackMessageIndexFields(args) {
+  const fileNames = args.files.flatMap((file) => {
+    if (!isRecord2(file)) return [];
+    const name = cleanString(file.name) ?? cleanString(file.title) ?? cleanString(file.id);
+    return name ? [name] : [];
+  });
+  const urls = /* @__PURE__ */ new Set();
+  const text2 = args.text ?? "";
+  for (const match of text2.matchAll(/<(https?:\/\/[^>|]+)(?:\|[^>]*)?>/gi)) {
+    const url = normalizedUrl(match[1]);
+    if (url) urls.add(url);
+  }
+  for (const match of text2.matchAll(/https?:\/\/[^\s<>()]+/gi)) {
+    const url = normalizedUrl(match[0]);
+    if (url) urls.add(url);
+  }
+  const attachments = Array.isArray(args.providerData.attachments) ? args.providerData.attachments : [];
+  for (const attachment of attachments) {
+    if (!isRecord2(attachment)) continue;
+    for (const key of ["url", "title_link", "from_url", "service_url"]) {
+      const url = normalizedUrl(attachment[key]);
+      if (url) urls.add(url);
+    }
+  }
+  const profile = isRecord2(args.providerData.user_profile) ? args.providerData.user_profile : isRecord2(args.providerData.profile) ? args.providerData.profile : null;
+  const authorName = cleanString(profile?.display_name) ?? cleanString(profile?.real_name) ?? cleanString(args.providerData.username) ?? cleanString(args.providerData.user_name);
+  return {
+    weekStart: slackWeekStart(args.occurredAt),
+    authorName,
+    fileCount: args.files.length,
+    hasFiles: args.files.length > 0,
+    fileNames,
+    linkCount: urls.size,
+    links: [...urls]
+  };
+}
+
+// src/api/slack-connected-data-export.ts
+var CURSOR_PREFIX = "slack1.";
+var MAX_CURSOR_BYTES = 64 * 1024;
+var MAX_PENDING_THREADS = 200;
+var THREAD_CONCURRENCY = 3;
+var MAX_SLACK_RETRIES = 3;
+function isRecord3(value) {
+  return !!value && typeof value === "object" && !Array.isArray(value);
+}
+function cleanString2(value, maxLength = 1e4) {
+  return typeof value === "string" && value.trim() ? value.trim().slice(0, maxLength) : null;
+}
+function unwrapToolResult(value) {
+  if (!isRecord3(value)) return value;
+  if (isRecord3(value.structuredContent)) return value.structuredContent;
+  if (Array.isArray(value.content)) {
+    const textPart = value.content.find((part) => isRecord3(part) && part.type === "text" && typeof part.text === "string");
+    if (isRecord3(textPart) && typeof textPart.text === "string") {
+      try {
+        return unwrapToolResult(JSON.parse(textPart.text));
+      } catch {
+        return textPart.text;
+      }
+    }
+  }
+  if (isRecord3(value.result)) return unwrapToolResult(value.result);
+  if (isRecord3(value.data)) return unwrapToolResult(value.data);
+  return value;
+}
+function messagesFromToolResult(value) {
+  const root = unwrapToolResult(value);
+  if (Array.isArray(root)) return root.filter(isRecord3);
+  if (!isRecord3(root)) return [];
+  for (const key of ["messages", "replies", "items", "data"]) {
+    if (Array.isArray(root[key])) return root[key].filter(isRecord3);
+  }
+  return [];
+}
+function nextCursorFromToolResult(value) {
+  const root = unwrapToolResult(value);
+  if (!isRecord3(root)) return null;
+  const metadata = isRecord3(root.response_metadata) ? root.response_metadata : isRecord3(root.responseMetadata) ? root.responseMetadata : isRecord3(root.metadata) ? root.metadata : null;
+  return cleanString2(
+    root.next_cursor ?? root.nextCursor ?? metadata?.next_cursor ?? metadata?.nextCursor,
+    1e4
+  );
+}
+function slackTimestampToIso(value) {
+  const timestamp = cleanString2(value, 64);
+  if (!timestamp || !/^\d{1,20}(?:\.\d{1,9})?$/.test(timestamp)) return null;
+  const milliseconds = Number(timestamp) * 1e3;
+  if (!Number.isFinite(milliseconds)) return null;
+  try {
+    return new Date(milliseconds).toISOString();
+  } catch {
+    return null;
+  }
+}
+function normalizeSlackMessage(row, channelId, parentMessageTs) {
+  const timestamp = cleanString2(row.ts, 64);
+  const replyCount = typeof row.reply_count === "number" && Number.isFinite(row.reply_count) ? Math.max(0, Math.floor(row.reply_count)) : 0;
+  const rowThreadTs = cleanString2(row.thread_ts, 64);
+  const inferredParentMessageTs = parentMessageTs ?? (rowThreadTs && rowThreadTs !== timestamp ? rowThreadTs : null);
+  const threadTs = inferredParentMessageTs ?? rowThreadTs ?? (replyCount > 0 ? timestamp : null);
+  const occurredAt = slackTimestampToIso(timestamp);
+  const files = Array.isArray(row.files) ? row.files : [];
+  const text2 = typeof row.text === "string" ? row.text : null;
+  return {
+    recordType: inferredParentMessageTs ? "slack_thread_reply" : "slack_message",
+    dataset: "slack_channel_messages",
+    id: timestamp ? `${channelId}:${timestamp}` : `${channelId}:unknown`,
+    providerRecordId: timestamp,
+    channelId,
+    threadTs,
+    parentMessageTs: inferredParentMessageTs,
+    isThreadReply: inferredParentMessageTs !== null,
+    occurredAt,
+    userId: cleanString2(row.user, 100) ?? cleanString2(row.bot_id, 100),
+    text: text2,
+    subtype: cleanString2(row.subtype, 100),
+    replyCount,
+    files,
+    reactions: Array.isArray(row.reactions) ? row.reactions : [],
+    providerData: row,
+    ...deriveSlackMessageIndexFields({
+      occurredAt,
+      text: text2,
+      files,
+      providerData: row
+    })
+  };
+}
+function encodeCursor(state) {
+  const encoded = `${CURSOR_PREFIX}${Buffer.from(JSON.stringify(state)).toString("base64url")}`;
+  if (Buffer.byteLength(encoded, "utf8") > MAX_CURSOR_BYTES) {
+    throw new Error("slack_export_cursor_too_large");
+  }
+  return encoded;
+}
+function validProviderCursor(value) {
+  return value === null || typeof value === "string" && value.length > 0 && value.length <= 1e4;
+}
+function decodeCursor(cursor, channelId, includeThreads) {
+  if (!cursor) {
+    return { version: 1, phase: "history", channelId, includeThreads, historyCursor: null };
+  }
+  if (!cursor.startsWith(CURSOR_PREFIX) || Buffer.byteLength(cursor, "utf8") > MAX_CURSOR_BYTES) {
+    throw new Error("slack_export_cursor_invalid");
+  }
+  let parsed;
+  try {
+    parsed = JSON.parse(Buffer.from(cursor.slice(CURSOR_PREFIX.length), "base64url").toString("utf8"));
+  } catch {
+    throw new Error("slack_export_cursor_invalid");
+  }
+  if (!isRecord3(parsed) || parsed.version !== 1 || parsed.channelId !== channelId || parsed.includeThreads !== includeThreads || !validProviderCursor(parsed.historyCursor)) {
+    throw new Error("slack_export_cursor_invalid");
+  }
+  if (parsed.phase === "history") {
+    return {
+      version: 1,
+      phase: "history",
+      channelId,
+      includeThreads,
+      historyCursor: parsed.historyCursor
+    };
+  }
+  if (parsed.phase !== "threads" || includeThreads !== true || !Array.isArray(parsed.historyMessageTs) || !Array.isArray(parsed.threads) || parsed.threads.length < 1 || parsed.threads.length > MAX_PENDING_THREADS) {
+    throw new Error("slack_export_cursor_invalid");
+  }
+  const historyMessageTs = parsed.historyMessageTs.flatMap((value) => {
+    const timestamp = cleanString2(value, 64);
+    return timestamp && /^\d{1,20}(?:\.\d{1,9})?$/.test(timestamp) ? [timestamp] : [];
+  });
+  if (historyMessageTs.length !== parsed.historyMessageTs.length || historyMessageTs.length > MAX_PENDING_THREADS) {
+    throw new Error("slack_export_cursor_invalid");
+  }
+  const threads = parsed.threads.flatMap((value) => {
+    if (!isRecord3(value)) return [];
+    const threadTs = cleanString2(value.threadTs, 64);
+    if (!threadTs || !/^\d{1,20}(?:\.\d{1,9})?$/.test(threadTs) || !validProviderCursor(value.cursor)) return [];
+    return [{ threadTs, cursor: value.cursor }];
+  });
+  if (threads.length !== parsed.threads.length) throw new Error("slack_export_cursor_invalid");
+  return {
+    version: 1,
+    phase: "threads",
+    channelId,
+    includeThreads: true,
+    historyCursor: parsed.historyCursor,
+    historyMessageTs,
+    threads
+  };
+}
+function slackBoundaryTimestamp(iso, offsetMicroseconds) {
+  const milliseconds = new Date(iso).getTime();
+  if (!Number.isFinite(milliseconds)) throw new Error("slack_export_range_invalid");
+  return Math.max(0, milliseconds / 1e3 + offsetMicroseconds / 1e6).toFixed(6);
+}
+function errorText(error) {
+  if (error instanceof Error) return `${error.name} ${error.message}`;
+  if (typeof error === "string") return error;
+  try {
+    return JSON.stringify(error);
+  } catch {
+    return "";
+  }
+}
+function retryAfterMilliseconds(error, attempt) {
+  const text2 = errorText(error);
+  if (!/429|rate.?limit|resource_exhausted/i.test(text2)) return null;
+  if (isRecord3(error) && typeof error.retryAfterMs === "number" && Number.isFinite(error.retryAfterMs)) {
+    return Math.min(Math.max(error.retryAfterMs, 1e3), 6e4);
+  }
+  const explicit = text2.match(/retry[_ -]?after[^0-9]{0,20}(\d{1,4})/i);
+  const seconds = explicit ? Number(explicit[1]) : attempt;
+  return Math.min(Math.max(seconds, 1) * 1e3, 6e4);
+}
+async function callSlackToolWithRetry(dependencies, args) {
+  for (let attempt = 1; attempt <= MAX_SLACK_RETRIES; attempt += 1) {
+    try {
+      return await dependencies.callTool(args);
+    } catch (error) {
+      const delay = retryAfterMilliseconds(error, attempt);
+      if (delay === null || attempt === MAX_SLACK_RETRIES) throw error;
+      await (dependencies.sleep ?? ((milliseconds) => new Promise((resolve2) => setTimeout(resolve2, milliseconds))))(delay);
+    }
+  }
+  throw new Error("slack_export_retry_exhausted");
+}
+function nextAfterThreads(state) {
+  if (state.threads.length > 0) return { nextCursor: encodeCursor(state), complete: false };
+  if (state.historyCursor) {
+    return {
+      nextCursor: encodeCursor({
+        version: 1,
+        phase: "history",
+        channelId: state.channelId,
+        includeThreads: true,
+        historyCursor: state.historyCursor
+      }),
+      complete: false
+    };
+  }
+  return { nextCursor: null, complete: true };
+}
+async function exportSlackChannelPage(input, dependencies) {
+  const channelId = input.scope?.slack?.channelId?.trim();
+  if (!channelId) throw new Error("slack_export_channel_required");
+  const includeThreads = input.scope?.slack?.includeThreads !== false;
+  const state = decodeCursor(input.cursor, channelId, includeThreads);
+  const pageSize = Math.max(1, Math.min(200, Math.floor(input.pageSize)));
+  if (state.phase === "history") {
+    const result = await callSlackToolWithRetry(dependencies, {
+      tool: "get-conversation-history",
+      input: {
+        channel_id: channelId,
+        limit: pageSize,
+        oldest: slackBoundaryTimestamp(input.from, -1),
+        latest: slackBoundaryTimestamp(input.to, 0),
+        inclusive: false,
+        ...state.historyCursor ? { cursor: state.historyCursor } : {}
+      },
+      requestId: `slack-export:${input.connectionId}:${channelId}:history:${state.historyCursor ?? "start"}`
+    });
+    const messages = messagesFromToolResult(result).slice(0, pageSize);
+    const historyCursor = nextCursorFromToolResult(result);
+    const records2 = messages.map((message) => normalizeSlackMessage(message, channelId, null));
+    const threadIds = includeThreads ? [...new Set(messages.flatMap((message) => {
+      const replyCount = typeof message.reply_count === "number" ? message.reply_count : 0;
+      const timestamp = cleanString2(message.ts, 64);
+      return replyCount > 0 && timestamp ? [timestamp] : [];
+    }))].slice(0, MAX_PENDING_THREADS) : [];
+    if (threadIds.length > 0) {
+      return {
+        providerConfigKey: "slack",
+        dataset: "slack_channel_messages",
+        records: records2,
+        nextCursor: encodeCursor({
+          version: 1,
+          phase: "threads",
+          channelId,
+          includeThreads: true,
+          historyCursor,
+          historyMessageTs: messages.flatMap((message) => cleanString2(message.ts, 64) ?? []),
+          threads: threadIds.map((threadTs) => ({ threadTs, cursor: null }))
+        }),
+        complete: false,
+        counts: { listed: messages.length, exported: records2.length, failed: 0 },
+        warnings: threadIds.length === MAX_PENDING_THREADS ? ["A history page reached the per-page threaded-parent safety limit; narrow the export range if threads are missing."] : [],
+        untrustedContent: true
+      };
+    }
+    return {
+      providerConfigKey: "slack",
+      dataset: "slack_channel_messages",
+      records: records2,
+      nextCursor: historyCursor ? encodeCursor({ ...state, historyCursor }) : null,
+      complete: historyCursor === null,
+      counts: { listed: messages.length, exported: records2.length, failed: 0 },
+      warnings: [],
+      untrustedContent: true
+    };
+  }
+  const batchSize = Math.min(THREAD_CONCURRENCY, state.threads.length, pageSize);
+  const batch = state.threads.slice(0, batchSize);
+  const perThreadLimit = Math.max(1, Math.min(100, Math.floor(pageSize / batchSize)));
+  const results = await Promise.all(batch.map((thread) => callSlackToolWithRetry(dependencies, {
+    tool: "get-thread-replies",
+    input: {
+      channel_id: channelId,
+      thread_ts: thread.threadTs,
+      limit: perThreadLimit,
+      ...thread.cursor ? { cursor: thread.cursor } : {}
+    },
+    requestId: `slack-export:${input.connectionId}:${channelId}:thread:${thread.threadTs}:${thread.cursor ?? "start"}`
+  })));
+  const records = [];
+  const stillPending = [];
+  let listed = 0;
+  for (let index = 0; index < results.length; index += 1) {
+    const thread = batch[index];
+    const messages = messagesFromToolResult(results[index]);
+    listed += messages.length;
+    records.push(...messages.filter((message) => {
+      const timestamp = cleanString2(message.ts, 64);
+      return timestamp !== thread.threadTs && !state.historyMessageTs.includes(timestamp ?? "");
+    }).map((message) => normalizeSlackMessage(message, channelId, thread.threadTs)));
+    const cursor = nextCursorFromToolResult(results[index]);
+    if (cursor) stillPending.push({ threadTs: thread.threadTs, cursor });
+  }
+  const nextState = {
+    ...state,
+    threads: [...stillPending, ...state.threads.slice(batchSize)]
+  };
+  const next = nextAfterThreads(nextState);
+  return {
+    providerConfigKey: "slack",
+    dataset: "slack_channel_messages",
+    records,
+    nextCursor: next.nextCursor,
+    complete: next.complete,
+    counts: { listed, exported: records.length, failed: 0 },
+    warnings: [],
+    untrustedContent: true
+  };
+}
 
 // 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";
 
@@ -29678,12 +31194,14 @@ var MainNangoTransportError = class extends Error {
   status;
   code;
   retryable;
-  constructor(message, status, code, retryable = status === 429 || status >= 500) {
+  retryAfterMs;
+  constructor(message, status, code, retryable = status === 429 || status >= 500, retryAfterMs = null) {
     super(message);
     this.name = "MainNangoTransportError";
     this.status = status;
     this.code = code;
     this.retryable = retryable;
+    this.retryAfterMs = retryAfterMs;
   }
 };
 function nangoClientErrorText(error) {
@@ -29695,6 +31213,13 @@ function nangoClientErrorText(error) {
     return "";
   }
 }
+function retryAfterMsFromText(value) {
+  const milliseconds = value.match(/retry[_ -]?after[_ -]?ms[^0-9]{0,20}(\d{1,7})/i);
+  if (milliseconds) return Math.min(Math.max(Number(milliseconds[1]), 1e3), 6e4);
+  const seconds = value.match(/retry[_ -]?after[^0-9]{0,20}(\d{1,4})/i);
+  if (seconds) return Math.min(Math.max(Number(seconds[1]), 1) * 1e3, 6e4);
+  return null;
+}
 function normalizeNangoClientError(error) {
   if (error instanceof MainNangoTransportError) return error;
   const detail = nangoClientErrorText(error);
@@ -29715,7 +31240,13 @@ function normalizeNangoClientError(error) {
     );
   }
   if (/RESOURCE_EXHAUSTED|rate.?limit|status["']?\s*:\s*429/i.test(detail)) {
-    return new MainNangoTransportError("The connected provider is temporarily rate limited.", 429, "upstream_rate_limited", true);
+    return new MainNangoTransportError(
+      "The connected provider is temporarily rate limited.",
+      429,
+      "upstream_rate_limited",
+      true,
+      retryAfterMsFromText(detail)
+    );
   }
   if (/UNAUTHENTICATED|invalid_grant|status["']?\s*:\s*401/i.test(detail)) {
     return new MainNangoTransportError("The service connection requires reconnection.", 409, "connection_inactive", false);
@@ -29780,7 +31311,9 @@ async function nangoRequest(path5, options = {}) {
     throw new MainNangoTransportError(
       status === 429 ? "The connected provider is temporarily rate limited." : "Nango request failed.",
       status,
-      status === 429 ? "upstream_rate_limited" : status === 404 ? "connection_not_found" : "connection_transport_unavailable"
+      status === 429 ? "upstream_rate_limited" : status === 404 ? "connection_not_found" : "connection_transport_unavailable",
+      status === 429 || status >= 500,
+      status === 429 ? retryAfterMsFromText(`retry-after: ${response.headers.get("retry-after") ?? ""}`) : null
     );
   }
   return payload;
@@ -29995,7 +31528,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 +31549,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 +31574,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 +31611,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()
   };
 }
@@ -30228,37 +31761,37 @@ function controlSecret() {
   if (!secret2) throw new NangoControlError("Scheduled service connections are not configured.", 503);
   return secret2;
 }
-function isRecord2(value) {
+function isRecord4(value) {
   return !!value && typeof value === "object" && !Array.isArray(value);
 }
 function unwrapData(value) {
-  if (isRecord2(value) && isRecord2(value.data)) return value.data;
+  if (isRecord4(value) && isRecord4(value.data)) return value.data;
   return value;
 }
-function cleanString(value, max = 300) {
+function cleanString3(value, max = 300) {
   if (typeof value !== "string") return null;
   const trimmed = value.trim();
   return trimmed ? trimmed.slice(0, max) : null;
 }
 function firstString(record, keys, max = 300) {
   for (const key of keys) {
-    const value = cleanString(record[key], max);
+    const value = cleanString3(record[key], max);
     if (value) return value;
   }
   return null;
 }
 function cleanTools(value) {
   if (!Array.isArray(value)) return [];
-  const tools = value.map((tool) => cleanString(tool, 200)).filter((tool) => !!tool);
+  const tools = value.map((tool) => cleanString3(tool, 200)).filter((tool) => !!tool);
   return [...new Set(tools)].slice(0, 200);
 }
 function cleanStringArray(value, maxItems = 20, maxLength = 100) {
   if (!Array.isArray(value)) return [];
-  const items = value.map((item) => cleanString(item, maxLength)).filter((item) => !!item);
+  const items = value.map((item) => cleanString3(item, maxLength)).filter((item) => !!item);
   return [...new Set(items)].slice(0, maxItems);
 }
 function cleanHttpsUrl(value) {
-  const candidate = cleanString(value, 2e3);
+  const candidate = cleanString3(value, 2e3);
   if (!candidate) return null;
   try {
     const url = new URL(candidate);
@@ -30270,7 +31803,7 @@ function cleanHttpsUrl(value) {
 function arrayFromPayload(value, keys) {
   const unwrapped = unwrapData(value);
   if (Array.isArray(unwrapped)) return unwrapped;
-  if (!isRecord2(unwrapped)) return [];
+  if (!isRecord4(unwrapped)) return [];
   for (const key of keys) {
     if (Array.isArray(unwrapped[key])) return unwrapped[key];
   }
@@ -30351,7 +31884,7 @@ function defaultControlErrorMessage(status) {
 function safeControlErrorPayload(body, responseStatus) {
   const status = controlErrorStatus(responseStatus);
   const unwrapped = unwrapData(body);
-  const record = isRecord2(unwrapped) ? unwrapped : isRecord2(body) ? body : null;
+  const record = isRecord4(unwrapped) ? unwrapped : isRecord4(body) ? body : null;
   const candidateCode = record ? firstString(record, ["code", "errorCode", "error_code"], 100) : null;
   const normalizedCandidateCode = candidateCode ? CONTROL_ERROR_CODE_ALIASES.get(candidateCode) ?? candidateCode : null;
   const code = normalizedCandidateCode && SAFE_CONTROL_ERROR_CODES.has(normalizedCandidateCode) ? normalizedCandidateCode : defaultControlErrorCode(status);
@@ -30400,7 +31933,7 @@ function sanitizeScheduleConnectionSelections(value) {
   const selections = [];
   const seen = /* @__PURE__ */ new Set();
   for (const item of value) {
-    if (!isRecord2(item)) throw new ScheduleConnectionValidationError("Each service connection must be an object.");
+    if (!isRecord4(item)) throw new ScheduleConnectionValidationError("Each service connection must be an object.");
     const connectionId = firstString(item, ["connectionId", "connection_id"]);
     const providerConfigKey = firstString(item, ["providerConfigKey", "provider_config_key", "integrationId", "integration_id"]);
     const allowedTools = cleanTools(item.allowedTools ?? item.allowed_tools ?? item.allowedCapabilities ?? item.allowed_capabilities);
@@ -30420,7 +31953,7 @@ async function getNangoCatalog() {
   const rows = arrayFromPayload(body, ["providers", "catalog", "integrations", "services"]);
   const result = [];
   for (const row of rows) {
-    if (!isRecord2(row)) continue;
+    if (!isRecord4(row)) continue;
     const providerConfigKey = firstString(row, ["providerConfigKey", "provider_config_key", "integrationId", "integration_id", "id"]);
     if (!providerConfigKey) continue;
     const provider = firstString(row, ["provider"]);
@@ -30440,18 +31973,18 @@ async function getNangoCatalog() {
     ).filter((tool) => !disabledTools?.has(tool));
     const requiredPermissionsByTool = {};
     const rawRequiredPermissions = row.requiredPermissionsByTool ?? row.required_permissions_by_tool;
-    if (isRecord2(rawRequiredPermissions)) {
+    if (isRecord4(rawRequiredPermissions)) {
       for (const [tool, permissions] of Object.entries(rawRequiredPermissions).slice(0, 500)) {
-        const cleanTool = cleanString(tool, 200);
+        const cleanTool = cleanString3(tool, 200);
         if (!cleanTool || !safeDefaultAllowedTools.includes(cleanTool) && !actionTools.includes(cleanTool)) continue;
         requiredPermissionsByTool[cleanTool] = cleanStringArray(permissions, 32, 200);
       }
     }
     const requiredFeaturesByTool = {};
     const rawRequiredFeatures = row.requiredFeaturesByTool ?? row.required_features_by_tool;
-    if (isRecord2(rawRequiredFeatures)) {
+    if (isRecord4(rawRequiredFeatures)) {
       for (const [tool, features] of Object.entries(rawRequiredFeatures).slice(0, 500)) {
-        const cleanTool = cleanString(tool, 200);
+        const cleanTool = cleanString3(tool, 200);
         if (!cleanTool) continue;
         requiredFeaturesByTool[cleanTool] = cleanStringArray(features, 32, 200);
       }
@@ -30576,7 +32109,7 @@ async function getNangoConnections(identity, options = {}) {
   const rows = arrayFromPayload(body, ["connections"]);
   const result = [];
   for (const row of rows) {
-    if (!isRecord2(row)) continue;
+    if (!isRecord4(row)) continue;
     const connectionId = firstString(row, ["connectionId", "connection_id", "id"]);
     const providerConfigKey = firstString(row, ["providerConfigKey", "provider_config_key", "integrationId", "integration_id", "provider"]);
     if (!connectionId || !providerConfigKey) continue;
@@ -30595,8 +32128,8 @@ async function getNangoConnections(identity, options = {}) {
     const rawToolCapabilities = row.toolCapabilities ?? row.tool_capabilities;
     if (Array.isArray(rawToolCapabilities)) {
       for (const value of rawToolCapabilities.slice(0, 500)) {
-        if (!isRecord2(value)) continue;
-        const name = cleanString(value.name, 200);
+        if (!isRecord4(value)) continue;
+        const name = cleanString3(value.name, 200);
         const classification = value.classification;
         const blockedValue = Object.prototype.hasOwnProperty.call(value, "blockedReason") ? value.blockedReason : value.blocked_reason;
         const blockedReason = blockedValue === null ? null : blockedValue === "missing_permission" || blockedValue === "permission_policy_missing" || blockedValue === "permission_verification_unavailable" || blockedValue === "missing_app_feature" ? blockedValue : void 0;
@@ -30663,7 +32196,7 @@ async function deleteNangoConnection(identity, connectionId) {
     body: JSON.stringify({ identity, connectionId })
   });
   const data = unwrapData(body);
-  if (!isRecord2(data) || data.ok !== true) {
+  if (!isRecord4(data) || data.ok !== true) {
     throw new NangoControlError("The connection service returned an invalid deletion response.");
   }
   const remaining = Number(data.remainingConnections);
@@ -30671,7 +32204,7 @@ async function deleteNangoConnection(identity, connectionId) {
 }
 function sanitizeConnectSession(body) {
   const data = unwrapData(body);
-  if (!isRecord2(data)) throw new NangoControlError("The connection service returned an invalid connect session.");
+  if (!isRecord4(data)) throw new NangoControlError("The connection service returned an invalid connect session.");
   const connectLink = firstString(data, ["connectLink", "connect_link"], 2e3);
   if (!connectLink) throw new NangoControlError("The connection service did not return a connect link.");
   return {
@@ -30713,14 +32246,14 @@ async function createNangoReconnectSession(identity, connectionId) {
 function sanitizeBindingRows(body, defaultScheduleActionId) {
   const data = unwrapData(body);
   const flattened = [];
-  if (isRecord2(data) && isRecord2(data.bindings) && !Array.isArray(data.bindings)) {
+  if (isRecord4(data) && isRecord4(data.bindings) && !Array.isArray(data.bindings)) {
     for (const [scheduleActionId, value] of Object.entries(data.bindings)) {
       if (Array.isArray(value)) value.forEach((row) => flattened.push({ row, scheduleActionId }));
     }
   } else {
     const rows = arrayFromPayload(data, ["bindings", "connections"]);
     for (const row of rows) {
-      if (isRecord2(row) && Array.isArray(row.connections)) {
+      if (isRecord4(row) && Array.isArray(row.connections)) {
         const scheduleActionId = firstString(row, ["scheduleActionId", "schedule_action_id", "scheduleId", "schedule_id"]) || defaultScheduleActionId;
         row.connections.forEach((connection) => flattened.push({ row: connection, scheduleActionId }));
       } else {
@@ -30730,7 +32263,7 @@ function sanitizeBindingRows(body, defaultScheduleActionId) {
   }
   const result = [];
   for (const item of flattened) {
-    if (!isRecord2(item.row)) continue;
+    if (!isRecord4(item.row)) continue;
     const connectionId = firstString(item.row, ["connectionId", "connection_id"]);
     const providerConfigKey = firstString(item.row, ["providerConfigKey", "provider_config_key", "integrationId", "integration_id", "provider"]);
     if (!connectionId || !providerConfigKey) continue;
@@ -30798,11 +32331,11 @@ async function setScheduleConnectionActionsEnabled(identity, connectionId, enabl
     body: JSON.stringify({ identity, connectionId, enabled })
   });
   const data = unwrapData(body);
-  if (!isRecord2(data) || !isRecord2(data.connection)) return enabled;
+  if (!isRecord4(data) || !isRecord4(data.connection)) return enabled;
   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);
@@ -30848,7 +32381,7 @@ async function callScheduleConnectionAction(identity, connectionId, input, tool,
     body: JSON.stringify({ identity, connectionId, ...tool ? { tool } : {}, input })
   });
   const data = unwrapData(body);
-  return isRecord2(data) ? data.result ?? data : data;
+  return isRecord4(data) ? data.result ?? data : data;
 }
 async function callScheduleConnectionRead(identity, connectionId, tool, args, idempotencyKey2) {
   if (mainOwnsIntegrations()) {
@@ -30871,7 +32404,7 @@ async function callScheduleConnectionRead(identity, connectionId, tool, args, id
     body: JSON.stringify({ identity, connectionId, tool, args: args ?? {} })
   });
   const data = unwrapData(body);
-  return isRecord2(data) ? data.result ?? data : data;
+  return isRecord4(data) ? data.result ?? data : data;
 }
 async function testNangoConnection(identity, connectionId) {
   if (!mainOwnsIntegrations()) {
@@ -30891,20 +32424,20 @@ async function testNangoConnection(identity, connectionId) {
   }
 }
 function sanitizeToolSchema(value) {
-  if (!isRecord2(value) || value.type !== "object") return null;
+  if (!isRecord4(value) || value.type !== "object") return null;
   try {
     const serialized = JSON.stringify(value);
     if (Buffer.byteLength(serialized, "utf8") > 256 * 1024) return null;
     const cloned = JSON.parse(serialized);
-    return isRecord2(cloned) ? cloned : null;
+    return isRecord4(cloned) ? cloned : null;
   } catch {
     return null;
   }
 }
 function sanitizeToolAnnotations(value) {
-  if (!isRecord2(value)) return void 0;
+  if (!isRecord4(value)) return void 0;
   const annotations = {};
-  const title = cleanString(value.title, 200);
+  const title = cleanString3(value.title, 200);
   if (title) annotations.title = title;
   for (const key of ["readOnlyHint", "destructiveHint", "idempotentHint", "openWorldHint"]) {
     if (typeof value[key] === "boolean") annotations[key] = value[key];
@@ -30912,7 +32445,7 @@ function sanitizeToolAnnotations(value) {
   return Object.keys(annotations).length > 0 ? annotations : void 0;
 }
 function sanitizeToolIconSource(value) {
-  const candidate = cleanString(value, 1e4);
+  const candidate = cleanString3(value, 1e4);
   if (!candidate) return null;
   if (/^data:image\/(?:png|jpeg|webp|gif|svg\+xml);base64,[a-z0-9+/=]+$/i.test(candidate)) return candidate;
   return cleanHttpsUrl(candidate);
@@ -30921,10 +32454,10 @@ function sanitizeToolIcons(value) {
   if (!Array.isArray(value)) return void 0;
   const icons = [];
   for (const item of value.slice(0, 16)) {
-    if (!isRecord2(item)) continue;
+    if (!isRecord4(item)) continue;
     const src = sanitizeToolIconSource(item.src);
     if (!src) continue;
-    const mimeType = cleanString(item.mimeType ?? item.mime_type, 100);
+    const mimeType = cleanString3(item.mimeType ?? item.mime_type, 100);
     const sizes = cleanStringArray(item.sizes, 16, 32);
     const theme = item.theme === "light" || item.theme === "dark" ? item.theme : void 0;
     icons.push({
@@ -30938,13 +32471,13 @@ function sanitizeToolIcons(value) {
 }
 function canonicalJson2(value) {
   if (Array.isArray(value)) return `[${value.map(canonicalJson2).join(",")}]`;
-  if (isRecord2(value)) {
+  if (isRecord4(value)) {
     return `{${Object.keys(value).sort().map((key) => `${JSON.stringify(key)}:${canonicalJson2(value[key])}`).join(",")}}`;
   }
   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()) {
@@ -30969,8 +32502,8 @@ async function describeNangoTool(identity, connectionId, tool, fresh) {
 }
 function sanitizeNangoToolDescription(body, tool) {
   const data = unwrapData(body);
-  const rawTool = isRecord2(data) && isRecord2(data.tool) ? data.tool : data;
-  if (!isRecord2(rawTool)) {
+  const rawTool = isRecord4(data) && isRecord4(data.tool) ? data.tool : data;
+  if (!isRecord4(rawTool)) {
     throw new NangoControlError(
       "The connection service returned an invalid live tool description.",
       502,
@@ -30983,13 +32516,13 @@ function sanitizeNangoToolDescription(body, tool) {
     serializedBytes = Buffer.byteLength(JSON.stringify(rawTool), "utf8");
   } catch {
   }
-  const name = cleanString(rawTool.name, 200);
-  const classification = cleanString(rawTool.classification, 20);
-  const transport = cleanString(rawTool.transport, 20);
-  const providerConfigKey = cleanString(rawTool.providerConfigKey ?? rawTool.provider_config_key, 200);
-  const schemaSource = cleanString(rawTool.schemaSource ?? rawTool.schema_source, 50);
-  const upstreamSchemaHash = cleanString(rawTool.schemaHash ?? rawTool.schema_hash, 200);
-  const fetchedAt = cleanString(rawTool.fetchedAt ?? rawTool.fetched_at, 100);
+  const name = cleanString3(rawTool.name, 200);
+  const classification = cleanString3(rawTool.classification, 20);
+  const transport = cleanString3(rawTool.transport, 20);
+  const providerConfigKey = cleanString3(rawTool.providerConfigKey ?? rawTool.provider_config_key, 200);
+  const schemaSource = cleanString3(rawTool.schemaSource ?? rawTool.schema_source, 50);
+  const upstreamSchemaHash = cleanString3(rawTool.schemaHash ?? rawTool.schema_hash, 200);
+  const fetchedAt = cleanString3(rawTool.fetchedAt ?? rawTool.fetched_at, 100);
   const inputSchema = sanitizeToolSchema(rawTool.inputSchema ?? rawTool.input_schema);
   const outputSchemaValue = rawTool.outputSchema ?? rawTool.output_schema;
   const outputSchema = outputSchemaValue === void 0 ? void 0 : sanitizeToolSchema(outputSchemaValue);
@@ -31003,11 +32536,11 @@ function sanitizeNangoToolDescription(body, tool) {
       true
     );
   }
-  const protocolVersion = rawTool.protocolVersion === null || rawTool.protocol_version === null ? null : cleanString(rawTool.protocolVersion ?? rawTool.protocol_version, 100);
+  const protocolVersion = rawTool.protocolVersion === null || rawTool.protocol_version === null ? null : cleanString3(rawTool.protocolVersion ?? rawTool.protocol_version, 100);
   const executionValue = rawTool.execution;
-  const taskSupport = isRecord2(executionValue) && (executionValue.taskSupport === "forbidden" || executionValue.taskSupport === "optional" || executionValue.taskSupport === "required") ? executionValue.taskSupport : null;
-  const title = cleanString(rawTool.title, 200);
-  const description = cleanString(rawTool.description, 12e3);
+  const taskSupport = isRecord4(executionValue) && (executionValue.taskSupport === "forbidden" || executionValue.taskSupport === "optional" || executionValue.taskSupport === "required") ? executionValue.taskSupport : null;
+  const title = cleanString3(rawTool.title, 200);
+  const description = cleanString3(rawTool.description, 12e3);
   const annotations = sanitizeToolAnnotations(rawTool.annotations);
   const icons = sanitizeToolIcons(rawTool.icons);
   const execution = taskSupport ? { taskSupport } : void 0;
@@ -31050,10 +32583,13 @@ function sanitizeNangoToolDescription(body, tool) {
   };
 }
 async function callScheduleConnectionExportPage(identity, input) {
-  if (mainOwnsIntegrations() && input.dataset === "search_console_performance") {
+  if (mainOwnsIntegrations() && (input.dataset === "search_console_performance" || input.dataset === "slack_channel_messages")) {
     try {
       return await callMainOwnedExportPage(identity, input);
     } catch (error) {
+      if (error instanceof Error && /^slack_export_(?:channel_required|cursor_invalid|range_invalid)$/.test(error.message)) {
+        throw new NangoControlError("The Slack channel export request or continuation is invalid.", 400, "invalid_request", false);
+      }
       throw asNangoControlError(error);
     }
   }
@@ -31062,11 +32598,11 @@ async function callScheduleConnectionExportPage(identity, input) {
     body: JSON.stringify({ identity, ...input })
   }, 9e4);
   const data = unwrapData(body);
-  if (!isRecord2(data) || data.ok !== true) {
+  if (!isRecord4(data) || data.ok !== true) {
     throw new NangoControlError("Connected-data export returned an invalid page response.");
   }
-  const providerConfigKey = cleanString(data.providerConfigKey, 128);
-  const dataset = cleanString(data.dataset, 64);
+  const providerConfigKey = cleanString3(data.providerConfigKey, 128);
+  const dataset = cleanString3(data.dataset, 64);
   if (!providerConfigKey || dataset === "auto" || !CONNECTED_DATA_DATASETS.includes(dataset)) {
     throw new NangoControlError("Connected-data export returned invalid provider metadata.");
   }
@@ -31076,7 +32612,7 @@ async function callScheduleConnectionExportPage(identity, input) {
   if (data.nextCursor !== void 0 && data.nextCursor !== null && typeof data.nextCursor !== "string") {
     throw new NangoControlError("Connected-data export returned an invalid continuation cursor.");
   }
-  const rawCounts = isRecord2(data.counts) ? data.counts : {};
+  const rawCounts = isRecord4(data.counts) ? data.counts : {};
   const numberOrZero = (value) => typeof value === "number" && Number.isFinite(value) && value >= 0 ? value : 0;
   return {
     providerConfigKey,
@@ -31094,11 +32630,11 @@ async function callScheduleConnectionExportPage(identity, input) {
   };
 }
 function unwrapMcpToolJson(value) {
-  if (!isRecord2(value)) return value;
-  if (isRecord2(value.structuredContent)) return value.structuredContent;
+  if (!isRecord4(value)) return value;
+  if (isRecord4(value.structuredContent)) return value.structuredContent;
   if (Array.isArray(value.content)) {
-    const textPart = value.content.find((part) => isRecord2(part) && part.type === "text" && typeof part.text === "string");
-    if (isRecord2(textPart) && typeof textPart.text === "string") {
+    const textPart = value.content.find((part) => isRecord4(part) && part.type === "text" && typeof part.text === "string");
+    if (isRecord4(textPart) && typeof textPart.text === "string") {
       try {
         return JSON.parse(textPart.text);
       } catch {
@@ -31111,13 +32647,26 @@ function unwrapMcpToolJson(value) {
 function rowsFromToolResult(value, keys) {
   const unwrapped = unwrapMcpToolJson(value);
   if (Array.isArray(unwrapped)) return unwrapped;
-  if (!isRecord2(unwrapped)) return [];
+  if (!isRecord4(unwrapped)) return [];
   for (const key of keys) if (Array.isArray(unwrapped[key])) return unwrapped[key];
   return [];
 }
 async function callMainOwnedExportPage(identity, input) {
   const connection = await getOwnedServiceConnection(identity, input.connectionId);
   if (!connection) throw new NangoControlError("The service connection was not found.", 404, "connection_not_found", false);
+  if (connection.providerConfigKey === "slack" && input.dataset === "slack_channel_messages") {
+    return exportSlackChannelPage(input, {
+      callTool: async (args) => callNangoToolDirect({
+        identity,
+        connectionId: input.connectionId,
+        tool: args.tool,
+        input: args.input,
+        classification: "read",
+        requestId: args.requestId,
+        operationKind: "export"
+      })
+    });
+  }
   if (connection.providerConfigKey !== "google-search-console" || input.dataset !== "search_console_performance") {
     throw new NangoControlError("This dataset has not moved to main-MCP export execution yet.", 400, "invalid_request", false);
   }
@@ -31135,8 +32684,8 @@ async function callMainOwnedExportPage(identity, input) {
     operationKind: "export"
   });
   const sites = rowsFromToolResult(listed, ["siteEntry", "sites", "items"]).flatMap((value) => {
-    const row = isRecord2(value) ? value : null;
-    const siteUrl2 = row ? cleanString(row.siteUrl ?? row.site_url, 2e3) : null;
+    const row = isRecord4(value) ? value : null;
+    const siteUrl2 = row ? cleanString3(row.siteUrl ?? row.site_url, 2e3) : null;
     return siteUrl2 ? [siteUrl2] : [];
   }).sort().slice(0, 1e4);
   if (siteIndex >= sites.length) {
@@ -31173,7 +32722,7 @@ async function callMainOwnedExportPage(identity, input) {
   });
   const rows = rowsFromToolResult(performance2, ["rows"]).slice(0, input.pageSize);
   const records = rows.map((value, index) => {
-    const row = isRecord2(value) ? value : {};
+    const row = isRecord4(value) ? value : {};
     const keys = Array.isArray(row.keys) ? row.keys.map((item) => String(item ?? "")) : [];
     const date = keys[0] || null;
     return {
@@ -31250,34 +32799,34 @@ function controlSecret2() {
   if (!secret2) throw new ResendControlError("Resend connections are not configured.", 503);
   return secret2;
 }
-function isRecord3(value) {
+function isRecord5(value) {
   return !!value && typeof value === "object" && !Array.isArray(value);
 }
 function unwrapData2(value) {
-  return isRecord3(value) && isRecord3(value.data) ? value.data : value;
+  return isRecord5(value) && isRecord5(value.data) ? value.data : value;
 }
-function cleanString2(value, max = 300) {
+function cleanString4(value, max = 300) {
   if (typeof value !== "string") return null;
   const trimmed = value.trim();
   return trimmed ? trimmed.slice(0, max) : null;
 }
 function firstString2(record, keys, max = 300) {
   for (const key of keys) {
-    const value = cleanString2(record[key], max);
+    const value = cleanString4(record[key], max);
     if (value) return value;
   }
   return null;
 }
 function cleanTools2(value) {
   if (!Array.isArray(value)) return [];
-  return [...new Set(value.map((tool) => cleanString2(tool, 200)).filter((tool) => !!tool))].slice(0, 200);
+  return [...new Set(value.map((tool) => cleanString4(tool, 200)).filter((tool) => !!tool))].slice(0, 200);
 }
 function cleanStringArray2(value, maxItems = 50, maxLength = 500) {
   if (!Array.isArray(value)) return [];
-  return [...new Set(value.map((item) => cleanString2(item, maxLength)).filter((item) => !!item))].slice(0, maxItems);
+  return [...new Set(value.map((item) => cleanString4(item, maxLength)).filter((item) => !!item))].slice(0, maxItems);
 }
 function cleanHttpsUrl2(value) {
-  const candidate = cleanString2(value, 2e3);
+  const candidate = cleanString4(value, 2e3);
   if (!candidate) return null;
   try {
     const url = new URL(candidate);
@@ -31295,7 +32844,7 @@ function cleanAuthorizationUrl(value) {
 function arrayFromPayload2(value, keys) {
   const unwrapped = unwrapData2(value);
   if (Array.isArray(unwrapped)) return unwrapped;
-  if (!isRecord3(unwrapped)) return [];
+  if (!isRecord5(unwrapped)) return [];
   for (const key of keys) {
     if (Array.isArray(unwrapped[key])) return unwrapped[key];
   }
@@ -31322,7 +32871,7 @@ async function controlRequest2(path5, init, timeoutMs = 2e4) {
     body = {};
   }
   if (!response.ok) {
-    const upstream = isRecord3(body) ? cleanString2(body.error, 300) : null;
+    const upstream = isRecord5(body) ? cleanString4(body.error, 300) : null;
     throw new ResendControlError(upstream || `Resend connection control failed (${response.status}).`);
   }
   return body;
@@ -31332,7 +32881,7 @@ async function getResendCatalog() {
   const rows = arrayFromPayload2(body, ["providers", "catalog", "integrations", "services"]);
   const result = [];
   for (const row of rows) {
-    if (!isRecord3(row)) continue;
+    if (!isRecord5(row)) continue;
     const id = firstString2(row, ["providerConfigKey", "provider_config_key", "id"]);
     if (id !== RESEND_PROVIDER_CONFIG_KEY) continue;
     const safeDefaultAllowedTools = cleanTools2(
@@ -31368,7 +32917,7 @@ async function getResendConnections(identity) {
   const rows = arrayFromPayload2(body, ["connections"]);
   const result = [];
   for (const row of rows) {
-    if (!isRecord3(row)) continue;
+    if (!isRecord5(row)) continue;
     const connectionId = firstString2(row, ["connectionId", "connection_id", "id"]);
     const providerConfigKey = firstString2(row, ["providerConfigKey", "provider_config_key", "provider"]) || RESEND_PROVIDER_CONFIG_KEY;
     if (!connectionId || providerConfigKey !== RESEND_PROVIDER_CONFIG_KEY) continue;
@@ -31412,7 +32961,7 @@ async function getResendConnections(identity) {
 }
 function sanitizeConnectSession2(body) {
   const data = unwrapData2(body);
-  if (!isRecord3(data)) throw new ResendControlError("The Resend connection service returned an invalid connect session.");
+  if (!isRecord5(data)) throw new ResendControlError("The Resend connection service returned an invalid connect session.");
   const connectLink = cleanAuthorizationUrl(data.authorizationUrl ?? data.authorization_url ?? data.connectLink ?? data.connect_link);
   if (!connectLink) throw new ResendControlError("The Resend connection service did not return a trusted authorization link.");
   return {
@@ -31453,7 +33002,7 @@ async function setResendActionsEnabled(identity, connectionId, enabled) {
     body: JSON.stringify({ identity, connectionId, enabled })
   });
   const data = unwrapData2(body);
-  if (!isRecord3(data) || !isRecord3(data.connection)) return enabled;
+  if (!isRecord5(data) || !isRecord5(data.connection)) return enabled;
   return data.connection.actionsEnabled === true || data.connection.actions_enabled === true;
 }
 async function callResendRead(identity, connectionId, tool, args) {
@@ -31462,7 +33011,7 @@ async function callResendRead(identity, connectionId, tool, args) {
     body: JSON.stringify({ identity, connectionId, tool, input: args ?? {} })
   });
   const data = unwrapData2(body);
-  return isRecord3(data) ? data.result ?? data : data;
+  return isRecord5(data) ? data.result ?? data : data;
 }
 async function callResendAction(identity, connectionId, tool, input) {
   const body = await controlRequest2("/api/internal/resend/actions/call", {
@@ -31470,7 +33019,7 @@ async function callResendAction(identity, connectionId, tool, input) {
     body: JSON.stringify({ identity, connectionId, tool, input })
   });
   const data = unwrapData2(body);
-  return isRecord3(data) ? data.result ?? data : data;
+  return isRecord5(data) ? data.result ?? data : data;
 }
 async function describeResendTool(identity, connectionId, tool) {
   const body = await controlRequest2("/api/internal/resend/describe", {
@@ -31478,12 +33027,12 @@ async function describeResendTool(identity, connectionId, tool) {
     body: JSON.stringify({ identity, connectionId, tool })
   });
   const data = unwrapData2(body);
-  const rawTool = isRecord3(data) && isRecord3(data.tool) ? data.tool : data;
-  if (!isRecord3(rawTool)) throw new ResendControlError("Resend returned an invalid tool description.");
+  const rawTool = isRecord5(data) && isRecord5(data.tool) ? data.tool : data;
+  if (!isRecord5(rawTool)) throw new ResendControlError("Resend returned an invalid tool description.");
   const name = firstString2(rawTool, ["name"], 200);
   const classification = firstString2(rawTool, ["classification", "kind"], 20);
   const inputSchema = rawTool.inputSchema ?? rawTool.input_schema;
-  if (!name || name !== tool || classification !== "read" && classification !== "action" || !isRecord3(inputSchema)) {
+  if (!name || name !== tool || classification !== "read" && classification !== "action" || !isRecord5(inputSchema)) {
     throw new ResendControlError("Resend returned an invalid tool description.");
   }
   return {
@@ -31500,10 +33049,10 @@ async function callResendExportPage(identity, input) {
     body: JSON.stringify({ identity, ...input })
   }, 9e4);
   const data = unwrapData2(body);
-  if (!isRecord3(data) || data.ok !== true || data.providerConfigKey !== RESEND_PROVIDER_CONFIG_KEY) {
+  if (!isRecord5(data) || data.ok !== true || data.providerConfigKey !== RESEND_PROVIDER_CONFIG_KEY) {
     throw new ResendControlError("Resend export returned an invalid page response.");
   }
-  const dataset = cleanString2(data.dataset, 64);
+  const dataset = cleanString4(data.dataset, 64);
   if (!dataset || dataset === "auto" || !CONNECTED_DATA_DATASETS.includes(dataset)) {
     throw new ResendControlError("Resend export returned invalid dataset metadata.");
   }
@@ -31511,7 +33060,7 @@ async function callResendExportPage(identity, input) {
   if (data.nextCursor !== void 0 && data.nextCursor !== null && typeof data.nextCursor !== "string") {
     throw new ResendControlError("Resend export returned an invalid continuation cursor.");
   }
-  const rawCounts = isRecord3(data.counts) ? data.counts : {};
+  const rawCounts = isRecord5(data.counts) ? data.counts : {};
   const numberOrZero = (value) => typeof value === "number" && Number.isFinite(value) && value >= 0 ? value : 0;
   return {
     providerConfigKey: RESEND_PROVIDER_CONFIG_KEY,
@@ -31530,7 +33079,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 +33095,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 +33262,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");
@@ -32114,6 +33675,16 @@ app.get("/memory/note", auth2, async (c) => {
     return c.json({ ok: false, error: err instanceof Error ? err.message : "could not load note" }, 502);
   }
 });
+app.get("/memory/universe", auth2, async (c) => {
+  const user = c.get("user");
+  const includeConnections = c.req.query("includeConnections") === "1";
+  try {
+    const graph = await dbUniverse(resolveMemoryIdentity(user), includeConnections);
+    return c.json({ ok: true, ...graph });
+  } catch (err) {
+    return c.json({ ok: false, error: err instanceof Error ? err.message : "could not build universe" }, 502);
+  }
+});
 app.put("/memory/note", auth2, async (c) => {
   const { key, error } = await getOrCreateUserMemoryKey(c.get("user"));
   if (!key) return c.json({ error: error ?? "memory unavailable" }, 502);
@@ -32855,7 +34426,18 @@ app.post("/schedule-connections/actions/export", auth2, requireIntegrationsTier,
   const body = await c.req.json().catch(() => ({}));
   const connectionId = providerConfigKeyFrom(body.connectionId);
   if (!connectionId) return c.json({ ok: false, error: "connectionId is required." }, 400);
-  const requestedDataset = typeof body.dataset === "string" ? body.dataset.trim() : "auto";
+  const channelId = typeof body.channelId === "string" ? body.channelId.trim() : "";
+  if (body.channelId !== void 0 && !channelId) {
+    return c.json({ ok: false, error: "channelId must be a non-empty Slack conversation ID." }, 400);
+  }
+  if (body.includeThreads !== void 0 && typeof body.includeThreads !== "boolean") {
+    return c.json({ ok: false, error: "includeThreads must be a boolean when provided." }, 400);
+  }
+  if (body.allTime !== void 0 && typeof body.allTime !== "boolean") {
+    return c.json({ ok: false, error: "allTime must be a boolean when provided." }, 400);
+  }
+  const rawRequestedDataset = typeof body.dataset === "string" ? body.dataset.trim() : "auto";
+  const requestedDataset = rawRequestedDataset === "auto" && channelId ? "slack_channel_messages" : rawRequestedDataset;
   const datasets = [...CONNECTED_DATA_DATASETS];
   if (!datasets.includes(requestedDataset)) {
     return c.json({ ok: false, error: `dataset must be one of: ${datasets.join(", ")}.` }, 400);
@@ -32878,21 +34460,37 @@ app.post("/schedule-connections/actions/export", auth2, requireIntegrationsTier,
   if (body.continuation !== void 0 && !continuation) {
     return c.json({ ok: false, error: "continuation must be the complete object returned by a prior export." }, 400);
   }
+  if (body.allTime === true && requestedDataset !== "slack_channel_messages") {
+    return c.json({ ok: false, error: "allTime is supported only for Slack channel exports." }, 400);
+  }
+  if (body.allTime === true && (body.from !== void 0 || body.lastDays !== void 0 || continuation)) {
+    return c.json({ ok: false, error: "Do not pass allTime with from, lastDays, or continuation." }, 400);
+  }
+  if (requestedDataset === "slack_channel_messages" && !channelId && !continuation) {
+    return c.json({ ok: false, error: "channelId is required for a Slack channel export." }, 400);
+  }
   try {
     const useResend = await isResendConnection(user.email, connectionId);
     const resolved = resolveConnectedDataExportRequest({
       requestedDataset,
-      from: typeof body.from === "string" ? body.from : void 0,
+      from: body.allTime === true ? "1970-01-01T00:00:00.000Z" : typeof body.from === "string" ? body.from : void 0,
       to: typeof body.to === "string" ? body.to : void 0,
       lastDays,
       cursor: typeof body.cursor === "string" ? body.cursor : void 0,
-      continuation
+      continuation,
+      scope: channelId ? {
+        slack: {
+          channelId,
+          includeThreads: body.includeThreads !== false
+        }
+      } : void 0
     });
     const result = await collectConnectedDataExport({
       ownerId: sha256Hex(user.api_key).slice(0, 24),
       connectionId,
       dataset: resolved.dataset,
       range: resolved.range,
+      ...resolved.scope ? { scope: resolved.scope } : {},
       maxItems,
       forceArtifact: body.delivery === "artifact",
       ...resolved.cursor ? { cursor: resolved.cursor } : {},
@@ -33253,8 +34851,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 +34899,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 +35017,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 +36064,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 +36080,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 +36099,8 @@ app.get("/cron/tick", async (c) => {
     siteExtractArtifactCleanup,
     siteExtractRedispatch,
     siteExtractReconciliation,
+    paaHarvestRedispatch,
+    paaHarvestReconciliation,
     workflowDispatch: workflowDispatchResult
   });
 });
@@ -34470,8 +36117,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 +36145,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 +36160,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 +36321,4 @@ app.get("/blog/:slug/", (c) => {
 export {
   app
 };
-//# sourceMappingURL=server-KM3CFWCF.js.map
+//# sourceMappingURL=server-2JJPCZH4.js.map