mcp-scraper 0.25.0 → 0.26.1

package/dist/{server-PILR3U5E.js → server-UHDJ5TH5.js}

@@ -35,7 +35,7 @@ import {
   sanitizeAttempts,
   sanitizeHarvestResult,
   transcribeMediaUrl
-} from "./chunk-NC37L5RW.js";
+} from "./chunk-YMEPX46N.js";
 import {
   auditImages,
   buildLinkReport,
@@ -76,7 +76,7 @@ import {
   RawMapsOverviewSchema,
   RawMapsReviewStatsSchema
 } from "./chunk-XGIPATLV.js";
-import "./chunk-UELJZCUC.js";
+import "./chunk-FQQC5OZJ.js";
 import {
   completeExtractJob,
   countSuccessfulPages,
@@ -87,10 +87,17 @@ import {
   saveExtractPages,
   setExtractJobTotal,
   settleExtractJob
-} from "./chunk-PNBYYAEK.js";
+} from "./chunk-3ZZOLQ6A.js";
 import {
   BROWSER_OPEN_MIN_BALANCE_MC,
   CONCURRENCY_PRICE_ID,
+  CONNECTED_ACTIVE_CONNECTION_MONTHLY_USD,
+  CONNECTED_COMPUTE_CREDITS_PER_SECOND,
+  CONNECTED_FUNCTION_RUN_CREDITS,
+  CONNECTED_FUNCTION_RUN_MC,
+  CONNECTED_PROXY_REQUEST_CREDITS,
+  CONNECTED_USAGE_RATE_POLICY,
+  CONNECTED_USAGE_RATE_POLICY_VERSION,
   CREDIT_COST_CATALOG,
   LedgerOperation,
   MC_COSTS,
@@ -112,12 +119,13 @@ import {
   USD_NANOS,
   VIDEO_ANALYSIS_LLM_MARGIN_MULTIPLE,
   browserActiveCostMc,
+  calculateConnectedUsageCharge,
   concurrencySlotBillingInfo,
   getPublicRatesPayload,
   insufficientBalanceResponse,
   serpActualCostMc,
   vendorCostUsdToMc
-} from "./chunk-JHI373VB.js";
+} from "./chunk-4767BA2O.js";
 import {
   CaptchaError,
   RECAPTCHA_INSTRUCTIONS,
@@ -3463,8 +3471,8 @@ function el(type, style, ...children) {
   const ch = children.flat().filter((c) => c != null);
   return { type, props: { style, children: ch.length === 0 ? void 0 : ch.length === 1 ? ch[0] : ch } };
 }
-function clean(text) {
-  return text.replace(/[\u{1F000}-\u{1FFFF}\u{2600}-\u{27BF}]/gu, "").replace(/[().,!?]/g, "").trim();
+function clean(text2) {
+  return text2.replace(/[\u{1F000}-\u{1FFFF}\u{2600}-\u{27BF}]/gu, "").replace(/[().,!?]/g, "").trim();
 }
 function tagline(post) {
   if (post.titleDisplayItalic) return clean(post.titleDisplayItalic).slice(0, 38);
@@ -3618,13 +3626,13 @@ async function extractKpo(opts) {
           continue;
         }
         if (!res.ok) return null;
-        const text = await res.text();
-        if (text.length < 2e3) return null;
-        const stripped = text.replace(/<(script|style|noscript|svg|iframe|canvas)[^>]*>[\s\S]*?<\/\1>/gi, "").replace(/<(nav|header|footer|aside)[^>]*>[\s\S]*?<\/\1>/gi, "");
+        const text2 = await res.text();
+        if (text2.length < 2e3) return null;
+        const stripped = text2.replace(/<(script|style|noscript|svg|iframe|canvas)[^>]*>[\s\S]*?<\/\1>/gi, "").replace(/<(nav|header|footer|aside)[^>]*>[\s\S]*?<\/\1>/gi, "");
         const contentBlock = stripped.match(/<main[^>]*>([\s\S]*?)<\/main>/i)?.[1] ?? stripped.match(/<article[^>]*>([\s\S]*?)<\/article>/i)?.[1] ?? stripped.match(/<body[^>]*>([\s\S]*?)<\/body>/i)?.[1] ?? "";
         const visibleContent = contentBlock.replace(/<[^>]+>/g, " ").replace(/\s+/g, " ").trim();
         if (visibleContent.length < 300) return null;
-        return text;
+        return text2;
       }
       return null;
     } catch {
@@ -3661,8 +3669,8 @@ async function extractKpo(opts) {
   const headings = [];
   for (const m of html.matchAll(/<(h[1-6])[^>]*>([\s\S]*?)<\/\1>/gi)) {
     const level = parseInt(m[1].slice(1));
-    const text = stripTags(m[2]);
-    if (text) headings.push({ level, text });
+    const text2 = stripTags(m[2]);
+    if (text2) headings.push({ level, text: text2 });
   }
   const sanitizeJsonLd = (s) => s.replace(/[\x00-\x09\x0b\x0c\x0e-\x1f]/g, " ");
   const parseJsonLd = (s) => {
@@ -4092,7 +4100,7 @@ async function extractBrandingFromPage(page) {
   const navChildBg = dominantColor(raw.navChildBgFreq ?? {});
   const primary = navBgUsable ?? svgPrimary ?? navChildBg ?? bodyBgHex;
   const accent = rgbToHex(raw.btnBg ?? "");
-  const text = rgbToHex(raw.bodyColor ?? "");
+  const text2 = rgbToHex(raw.bodyColor ?? "");
   const heading = rgbToHex(raw.h1Color ?? "");
   const background = bodyBgHex;
   const scheme = background ? luminance(background) > 128 ? "light" : "dark" : null;
@@ -4102,7 +4110,7 @@ async function extractBrandingFromPage(page) {
       primary: primary && !isTransparentOrWhite(primary) ? primary : null,
       accent: accent && !isTransparentOrWhite(accent) ? accent : null,
       background: background ?? null,
-      text: text ?? null,
+      text: text2 ?? null,
       heading: heading ?? null
     },
     fonts: {
@@ -4743,8 +4751,8 @@ function parsePageData(url, html, status, via, resp) {
   const canonicalUrl = html.match(/<link[^>]+rel=["']canonical["'][^>]+href=["']([^"']*)["']/i)?.[1]?.trim() ?? html.match(/<link[^>]+href=["']([^"']*)["'][^>]+rel=["']canonical["']/i)?.[1]?.trim() ?? null;
   const headings = [];
   for (const m of html.matchAll(/<h([1-6])[^>]*>([\s\S]*?)<\/h\1>/gi)) {
-    const text = m[2].replace(/<[^>]+>/g, "").trim();
-    if (text) headings.push({ level: Number(m[1]), text: text.slice(0, 200) });
+    const text2 = m[2].replace(/<[^>]+>/g, "").trim();
+    if (text2) headings.push({ level: Number(m[1]), text: text2.slice(0, 200) });
   }
   const h1 = headings.find((h) => h.level === 1)?.text ?? null;
   const bodyText = html.replace(/<script[\s\S]*?<\/script>/gi, "").replace(/<style[\s\S]*?<\/style>/gi, "").replace(/<[^>]+>/g, " ").replace(/\s+/g, " ").trim();
@@ -5064,14 +5072,14 @@ var inngest = new Inngest({ id: "mcp-scraper" });
 // src/lib/llm-parse-with-retry.ts
 import Anthropic from "@anthropic-ai/sdk";
 function extractJson(raw) {
-  let text = raw.replace(/<think>[\s\S]*?<\/think>/gi, "").trim();
-  text = text.replace(/^```(?:json)?\s*/i, "").replace(/\s*```\s*$/, "").trim();
-  if (text.startsWith("{") || text.startsWith("[")) return text;
-  const objStart = text.indexOf("{");
-  const arrStart = text.indexOf("[");
+  let text2 = raw.replace(/<think>[\s\S]*?<\/think>/gi, "").trim();
+  text2 = text2.replace(/^```(?:json)?\s*/i, "").replace(/\s*```\s*$/, "").trim();
+  if (text2.startsWith("{") || text2.startsWith("[")) return text2;
+  const objStart = text2.indexOf("{");
+  const arrStart = text2.indexOf("[");
   let start = -1;
   let open, close;
-  if (objStart === -1 && arrStart === -1) return text;
+  if (objStart === -1 && arrStart === -1) return text2;
   if (objStart === -1) {
     start = arrStart;
     open = "[";
@@ -5092,8 +5100,8 @@ function extractJson(raw) {
   let depth = 0;
   let inStr = false;
   let escape = false;
-  for (let i = start; i < text.length; i++) {
-    const ch = text[i];
+  for (let i = start; i < text2.length; i++) {
+    const ch = text2[i];
     if (escape) {
       escape = false;
       continue;
@@ -5109,10 +5117,10 @@ function extractJson(raw) {
     if (inStr) continue;
     if (ch === open) depth++;
     else if (ch === close) {
-      if (--depth === 0) return text.slice(start, i + 1);
+      if (--depth === 0) return text2.slice(start, i + 1);
     }
   }
-  return text.slice(start);
+  return text2.slice(start);
 }
 var DeepInfraLlmClient = class {
   apiKey;
@@ -8513,9 +8521,9 @@ import { provisionDefaultsTool } from "mcpscraper-memory-tools/tools/vaults/prov
 import { setScheduleEntitlementTool } from "mcpscraper-memory-tools/tools/schedule/set-schedule-entitlement";
 var MEMORY_BASE_URL = () => (process.env.MCP_MEMORY_BASE_URL ?? "https://memory.mcpscraper.dev").replace(/\/$/, "");
 var ADMIN_KEY = () => process.env.MCP_MEMORY_ADMIN_KEY?.trim() ?? "";
-function parseMemoryRpcBody(text) {
-  const dataLine = text.split("\n").find((line) => line.startsWith("data:"));
-  const payload = dataLine ? dataLine.slice(5).trim() : text;
+function parseMemoryRpcBody(text2) {
+  const dataLine = text2.split("\n").find((line) => line.startsWith("data:"));
+  const payload = dataLine ? dataLine.slice(5).trim() : text2;
   return JSON.parse(payload);
 }
 function isMemoryOperator(email) {
@@ -8559,9 +8567,9 @@ async function memoryCall(toolName, args, userMemoryKey) {
         params: { name: toolName, arguments: args }
       })
     });
-    const text = await res.text();
+    const text2 = await res.text();
     if (!res.ok) return { ok: false, error: `memory ${toolName} failed (${res.status})` };
-    const body = parseMemoryRpcBody(text);
+    const body = parseMemoryRpcBody(text2);
     if (body.error) return { ok: false, error: body.error.message ?? `memory ${toolName} failed` };
     if (body.result?.structuredContent) return body.result.structuredContent;
     const textContent = body.result?.content?.find((c) => c.type === "text")?.text;
@@ -8797,6 +8805,412 @@ internalBillingApp.post("/scheduled-run/void", async (c) => {
   }
 });
 
+// src/api/connected-usage-billing.ts
+import { createHash as createHash3, randomUUID as randomUUID2 } from "crypto";
+import { z as z11 } from "zod";
+var CONNECTED_USAGE_BILLING_CLASS = "connected_usage";
+var CONNECTED_USAGE_DEFAULT_SOURCE_SURFACE = "mastra_scheduler";
+var ConnectedUsageSafeMetadataSchema = z11.object({
+  toolName: z11.string().trim().min(1).max(200).optional(),
+  operationKind: z11.enum(["read", "action", "sync", "export", "proxy", "other"]).optional(),
+  outcome: z11.enum(["success", "error", "partial"]).optional(),
+  requestId: z11.string().trim().min(1).max(200).optional(),
+  occurrenceId: z11.string().trim().min(1).max(200).optional(),
+  scheduleId: z11.string().trim().min(1).max(200).optional(),
+  nangoOperationId: z11.string().trim().min(1).max(200).optional(),
+  startedAt: z11.string().datetime({ offset: true }).optional(),
+  completedAt: z11.string().datetime({ offset: true }).optional()
+}).strict();
+var ConnectedUsageSettlementInputSchema = z11.object({
+  identity: z11.string().trim().min(1).max(320),
+  idempotencyKey: z11.string().trim().min(1).max(500),
+  ratePolicyVersion: z11.string().trim().min(1).max(100),
+  connectionId: z11.string().trim().min(1).max(500),
+  providerConfigKey: z11.string().trim().min(1).max(200),
+  functionRuns: z11.number().int().safe().nonnegative(),
+  proxyRequests: z11.number().int().safe().nonnegative(),
+  computeMilliseconds: z11.number().int().safe().nonnegative(),
+  sourceSurface: z11.enum(["main_mcp", "mastra_scheduler", "nango_reconciliation"]).default(CONNECTED_USAGE_DEFAULT_SOURCE_SURFACE),
+  metadata: ConnectedUsageSafeMetadataSchema.optional()
+}).strict();
+var ConnectedUsagePreflightInputSchema = z11.object({
+  identity: z11.string().trim().min(1).max(320),
+  ratePolicyVersion: z11.string().trim().min(1).max(100)
+}).strict();
+var ConnectedUsageBillingError = class extends Error {
+  constructor(code, message, httpStatus, details = {}) {
+    super(message);
+    this.code = code;
+    this.httpStatus = httpStatus;
+    this.details = details;
+    this.name = "ConnectedUsageBillingError";
+  }
+  code;
+  httpStatus;
+  details;
+};
+function hash(value) {
+  return createHash3("sha256").update(value).digest("hex");
+}
+function eventKey(idempotencyKey) {
+  return `connected-usage:${hash(idempotencyKey)}`;
+}
+function debitKey(idempotencyKey) {
+  return `connected-usage-debit:${hash(idempotencyKey)}`;
+}
+function normalizeIdentity2(identity) {
+  return identity.trim().toLowerCase();
+}
+async function resolveUser(identity) {
+  const user = await getUserByEmail(normalizeIdentity2(identity));
+  if (!user) throw new ConnectedUsageBillingError("user_not_found", "billing identity was not found", 404);
+  return user;
+}
+function canonicalFingerprint(args) {
+  const metadata = {
+    toolName: args.metadata.toolName ?? null,
+    operationKind: args.metadata.operationKind ?? null,
+    outcome: args.metadata.outcome ?? null,
+    requestId: args.metadata.requestId ?? null,
+    occurrenceId: args.metadata.occurrenceId ?? null,
+    scheduleId: args.metadata.scheduleId ?? null,
+    nangoOperationId: args.metadata.nangoOperationId ?? null,
+    startedAt: args.metadata.startedAt ?? null,
+    completedAt: args.metadata.completedAt ?? null
+  };
+  return hash(JSON.stringify({
+    ratePolicyVersion: CONNECTED_USAGE_RATE_POLICY_VERSION,
+    connectionId: args.connectionId,
+    providerConfigKey: args.providerConfigKey,
+    usage: args.usage,
+    sourceSurface: args.sourceSurface,
+    metadata
+  }));
+}
+function encodeMetadata(metadata) {
+  const encoded = JSON.stringify(metadata);
+  if (encoded.length > 4e3) throw new ConnectedUsageBillingError("invalid_request", "connected usage metadata is too large", 400);
+  return encoded;
+}
+function decodeMetadata(row) {
+  try {
+    const parsed = JSON.parse(row.metadata ?? "");
+    if (parsed.contract !== "connected_usage_receipt" || parsed.ratePolicyVersion !== CONNECTED_USAGE_RATE_POLICY_VERSION || typeof parsed.fingerprint !== "string" || typeof parsed.connectionId !== "string" || typeof parsed.providerConfigKey !== "string" || !parsed.usage || !parsed.charge) {
+      throw new Error("invalid connected usage receipt metadata");
+    }
+    return parsed;
+  } catch {
+    throw new ConnectedUsageBillingError("idempotency_key_conflict", "the idempotency key is already bound to an incompatible billing receipt", 409);
+  }
+}
+async function readEvent(key) {
+  const result = await getDb().execute({
+    sql: "SELECT id, user_id, billing_class, source_surface, status, amount_mc, metadata FROM billing_events WHERE idempotency_key = ? LIMIT 1",
+    args: [key]
+  });
+  return result.rows[0] ? result.rows[0] : null;
+}
+async function hasOtherPendingReceipt(userId, excludingKey) {
+  const result = await getDb().execute({
+    sql: `SELECT 1
+          FROM billing_events
+          WHERE user_id = ?
+            AND billing_class = ?
+            AND status = 'cost_pending'
+            ${excludingKey ? "AND idempotency_key <> ?" : ""}
+          LIMIT 1`,
+    args: excludingKey ? [userId, CONNECTED_USAGE_BILLING_CLASS, excludingKey] : [userId, CONNECTED_USAGE_BILLING_CLASS]
+  });
+  return result.rows.length > 0;
+}
+function debitKeyFromEventKey(key) {
+  const prefix = "connected-usage:";
+  const digest = key.startsWith(prefix) ? key.slice(prefix.length) : "";
+  return /^[a-f0-9]{64}$/.test(digest) ? `connected-usage-debit:${digest}` : null;
+}
+async function retryPendingConnectedUsageReceipts(user) {
+  const result = await getDb().execute({
+    sql: `SELECT id, user_id, idempotency_key, billing_class, source_surface, status, amount_mc, metadata
+          FROM billing_events
+          WHERE user_id = ? AND billing_class = ? AND status = 'cost_pending'
+          ORDER BY created_at ASC
+          LIMIT 10`,
+    args: [user.id, CONNECTED_USAGE_BILLING_CLASS]
+  });
+  for (const raw of result.rows) {
+    const row = raw;
+    const key = String(row.idempotency_key ?? "");
+    const durableDebitKey = debitKeyFromEventKey(key);
+    let metadata;
+    try {
+      metadata = decodeMetadata(row);
+    } catch {
+      return;
+    }
+    if (!durableDebitKey || Number(row.user_id) !== user.id || row.billing_class !== CONNECTED_USAGE_BILLING_CLASS || Number(row.amount_mc) !== metadata.charge.amountMc) {
+      return;
+    }
+    if (metadata.charge.amountMc > 0) {
+      const debit = await debitMcIdempotent(
+        user.id,
+        metadata.charge.amountMc,
+        LedgerOperation.CONNECTED_USAGE,
+        `connected-usage:${metadata.providerConfigKey}`,
+        durableDebitKey
+      );
+      if (!debit.ok) return;
+    }
+    const settledMetadata = { ...metadata };
+    delete settledMetadata.reason;
+    await getDb().execute({
+      sql: `UPDATE billing_events
+            SET status = 'settled', metadata = ?, settled_at = datetime('now')
+            WHERE idempotency_key = ? AND user_id = ? AND billing_class = ? AND status = 'cost_pending'`,
+      args: [encodeMetadata(settledMetadata), key, user.id, CONNECTED_USAGE_BILLING_CLASS]
+    });
+  }
+}
+function assertRatePolicyVersion(ratePolicyVersion) {
+  if (ratePolicyVersion !== CONNECTED_USAGE_RATE_POLICY_VERSION) {
+    throw new ConnectedUsageBillingError(
+      "rate_policy_mismatch",
+      "connected usage receipt rate policy does not match the active policy",
+      409,
+      { expectedRatePolicyVersion: CONNECTED_USAGE_RATE_POLICY_VERSION }
+    );
+  }
+}
+async function preflightConnectedUsage(rawInput) {
+  const parsed = ConnectedUsagePreflightInputSchema.safeParse(rawInput);
+  if (!parsed.success) {
+    throw new ConnectedUsageBillingError("invalid_request", "invalid connected usage preflight request", 400);
+  }
+  assertRatePolicyVersion(parsed.data.ratePolicyVersion);
+  const user = await resolveUser(parsed.data.identity);
+  await retryPendingConnectedUsageReceipts(user);
+  if (await hasOtherPendingReceipt(user.id)) {
+    throw new ConnectedUsageBillingError(
+      "pending_cost",
+      "a previous connected usage receipt has unresolved cost",
+      409
+    );
+  }
+  const balanceMc = await reconcileBalanceMc(user.id, user.balance_mc);
+  if (balanceMc < CONNECTED_FUNCTION_RUN_MC) {
+    throw new ConnectedUsageBillingError(
+      "insufficient_credits",
+      "the wallet cannot cover the minimum connected function charge",
+      402,
+      { balanceMc, requiredMc: CONNECTED_FUNCTION_RUN_MC }
+    );
+  }
+  return {
+    allowed: true,
+    ratePolicyVersion: CONNECTED_USAGE_RATE_POLICY_VERSION,
+    minimumMc: CONNECTED_FUNCTION_RUN_MC,
+    minimumCredits: CONNECTED_FUNCTION_RUN_CREDITS,
+    balanceMc
+  };
+}
+function assertMatchingReceipt(row, userId, sourceSurface, fingerprint, amountMc) {
+  const metadata = decodeMetadata(row);
+  if (Number(row.user_id) !== userId || row.billing_class !== CONNECTED_USAGE_BILLING_CLASS || row.source_surface !== sourceSurface || Number(row.amount_mc) !== amountMc || metadata.fingerprint !== fingerprint) {
+    throw new ConnectedUsageBillingError("idempotency_key_conflict", "the idempotency key is already bound to different connected usage", 409);
+  }
+  return metadata;
+}
+function costBreakdown(usage, charge2) {
+  return [
+    {
+      key: "function_runs",
+      label: "Connected function runs",
+      quantity: usage.functionRuns,
+      quantityUnit: "function_run",
+      rateCredits: CONNECTED_FUNCTION_RUN_CREDITS,
+      rateUnit: "function_run",
+      amountMc: charge2.functionRunMc,
+      credits: charge2.functionRunMc / MC_PER_CREDIT
+    },
+    {
+      key: "proxy_requests",
+      label: "Connected proxy requests",
+      quantity: usage.proxyRequests,
+      quantityUnit: "proxy_request",
+      rateCredits: CONNECTED_PROXY_REQUEST_CREDITS,
+      rateUnit: "proxy_request",
+      amountMc: charge2.proxyRequestMc,
+      credits: charge2.proxyRequestMc / MC_PER_CREDIT
+    },
+    {
+      key: "compute",
+      label: "Connected function compute",
+      quantity: usage.computeMilliseconds,
+      quantityUnit: "millisecond",
+      rateCredits: CONNECTED_COMPUTE_CREDITS_PER_SECOND,
+      rateUnit: "compute_second",
+      amountMc: charge2.computeMc,
+      credits: charge2.computeMc / MC_PER_CREDIT
+    }
+  ];
+}
+function mapSettlement(row, metadata, balanceMc, duplicate) {
+  const reason = row.status === "cost_pending" ? metadata.reason : void 0;
+  return {
+    id: row.id,
+    status: row.status === "settled" ? "settled" : "cost_pending",
+    ratePolicyVersion: CONNECTED_USAGE_RATE_POLICY_VERSION,
+    connectionId: metadata.connectionId,
+    providerConfigKey: metadata.providerConfigKey,
+    amountMc: metadata.charge.amountMc,
+    credits: metadata.charge.credits,
+    functionRunMc: metadata.charge.functionRunMc,
+    proxyRequestMc: metadata.charge.proxyRequestMc,
+    computeMc: metadata.charge.computeMc,
+    usage: metadata.usage,
+    costBreakdown: costBreakdown(metadata.usage, metadata.charge),
+    balanceMc,
+    ...reason ? { reason } : {},
+    duplicate
+  };
+}
+async function settleConnectedUsage(rawInput) {
+  const parsed = ConnectedUsageSettlementInputSchema.safeParse(rawInput);
+  if (!parsed.success) {
+    throw new ConnectedUsageBillingError(
+      "invalid_request",
+      "invalid connected usage settlement request",
+      400,
+      { fields: [...new Set(parsed.error.issues.map((issue) => issue.path.join(".")).filter(Boolean))] }
+    );
+  }
+  const input = parsed.data;
+  assertRatePolicyVersion(input.ratePolicyVersion);
+  const user = await resolveUser(input.identity);
+  const usage = {
+    functionRuns: input.functionRuns,
+    proxyRequests: input.proxyRequests,
+    computeMilliseconds: input.computeMilliseconds
+  };
+  const charge2 = calculateConnectedUsageCharge(usage);
+  const safeMetadata3 = input.metadata ?? {};
+  const fingerprint = canonicalFingerprint({
+    connectionId: input.connectionId,
+    providerConfigKey: input.providerConfigKey,
+    usage,
+    sourceSurface: input.sourceSurface,
+    metadata: safeMetadata3
+  });
+  const storedMetadata = {
+    contract: "connected_usage_receipt",
+    ratePolicyVersion: CONNECTED_USAGE_RATE_POLICY_VERSION,
+    fingerprint,
+    connectionId: input.connectionId,
+    providerConfigKey: input.providerConfigKey,
+    usage,
+    charge: charge2,
+    safeMetadata: safeMetadata3
+  };
+  const key = eventKey(input.idempotencyKey);
+  if (await hasOtherPendingReceipt(user.id, key)) {
+    throw new ConnectedUsageBillingError(
+      "pending_cost",
+      "a previous connected usage receipt has unresolved cost",
+      409
+    );
+  }
+  const inserted = await getDb().execute({
+    sql: `INSERT OR IGNORE INTO billing_events
+            (id, user_id, idempotency_key, billing_class, source_surface, status, amount_mc, metadata)
+          VALUES (?, ?, ?, ?, ?, 'settling', ?, ?)`,
+    args: [randomUUID2(), user.id, key, CONNECTED_USAGE_BILLING_CLASS, input.sourceSurface, charge2.amountMc, encodeMetadata(storedMetadata)]
+  });
+  let event = await readEvent(key);
+  if (!event) throw new Error("connected usage receipt insert completed without a readable event");
+  let eventMetadata = assertMatchingReceipt(event, user.id, input.sourceSurface, fingerprint, charge2.amountMc);
+  const duplicate = inserted.rowsAffected === 0;
+  if (event.status === "settled") {
+    return mapSettlement(event, eventMetadata, await reconcileBalanceMc(user.id, user.balance_mc), true);
+  }
+  if (!["settling", "cost_pending"].includes(event.status)) {
+    throw new ConnectedUsageBillingError("idempotency_key_conflict", "the connected usage receipt has an incompatible status", 409);
+  }
+  if (event.status === "cost_pending") {
+    await getDb().execute({
+      sql: "UPDATE billing_events SET status = 'settling', metadata = ? WHERE idempotency_key = ? AND status = 'cost_pending'",
+      args: [encodeMetadata(storedMetadata), key]
+    });
+  }
+  if (charge2.amountMc === 0) {
+    await getDb().execute({
+      sql: "UPDATE billing_events SET status = 'settled', settled_at = datetime('now') WHERE idempotency_key = ? AND status = 'settling'",
+      args: [key]
+    });
+  } else {
+    const debit = await debitMcIdempotent(
+      user.id,
+      charge2.amountMc,
+      LedgerOperation.CONNECTED_USAGE,
+      `connected-usage:${input.providerConfigKey}`,
+      debitKey(input.idempotencyKey)
+    );
+    if (!debit.ok) {
+      const pendingMetadata = { ...storedMetadata, reason: "insufficient_credits" };
+      await getDb().execute({
+        sql: "UPDATE billing_events SET status = 'cost_pending', metadata = ? WHERE idempotency_key = ? AND status = 'settling'",
+        args: [encodeMetadata(pendingMetadata), key]
+      });
+      event = await readEvent(key);
+      if (!event) throw new Error("connected usage pending receipt was lost");
+      eventMetadata = assertMatchingReceipt(event, user.id, input.sourceSurface, fingerprint, charge2.amountMc);
+      return mapSettlement(event, eventMetadata, debit.balance_mc, duplicate || debit.duplicate);
+    }
+    await getDb().execute({
+      sql: "UPDATE billing_events SET status = 'settled', metadata = ?, settled_at = datetime('now') WHERE idempotency_key = ? AND status IN ('settling', 'cost_pending')",
+      args: [encodeMetadata(storedMetadata), key]
+    });
+  }
+  event = await readEvent(key);
+  if (!event) throw new Error("connected usage settlement completed without an event receipt");
+  eventMetadata = assertMatchingReceipt(event, user.id, input.sourceSurface, fingerprint, charge2.amountMc);
+  return mapSettlement(
+    event,
+    eventMetadata,
+    await reconcileBalanceMc(user.id, user.balance_mc),
+    duplicate
+  );
+}
+async function listConnectedUsageHistory(userId, limit = 100) {
+  const result = await getDb().execute({
+    sql: `SELECT id, user_id, billing_class, source_surface, status, amount_mc, metadata, created_at
+          FROM billing_events
+          WHERE user_id = ? AND billing_class = ? AND status IN ('settled', 'cost_pending')
+          ORDER BY created_at DESC
+          LIMIT ?`,
+    args: [userId, CONNECTED_USAGE_BILLING_CLASS, Math.max(1, Math.min(250, Math.round(limit)))]
+  });
+  const history = [];
+  for (const raw of result.rows) {
+    const row = raw;
+    try {
+      const receipt = decodeMetadata(row);
+      history.push({
+        id: row.id,
+        createdAt: String(row.created_at ?? ""),
+        status: row.status === "settled" ? "settled" : "cost_pending",
+        connectionId: receipt.connectionId,
+        providerConfigKey: receipt.providerConfigKey,
+        amountMc: receipt.charge.amountMc,
+        credits: receipt.charge.credits,
+        usage: receipt.usage,
+        costBreakdown: costBreakdown(receipt.usage, receipt.charge),
+        metadata: receipt.safeMetadata
+      });
+    } catch {
+    }
+  }
+  return history;
+}
+
 // src/api/youtube-routes.ts
 import { Hono as Hono4 } from "hono";
 
@@ -8806,17 +9220,17 @@ import path4 from "path";
 import Papa from "papaparse";
 
 // src/youtube/schemas.ts
-import { z as z11 } from "zod";
-var YouTubeHarvestOptionsSchema = z11.object({
-  mode: z11.enum(["search", "channel"]),
-  query: z11.string().optional(),
-  channelHandle: z11.string().optional(),
-  maxVideos: z11.number().int().min(1).max(5e3).default(100),
-  downloadMp3: z11.boolean().default(false),
-  outputDir: z11.string().default("./yt-output"),
-  kernelApiKey: z11.string().optional(),
-  kernelProxyId: z11.string().optional(),
-  headless: z11.boolean().default(false)
+import { z as z12 } from "zod";
+var YouTubeHarvestOptionsSchema = z12.object({
+  mode: z12.enum(["search", "channel"]),
+  query: z12.string().optional(),
+  channelHandle: z12.string().optional(),
+  maxVideos: z12.number().int().min(1).max(5e3).default(100),
+  downloadMp3: z12.boolean().default(false),
+  outputDir: z12.string().default("./yt-output"),
+  kernelApiKey: z12.string().optional(),
+  kernelProxyId: z12.string().optional(),
+  headless: z12.boolean().default(false)
 }).refine(
   (o) => o.mode === "search" ? !!o.query : !!o.channelHandle,
   { message: "search mode requires query; channel mode requires channelHandle" }
@@ -9357,14 +9771,14 @@ async function fetchViaYoutubeTranscript(videoId) {
       timestamp: [e.offset / 1e3, (e.offset + e.duration) / 1e3],
       text: e.text.trim()
     }));
-    const text = chunks.map((c) => c.text).join(" ");
+    const text2 = chunks.map((c) => c.text).join(" ");
     const last = chunks[chunks.length - 1];
     const now = Date.now();
     await runWithCostContext(
       { ...currentCostContext(), op: "yt_transcription", subOp: "youtube-transcript" },
       () => recordKernelSession({ kernelSessionId: null, source: "yt_caption_tier", headlessSent: null, openedAtMs: now, closedAtMs: now })
     );
-    return { videoId, text, chunks, durationMs: last ? last.timestamp[1] * 1e3 : 0, method: "youtube-transcript" };
+    return { videoId, text: text2, chunks, durationMs: last ? last.timestamp[1] * 1e3 : 0, method: "youtube-transcript" };
   } catch {
     return null;
   }
@@ -9379,12 +9793,12 @@ function parseTimedtextJson3(jsonText) {
   const results = [];
   for (const ev of data.events ?? []) {
     if (!ev.segs) continue;
-    const text = ev.segs.map((s) => s.utf8 ?? "").join("").replace(/\s+/g, " ").trim();
-    if (!text) continue;
+    const text2 = ev.segs.map((s) => s.utf8 ?? "").join("").replace(/\s+/g, " ").trim();
+    if (!text2) continue;
     const start = typeof ev.tStartMs === "number" ? ev.tStartMs : NaN;
     const dur = typeof ev.dDurationMs === "number" ? ev.dDurationMs : 0;
     if (!Number.isFinite(start)) continue;
-    results.push({ start, dur, text });
+    results.push({ start, dur, text: text2 });
   }
   return results;
 }
@@ -9396,22 +9810,22 @@ function parseTimedtextXml(xml) {
     const startMs = parseInt(m[1], 10);
     const durMs = parseInt(m[2], 10);
     const inner = m[3];
-    let text = inner.replace(/<[^>]+>/g, "").trim();
-    if (!text) {
+    let text2 = inner.replace(/<[^>]+>/g, "").trim();
+    if (!text2) {
       const sMatch = /<s[^>]*>([^<]*)<\/s>/g;
       let sm;
       const parts = [];
       while ((sm = sMatch.exec(inner)) !== null) parts.push(sm[1]);
-      text = parts.join("").trim();
+      text2 = parts.join("").trim();
     }
-    text = text.replace(/&amp;/g, "&").replace(/&lt;/g, "<").replace(/&gt;/g, ">").replace(/&quot;/g, '"').replace(/&#39;/g, "'");
-    if (text) results.push({ start: startMs, dur: durMs, text });
+    text2 = text2.replace(/&amp;/g, "&").replace(/&lt;/g, "<").replace(/&gt;/g, ">").replace(/&quot;/g, '"').replace(/&#39;/g, "'");
+    if (text2) results.push({ start: startMs, dur: durMs, text: text2 });
   }
   if (results.length > 0) return results;
   const classicRegex = /<text start="([^"]*)" dur="([^"]*)">([^<]*)<\/text>/g;
   while ((m = classicRegex.exec(xml)) !== null) {
-    const text = m[3].replace(/&amp;/g, "&").replace(/&lt;/g, "<").replace(/&gt;/g, ">").replace(/&quot;/g, '"').replace(/&#39;/g, "'");
-    results.push({ start: parseFloat(m[1]) * 1e3, dur: parseFloat(m[2]) * 1e3, text });
+    const text2 = m[3].replace(/&amp;/g, "&").replace(/&lt;/g, "<").replace(/&gt;/g, ">").replace(/&quot;/g, '"').replace(/&#39;/g, "'");
+    results.push({ start: parseFloat(m[1]) * 1e3, dur: parseFloat(m[2]) * 1e3, text: text2 });
   }
   return results;
 }
@@ -9536,8 +9950,8 @@ async function fetchViaKernelSession(videoId) {
     timestamp: [e.start / 1e3, (e.start + e.dur) / 1e3],
     text: e.text
   }));
-  const text = chunks.map((c) => c.text).join(" ");
-  return { videoId, text, chunks, durationMs: Date.now() - start, method: "browser-innertube" };
+  const text2 = chunks.map((c) => c.text).join(" ");
+  return { videoId, text: text2, chunks, durationMs: Date.now() - start, method: "browser-innertube" };
 }
 async function fetchViaResolvedAudio(videoId) {
   if (!mediaResolverConfigured()) return null;
@@ -9602,68 +10016,68 @@ function createApiKeyAuth() {
 }
 
 // src/api/server-schemas.ts
-import { z as z12 } from "zod";
-var HarvestBodySchema = z12.object({
-  query: z12.string().min(1, "query is required"),
-  location: z12.string().optional(),
-  depth: z12.number().int().min(1).max(4).optional(),
-  maxQuestions: z12.number().int().min(1).optional(),
-  callback_url: z12.string().url().optional(),
-  gl: z12.string().optional(),
-  hl: z12.string().optional(),
-  device: z12.enum(["desktop", "mobile"]).optional(),
-  proxyMode: z12.enum(["location", "configured", "none"]).optional(),
-  proxyZip: z12.string().regex(/^\d{5}$/).optional(),
-  debug: z12.boolean().optional(),
-  serpOnly: z12.boolean().optional(),
-  pages: z12.number().int().min(1).max(2).optional()
-});
-var ExtractUrlBodySchema = z12.object({
-  url: z12.string().min(1, "url is required"),
-  screenshot: z12.boolean().optional(),
-  screenshotDevice: z12.enum(["desktop", "mobile"]).optional(),
-  extractBranding: z12.boolean().optional(),
-  downloadMedia: z12.boolean().optional(),
-  mediaTypes: z12.array(z12.enum(["image", "video", "audio"])).optional(),
-  allowLocal: z12.boolean().optional(),
-  depositToVault: z12.boolean().optional(),
-  vaultName: z12.string().trim().min(1).max(120).optional()
-});
-var DiffPageBodySchema = z12.object({
-  url: z12.string().min(1, "url is required"),
-  allowLocal: z12.boolean().optional(),
-  resetBaseline: z12.boolean().optional()
-});
-var MapUrlsBodySchema = z12.object({
-  url: z12.string().min(1, "url is required"),
-  maxUrls: z12.number().int().min(1).max(2e3).optional(),
-  concurrency: z12.number().int().min(1).max(20).optional(),
-  browserFallback: z12.boolean().optional(),
-  kernelFallback: z12.boolean().optional()
-});
-var ExtractSiteBodySchema = z12.object({
-  url: z12.string().min(1, "url is required"),
-  maxPages: z12.number().int().min(1).max(1e4).optional(),
-  browserFallback: z12.boolean().optional(),
-  kernelFallback: z12.boolean().optional(),
-  rotateProxies: z12.boolean().optional(),
-  rotateProxyEvery: z12.number().int().min(1).max(100).optional(),
-  background: z12.boolean().optional(),
-  downloadImages: z12.boolean().optional(),
-  formats: z12.array(z12.enum(["markdown", "links", "json", "images", "branding", "issues"])).optional()
-});
-var YoutubeHarvestBodySchema = z12.object({
-  mode: z12.enum(["search", "channel"]),
-  query: z12.string().optional(),
-  channelHandle: z12.string().optional(),
-  maxVideos: z12.number().int().min(1).max(500).optional()
-});
-var YoutubeTranscribeBodySchema = z12.object({
-  videoId: z12.string().min(1, "videoId is required")
+import { z as z13 } from "zod";
+var HarvestBodySchema = z13.object({
+  query: z13.string().min(1, "query is required"),
+  location: z13.string().optional(),
+  depth: z13.number().int().min(1).max(4).optional(),
+  maxQuestions: z13.number().int().min(1).optional(),
+  callback_url: z13.string().url().optional(),
+  gl: z13.string().optional(),
+  hl: z13.string().optional(),
+  device: z13.enum(["desktop", "mobile"]).optional(),
+  proxyMode: z13.enum(["location", "configured", "none"]).optional(),
+  proxyZip: z13.string().regex(/^\d{5}$/).optional(),
+  debug: z13.boolean().optional(),
+  serpOnly: z13.boolean().optional(),
+  pages: z13.number().int().min(1).max(2).optional()
+});
+var ExtractUrlBodySchema = z13.object({
+  url: z13.string().min(1, "url is required"),
+  screenshot: z13.boolean().optional(),
+  screenshotDevice: z13.enum(["desktop", "mobile"]).optional(),
+  extractBranding: z13.boolean().optional(),
+  downloadMedia: z13.boolean().optional(),
+  mediaTypes: z13.array(z13.enum(["image", "video", "audio"])).optional(),
+  allowLocal: z13.boolean().optional(),
+  depositToVault: z13.boolean().optional(),
+  vaultName: z13.string().trim().min(1).max(120).optional()
+});
+var DiffPageBodySchema = z13.object({
+  url: z13.string().min(1, "url is required"),
+  allowLocal: z13.boolean().optional(),
+  resetBaseline: z13.boolean().optional()
+});
+var MapUrlsBodySchema = z13.object({
+  url: z13.string().min(1, "url is required"),
+  maxUrls: z13.number().int().min(1).max(2e3).optional(),
+  concurrency: z13.number().int().min(1).max(20).optional(),
+  browserFallback: z13.boolean().optional(),
+  kernelFallback: z13.boolean().optional()
+});
+var ExtractSiteBodySchema = z13.object({
+  url: z13.string().min(1, "url is required"),
+  maxPages: z13.number().int().min(1).max(1e4).optional(),
+  browserFallback: z13.boolean().optional(),
+  kernelFallback: z13.boolean().optional(),
+  rotateProxies: z13.boolean().optional(),
+  rotateProxyEvery: z13.number().int().min(1).max(100).optional(),
+  background: z13.boolean().optional(),
+  downloadImages: z13.boolean().optional(),
+  formats: z13.array(z13.enum(["markdown", "links", "json", "images", "branding", "issues"])).optional()
+});
+var YoutubeHarvestBodySchema = z13.object({
+  mode: z13.enum(["search", "channel"]),
+  query: z13.string().optional(),
+  channelHandle: z13.string().optional(),
+  maxVideos: z13.number().int().min(1).max(500).optional()
+});
+var YoutubeTranscribeBodySchema = z13.object({
+  videoId: z13.string().min(1, "videoId is required")
 });
 
 // src/api/concurrency-gates.ts
-import { randomUUID as randomUUID2 } from "crypto";
+import { randomUUID as randomUUID3 } from "crypto";
 var DEFAULT_LOCK_TTL_SECONDS = 15 * 60;
 var DEFAULT_RETRY_AFTER_SECONDS = 30;
 var MAX_LOCK_TTL_SECONDS = 24 * 60 * 60;
@@ -9781,7 +10195,7 @@ async function acquireConcurrencyGate(user, operation, options = {}) {
     return { ok: true, lockId: null, active: await countActiveUsageForUser(user.id), limit, operation, reused: true };
   }
   await expireConcurrencyLocksForUser(user.id);
-  const lockId = `cl_${randomUUID2().replace(/-/g, "").slice(0, 24)}`;
+  const lockId = `cl_${randomUUID3().replace(/-/g, "").slice(0, 24)}`;
   const res = await getDb().execute({
     sql: `INSERT INTO concurrency_locks (id, user_id, operation, status, expires_at, metadata)
           SELECT ?, ?, ?, 'active', datetime('now', ?), ?
@@ -9997,11 +10411,11 @@ function fmtTs(secs) {
 
 // src/api/screenshot-routes.ts
 import { Hono as Hono5 } from "hono";
-import { z as z13 } from "zod";
-var ScreenshotBodySchema = z13.object({
-  url: z13.string().trim().min(1, "url is required"),
-  device: z13.string().trim().optional(),
-  allowLocal: z13.boolean().optional()
+import { z as z14 } from "zod";
+var ScreenshotBodySchema = z14.object({
+  url: z14.string().trim().min(1, "url is required"),
+  device: z14.string().trim().optional(),
+  allowLocal: z14.boolean().optional()
 });
 var screenshotApp = new Hono5();
 screenshotApp.use("*", createApiKeyAuth());
@@ -10061,7 +10475,7 @@ screenshotApp.post("/", async (c) => {
 
 // src/api/facebook-ad-routes.ts
 import { Hono as Hono6 } from "hono";
-import { z as z14 } from "zod";
+import { z as z15 } from "zod";
 
 // src/extractor/FacebookAdExtractor.ts
 var SPRITE_Y_TO_PLATFORM = {
@@ -10733,9 +11147,9 @@ var FacebookAdExtractor = class {
 
 // src/extractor/FacebookAdGraphql.ts
 var AD_LIBRARY_QUERY = "AdLibrarySearchPaginationQuery";
-function parseFbGraphqlJson(text) {
+function parseFbGraphqlJson(text2) {
   const out = [];
-  const body = text.replace(/^for\s*\(;;\);/, "").trim();
+  const body = text2.replace(/^for\s*\(;;\);/, "").trim();
   try {
     out.push(JSON.parse(body));
     return out;
@@ -10783,8 +11197,8 @@ async function collectAdLibraryResults(page, url, maxResults, opts = {}) {
     if (!resp.url().includes("/api/graphql")) return;
     const friendlyName = (resp.request().postData() ?? "").match(/fb_api_req_friendly_name=([^&]+)/)?.[1];
     if (friendlyName !== AD_LIBRARY_QUERY) return;
-    void resp.text().then((text) => {
-      for (const payload of parseFbGraphqlJson(text)) {
+    void resp.text().then((text2) => {
+      for (const payload of parseFbGraphqlJson(text2)) {
         for (const result of extractCollatedResults(payload)) {
           if (seen.has(result.ad_archive_id)) continue;
           seen.add(result.ad_archive_id);
@@ -10954,35 +11368,35 @@ async function extractFacebookOrganicVideoFromPage(page, sourceUrl, quality = "b
 
 // src/api/facebook-ad-routes.ts
 import { fal } from "@fal-ai/client";
-var FacebookAdBodySchema = z14.object({
-  url: z14.string().trim().optional(),
-  libraryId: z14.string().trim().optional(),
-  openModal: z14.boolean().optional()
+var FacebookAdBodySchema = z15.object({
+  url: z15.string().trim().optional(),
+  libraryId: z15.string().trim().optional(),
+  openModal: z15.boolean().optional()
 }).refine((d) => !!d.url || !!d.libraryId, { message: "url or libraryId is required" });
-var FacebookPageIntelBodySchema = z14.object({
-  pageId: z14.string().trim().optional(),
-  query: z14.string().trim().optional(),
-  libraryId: z14.string().trim().optional(),
-  maxAds: z14.number().int().min(1).max(200).optional(),
-  country: z14.string().trim().toUpperCase().optional()
+var FacebookPageIntelBodySchema = z15.object({
+  pageId: z15.string().trim().optional(),
+  query: z15.string().trim().optional(),
+  libraryId: z15.string().trim().optional(),
+  maxAds: z15.number().int().min(1).max(200).optional(),
+  country: z15.string().trim().toUpperCase().optional()
 }).refine((d) => !!d.pageId || !!d.query || !!d.libraryId, {
   message: "pageId, libraryId, or query is required"
 });
-var FacebookTranscribeBodySchema = z14.object({
-  videoUrl: z14.string().trim().min(1, "videoUrl is required")
+var FacebookTranscribeBodySchema = z15.object({
+  videoUrl: z15.string().trim().min(1, "videoUrl is required")
 });
-var FacebookVideoTranscribeBodySchema = z14.object({
-  url: z14.string().trim().min(1, "url is required"),
-  quality: z14.enum(["best", "hd", "sd"]).default("best")
+var FacebookVideoTranscribeBodySchema = z15.object({
+  url: z15.string().trim().min(1, "url is required"),
+  quality: z15.enum(["best", "hd", "sd"]).default("best")
 });
-var FacebookSearchBodySchema = z14.object({
-  query: z14.string().trim().min(1, "query is required"),
-  country: z14.string().trim().toUpperCase().optional(),
-  maxResults: z14.number().int().min(1).max(20).optional()
+var FacebookSearchBodySchema = z15.object({
+  query: z15.string().trim().min(1, "query is required"),
+  country: z15.string().trim().toUpperCase().optional(),
+  maxResults: z15.number().int().min(1).max(20).optional()
 });
-var FacebookMediaBodySchema = z14.object({
-  url: z14.string().trim().min(1, "url is required"),
-  filename: z14.string().trim().optional()
+var FacebookMediaBodySchema = z15.object({
+  url: z15.string().trim().min(1, "url is required"),
+  filename: z15.string().trim().optional()
 });
 function invalidRequest(message) {
   return { error_code: "invalid_request", message };
@@ -11416,7 +11830,7 @@ facebookAdApp.post("/media", createApiKeyAuth(), async (c) => {
 
 // src/api/google-ads-routes.ts
 import { Hono as Hono7 } from "hono";
-import { z as z15 } from "zod";
+import { z as z16 } from "zod";
 
 // src/extractor/GoogleAdsExtractor.ts
 var ORIGIN = "https://adstransparency.google.com";
@@ -11586,19 +12000,19 @@ var GoogleAdsExtractor = class {
 
 // src/api/google-ads-routes.ts
 import { fal as fal2 } from "@fal-ai/client";
-var GoogleAdsSearchBodySchema = z15.object({
-  query: z15.string().trim().min(1, "query is required"),
-  region: z15.string().trim().toUpperCase().length(2).optional(),
-  maxResults: z15.number().int().min(1).max(20).optional()
-});
-var GoogleAdsPageIntelBodySchema = z15.object({
-  advertiserId: z15.string().trim().optional(),
-  domain: z15.string().trim().optional(),
-  region: z15.string().trim().toUpperCase().length(2).optional(),
-  maxAds: z15.number().int().min(1).max(200).optional()
+var GoogleAdsSearchBodySchema = z16.object({
+  query: z16.string().trim().min(1, "query is required"),
+  region: z16.string().trim().toUpperCase().length(2).optional(),
+  maxResults: z16.number().int().min(1).max(20).optional()
+});
+var GoogleAdsPageIntelBodySchema = z16.object({
+  advertiserId: z16.string().trim().optional(),
+  domain: z16.string().trim().optional(),
+  region: z16.string().trim().toUpperCase().length(2).optional(),
+  maxAds: z16.number().int().min(1).max(200).optional()
 }).refine((d) => !!d.advertiserId || !!d.domain, { message: "advertiserId or domain is required" });
-var GoogleAdsTranscribeBodySchema = z15.object({
-  videoUrl: z15.string().trim().min(1, "videoUrl is required")
+var GoogleAdsTranscribeBodySchema = z16.object({
+  videoUrl: z16.string().trim().min(1, "videoUrl is required")
 });
 function invalidRequest2(message) {
   return { error_code: "invalid_request", message };
@@ -11741,7 +12155,7 @@ googleAdsApp.post("/transcribe", createApiKeyAuth(), async (c) => {
 
 // src/api/instagram-routes.ts
 import { Hono as Hono8 } from "hono";
-import { z as z16 } from "zod";
+import { z as z17 } from "zod";
 import { mkdtempSync, readFileSync as readFileSync2, rmSync, writeFileSync } from "fs";
 import { tmpdir } from "os";
 import { join as join3 } from "path";
@@ -11832,7 +12246,7 @@ function trackFromUrl(url) {
     height: typeof parsed?.height === "number" ? parsed.height : null
   };
 }
-function extractInstagramMp4UrlsFromText(text) {
+function extractInstagramMp4UrlsFromText(text2) {
   const urls = [];
   const seen = /* @__PURE__ */ new Set();
   const patterns = [
@@ -11841,7 +12255,7 @@ function extractInstagramMp4UrlsFromText(text) {
   ];
   for (const pattern of patterns) {
     let match;
-    while ((match = pattern.exec(text)) !== null) {
+    while ((match = pattern.exec(text2)) !== null) {
       const normalized = normalizeInstagramMediaUrl(match[0].replace(/%5C/gi, "\\"));
       if (!normalized || seen.has(normalized)) continue;
       seen.add(normalized);
@@ -11871,9 +12285,9 @@ function selectInstagramTracks(tracks) {
   const selectedAudioTrack = tracks.filter((track) => track.streamType === "audio").sort((a, b) => (b.bitrate ?? 0) - (a.bitrate ?? 0))[0] ?? null;
   return { selectedVideoTrack, selectedAudioTrack };
 }
-function parseCount(text) {
-  if (!text) return null;
-  const match = text.match(/([\d,.]+)\s*posts?/i);
+function parseCount(text2) {
+  if (!text2) return null;
+  const match = text2.match(/([\d,.]+)\s*posts?/i);
   if (!match) return null;
   const value = Number(match[1].replace(/[,.]/g, ""));
   return Number.isFinite(value) ? value : null;
@@ -11932,8 +12346,8 @@ async function collectInstagramProfileContentFromPage(page, opts) {
     return items.length - before;
   };
   const readBodyText = async () => page.evaluate(() => document.body?.innerText ?? "").catch(() => "");
-  const profileLines = (text) => text.split("\n").map((line) => line.trim()).filter(Boolean);
-  const profilePostCountText = (text) => profileLines(text).find((line) => /\bposts?\b/i.test(line) && /[\d,.]/.test(line)) ?? null;
+  const profileLines = (text2) => text2.split("\n").map((line) => line.trim()).filter(Boolean);
+  const profilePostCountText = (text2) => profileLines(text2).find((line) => /\bposts?\b/i.test(line) && /[\d,.]/.test(line)) ?? null;
   const scrollMetrics = async () => page.evaluate(() => ({
     scrollY: typeof window.scrollY === "number" ? window.scrollY : null,
     scrollHeight: Math.max(
@@ -12103,30 +12517,30 @@ async function extractInstagramMediaFromPage(page, sourceUrl, capturedMediaUrls
 }
 
 // src/api/instagram-routes.ts
-var InstagramProfileContentBodySchema = z16.object({
-  handle: z16.string().trim().optional(),
-  url: z16.string().trim().optional(),
-  profile: z16.string().trim().min(1).optional(),
-  saveProfileChanges: z16.boolean().optional(),
-  save_profile_changes: z16.boolean().optional(),
-  maxItems: z16.number().int().min(1).max(2e3).default(50),
-  maxScrolls: z16.number().int().min(0).max(250).default(10),
-  scrollDelayMs: z16.number().int().min(250).max(5e3).default(1200),
-  stableScrollLimit: z16.number().int().min(1).max(10).default(4)
+var InstagramProfileContentBodySchema = z17.object({
+  handle: z17.string().trim().optional(),
+  url: z17.string().trim().optional(),
+  profile: z17.string().trim().min(1).optional(),
+  saveProfileChanges: z17.boolean().optional(),
+  save_profile_changes: z17.boolean().optional(),
+  maxItems: z17.number().int().min(1).max(2e3).default(50),
+  maxScrolls: z17.number().int().min(0).max(250).default(10),
+  scrollDelayMs: z17.number().int().min(250).max(5e3).default(1200),
+  stableScrollLimit: z17.number().int().min(1).max(10).default(4)
 }).refine((d) => !!d.handle || !!d.url, {
   message: "handle or url is required"
 });
-var InstagramMediaTypeSchema = z16.enum(["image", "video", "audio"]);
-var InstagramMediaDownloadBodySchema = z16.object({
-  url: z16.string().trim().min(1, "url is required"),
-  profile: z16.string().trim().min(1).optional(),
-  saveProfileChanges: z16.boolean().optional(),
-  save_profile_changes: z16.boolean().optional(),
-  mediaTypes: z16.array(InstagramMediaTypeSchema).default(["image", "video", "audio"]),
-  downloadMedia: z16.boolean().default(true),
-  downloadAllTracks: z16.boolean().default(false),
-  includeTranscript: z16.boolean().default(false),
-  mux: z16.boolean().default(true)
+var InstagramMediaTypeSchema = z17.enum(["image", "video", "audio"]);
+var InstagramMediaDownloadBodySchema = z17.object({
+  url: z17.string().trim().min(1, "url is required"),
+  profile: z17.string().trim().min(1).optional(),
+  saveProfileChanges: z17.boolean().optional(),
+  save_profile_changes: z17.boolean().optional(),
+  mediaTypes: z17.array(InstagramMediaTypeSchema).default(["image", "video", "audio"]),
+  downloadMedia: z17.boolean().default(true),
+  downloadAllTracks: z17.boolean().default(false),
+  includeTranscript: z17.boolean().default(false),
+  mux: z17.boolean().default(true)
 });
 var instagramApp = new Hono8();
 function invalidRequest3(message) {
@@ -12409,10 +12823,10 @@ instagramApp.post("/media-download", createApiKeyAuth(), async (c) => {
 
 // src/api/reddit-routes.ts
 import { Hono as Hono9 } from "hono";
-import { z as z17 } from "zod";
-var RedditThreadBodySchema = z17.object({
-  url: z17.string().trim().min(1, "url is required"),
-  maxComments: z17.number().int().min(1).max(2e3).optional()
+import { z as z18 } from "zod";
+var RedditThreadBodySchema = z18.object({
+  url: z18.string().trim().min(1, "url is required"),
+  maxComments: z18.number().int().min(1).max(2e3).optional()
 });
 function invalidRequest4(message) {
   return { error_code: "invalid_request", message };
@@ -12551,14 +12965,14 @@ redditApp.post("/thread", createApiKeyAuth(), async (c) => {
 
 // src/api/video-routes.ts
 import { Hono as Hono10 } from "hono";
-import { z as z18 } from "zod";
+import { z as z19 } from "zod";
 var videoApp = new Hono10();
-var AnalyzeBodySchema = z18.object({
-  sourceUrl: z18.string().trim().url("sourceUrl must be a direct video file URL"),
-  intervalS: z18.number().min(1).max(30).optional(),
-  maxFrames: z18.number().int().min(1).max(480).optional(),
-  detail: z18.enum(["fast", "standard", "deep"]).optional(),
-  vault: z18.string().trim().min(1).optional()
+var AnalyzeBodySchema = z19.object({
+  sourceUrl: z19.string().trim().url("sourceUrl must be a direct video file URL"),
+  intervalS: z19.number().min(1).max(30).optional(),
+  maxFrames: z19.number().int().min(1).max(480).optional(),
+  detail: z19.enum(["fast", "standard", "deep"]).optional(),
+  vault: z19.string().trim().min(1).optional()
 });
 function invalidRequest5(message) {
   return { error_code: "invalid_request", message };
@@ -12864,7 +13278,7 @@ var MapsReviewCollector = class {
 };
 
 // src/extractor/MapsExtractor.ts
-import { z as z19 } from "zod";
+import { z as z20 } from "zod";
 var MapsExtractor = class {
   constructor(driver) {
     this.driver = driver;
@@ -13072,7 +13486,7 @@ var MapsExtractor = class {
       });
       return rows;
     }, { hoursTable: MapsSelectors.hoursTable, hoursTableAlt: MapsSelectors.hoursTableAlt });
-    const result = z19.array(RawMapsHoursRowSchema).safeParse(raw);
+    const result = z20.array(RawMapsHoursRowSchema).safeParse(raw);
     if (!result.success) {
       console.warn("[MapsExtractor] hours parse failed", result.error.flatten());
       return [];
@@ -13118,25 +13532,25 @@ var MapsExtractor = class {
         if (el2.tagName === "H2") {
           currentSection = el2.innerText?.trim() || currentSection;
         } else if (el2.tagName === "LI") {
-          const text = el2.innerText?.replace(/^[\s\S]*?\n/, "").trim();
-          const key = `${currentSection}|${text}`;
-          if (text && !seen.has(key)) {
+          const text2 = el2.innerText?.replace(/^[\s\S]*?\n/, "").trim();
+          const key = `${currentSection}|${text2}`;
+          if (text2 && !seen.has(key)) {
             seen.add(key);
-            results.push({ section: currentSection, attribute: text });
+            results.push({ section: currentSection, attribute: text2 });
           }
         }
       });
       main.querySelectorAll('[href*="businessownership"], [data-item-id^="place-info-links:"]').forEach((el2) => {
-        const text = el2.innerText?.trim();
-        const key = `Ownership|${text}`;
-        if (text && !seen.has(key)) {
+        const text2 = el2.innerText?.trim();
+        const key = `Ownership|${text2}`;
+        if (text2 && !seen.has(key)) {
           seen.add(key);
-          results.push({ section: "Ownership", attribute: text });
+          results.push({ section: "Ownership", attribute: text2 });
         }
       });
       return results;
     });
-    const result = z19.array(RawMapsAboutAttributeSchema).safeParse(raw);
+    const result = z20.array(RawMapsAboutAttributeSchema).safeParse(raw);
     if (!result.success) {
       console.warn("[MapsExtractor] about parse failed", result.error.flatten());
       return [];
@@ -13196,13 +13610,13 @@ var MapsExtractor = class {
       const items = [];
       withHeading.querySelectorAll("*").forEach((el2) => {
         if (el2.children.length > 0) return;
-        const text = el2.innerText?.trim() ?? el2.textContent?.trim() ?? "";
-        if (!text || headingLines.has(text)) return;
-        if (/^(back|close|done|thanks)$/i.test(text)) return;
-        if (/^serves\s.*following/i.test(text)) return;
-        if (seen.has(text)) return;
-        seen.add(text);
-        items.push(text);
+        const text2 = el2.innerText?.trim() ?? el2.textContent?.trim() ?? "";
+        if (!text2 || headingLines.has(text2)) return;
+        if (/^(back|close|done|thanks)$/i.test(text2)) return;
+        if (/^serves\s.*following/i.test(text2)) return;
+        if (seen.has(text2)) return;
+        seen.add(text2);
+        items.push(text2);
       });
       return items;
     }, expectedHeading);
@@ -13268,8 +13682,8 @@ var MapsSearchExtractor = class {
   }
   async detectBlock(page) {
     return page.evaluate(() => {
-      const text = document.body.innerText.slice(0, 2e3);
-      return /unusual traffic|captcha|recaptcha|about this page/i.test(text) || /\/sorry\//.test(location.href);
+      const text2 = document.body.innerText.slice(0, 2e3);
+      return /unusual traffic|captcha|recaptcha|about this page/i.test(text2) || /\/sorry\//.test(location.href);
     });
   }
   async collectResults(page, maxResults) {
@@ -13306,8 +13720,8 @@ var MapsSearchExtractor = class {
   async extractVisibleResults(page) {
     return page.evaluate(() => {
       function normalizeText(value) {
-        const text = value?.replace(/\s+/g, " ").trim() ?? "";
-        return text || null;
+        const text2 = value?.replace(/\s+/g, " ").trim() ?? "";
+        return text2 || null;
       }
       function cidFromUrl(url) {
         const fid = url.match(/!1s(0x[0-9a-f]+):(0x[0-9a-f]+)/i);
@@ -13323,8 +13737,8 @@ var MapsSearchExtractor = class {
         if (!card) return [];
         const parts = [];
         card.querySelectorAll("div, span").forEach((el2) => {
-          const text = Array.from(el2.childNodes).filter((node) => node.nodeType === 3).map((node) => node.textContent?.trim() ?? "").filter((text2) => text2.length > 1 && text2.length < 140).join(" ");
-          if (text && !parts.includes(text)) parts.push(text);
+          const text2 = Array.from(el2.childNodes).filter((node) => node.nodeType === 3).map((node) => node.textContent?.trim() ?? "").filter((text3) => text3.length > 1 && text3.length < 140).join(" ");
+          if (text2 && !parts.includes(text2)) parts.push(text2);
         });
         return parts;
       }
@@ -13726,10 +14140,10 @@ mapsApp.post("/place", createApiKeyAuth(), async (c) => {
 
 // src/api/trustpilot-routes.ts
 import { Hono as Hono12 } from "hono";
-import { z as z20 } from "zod";
-var TrustpilotReviewsBodySchema = z20.object({
-  domain: z20.string().trim().min(1, "domain is required"),
-  maxPages: z20.number().int().min(1).max(50).default(5)
+import { z as z21 } from "zod";
+var TrustpilotReviewsBodySchema = z21.object({
+  domain: z21.string().trim().min(1, "domain is required"),
+  maxPages: z21.number().int().min(1).max(50).default(5)
 });
 function invalidRequest6(message) {
   return { error_code: "invalid_request", message };
@@ -13876,10 +14290,10 @@ trustpilotApp.post("/reviews", createApiKeyAuth(), async (c) => {
 
 // src/api/g2-routes.ts
 import { Hono as Hono13 } from "hono";
-import { z as z21 } from "zod";
-var G2ReviewsBodySchema = z21.object({
-  product: z21.string().trim().min(1, "product is required"),
-  maxPages: z21.number().int().min(1).max(50).default(5)
+import { z as z22 } from "zod";
+var G2ReviewsBodySchema = z22.object({
+  product: z22.string().trim().min(1, "product is required"),
+  maxPages: z22.number().int().min(1).max(50).default(5)
 });
 function invalidRequest7(message) {
   return { error_code: "invalid_request", message };
@@ -14086,7 +14500,7 @@ import { Hono as Hono14 } from "hono";
 // src/directory/directory-workflow.ts
 import { mkdir as mkdir2, writeFile } from "fs/promises";
 import { join as join4 } from "path";
-import { z as z22 } from "zod";
+import { z as z23 } from "zod";
 
 // src/directory/location-db.ts
 import { access, readFile } from "fs/promises";
@@ -14247,24 +14661,24 @@ async function resolveDirectoryMarkets(options) {
 }
 
 // src/directory/directory-workflow.ts
-var DirectoryWorkflowOptionsSchema = z22.object({
-  query: z22.string().min(1),
-  state: z22.string().min(2).default("TN"),
-  minPopulation: z22.number().int().min(0).default(1e5),
-  populationYear: z22.union(POPULATION_YEARS.map((year) => z22.literal(year))).default(2025),
-  maxCities: z22.number().int().min(1).max(100).default(25),
-  maxResultsPerCity: z22.number().int().min(1).max(50).default(50),
-  concurrency: z22.number().int().min(1).max(5).default(5),
-  includeZipGroups: z22.boolean().default(true),
-  usZipsCsvPath: z22.string().optional(),
-  saveCsv: z22.boolean().default(true),
-  gl: z22.string().length(2).default("us"),
-  hl: z22.string().length(2).default("en"),
-  proxyMode: z22.enum(["location", "configured", "none"]).default(DEFAULT_MAPS_PROXY_MODE),
-  proxyZip: z22.string().regex(/^\d{5}$/).optional(),
-  debug: z22.boolean().default(false),
-  headless: z22.boolean().default(true),
-  kernelApiKey: z22.string().optional()
+var DirectoryWorkflowOptionsSchema = z23.object({
+  query: z23.string().min(1),
+  state: z23.string().min(2).default("TN"),
+  minPopulation: z23.number().int().min(0).default(1e5),
+  populationYear: z23.union(POPULATION_YEARS.map((year) => z23.literal(year))).default(2025),
+  maxCities: z23.number().int().min(1).max(100).default(25),
+  maxResultsPerCity: z23.number().int().min(1).max(50).default(50),
+  concurrency: z23.number().int().min(1).max(5).default(5),
+  includeZipGroups: z23.boolean().default(true),
+  usZipsCsvPath: z23.string().optional(),
+  saveCsv: z23.boolean().default(true),
+  gl: z23.string().length(2).default("us"),
+  hl: z23.string().length(2).default("en"),
+  proxyMode: z23.enum(["location", "configured", "none"]).default(DEFAULT_MAPS_PROXY_MODE),
+  proxyZip: z23.string().regex(/^\d{5}$/).optional(),
+  debug: z23.boolean().default(false),
+  headless: z23.boolean().default(true),
+  kernelApiKey: z23.string().optional()
 });
 function errorMessage(err) {
   return err instanceof Error ? err.message : String(err);
@@ -14559,34 +14973,34 @@ directoryApp.post("/run", createApiKeyAuth(), async (c) => {
 import { createHmac as createHmac3 } from "crypto";
 import { readFile as readFile2 } from "fs/promises";
 import { Hono as Hono15 } from "hono";
-import { z as z23 } from "zod";
+import { z as z24 } from "zod";
 var workflowApp = new Hono15();
-var WorkflowInputSchema = z23.record(z23.unknown()).default({});
-var WorkflowIdSchema = z23.string().min(1);
-var CadenceSchema = z23.enum(["daily", "weekly", "monthly"]);
-var ScheduleStatusSchema = z23.enum(["active", "paused"]);
-var RunBodySchema = z23.object({
+var WorkflowInputSchema = z24.record(z24.unknown()).default({});
+var WorkflowIdSchema = z24.string().min(1);
+var CadenceSchema = z24.enum(["daily", "weekly", "monthly"]);
+var ScheduleStatusSchema = z24.enum(["active", "paused"]);
+var RunBodySchema = z24.object({
   workflowId: WorkflowIdSchema,
   input: WorkflowInputSchema,
-  webhookUrl: z23.string().url().optional()
+  webhookUrl: z24.string().url().optional()
 });
-var ScheduleCreateSchema = z23.object({
+var ScheduleCreateSchema = z24.object({
   workflowId: WorkflowIdSchema,
-  name: z23.string().min(1).max(120).optional(),
+  name: z24.string().min(1).max(120).optional(),
   input: WorkflowInputSchema,
   cadence: CadenceSchema.default("weekly"),
-  timezone: z23.string().min(1).max(64).default("UTC"),
-  webhookUrl: z23.string().url().optional(),
-  nextRunAt: z23.string().datetime().optional()
+  timezone: z24.string().min(1).max(64).default("UTC"),
+  webhookUrl: z24.string().url().optional(),
+  nextRunAt: z24.string().datetime().optional()
 });
-var SchedulePatchSchema = z23.object({
-  name: z23.string().min(1).max(120).optional(),
+var SchedulePatchSchema = z24.object({
+  name: z24.string().min(1).max(120).optional(),
   status: ScheduleStatusSchema.optional(),
   input: WorkflowInputSchema.optional(),
   cadence: CadenceSchema.optional(),
-  timezone: z23.string().min(1).max(64).optional(),
-  webhookUrl: z23.string().url().nullable().optional(),
-  nextRunAt: z23.string().datetime().nullable().optional()
+  timezone: z24.string().min(1).max(64).optional(),
+  webhookUrl: z24.string().url().nullable().optional(),
+  nextRunAt: z24.string().datetime().nullable().optional()
 });
 function hostedWorkflowOutputDir() {
   return workflowOutputBaseDir(process.env.MCP_SCRAPER_WORKFLOW_OUTPUT_DIR?.trim() || "/tmp/mcp-scraper-workflows");
@@ -15091,17 +15505,17 @@ workflowApp.post("/cron/dispatch", async (c) => {
 
 // src/api/serp-intelligence-routes.ts
 import { Hono as Hono16 } from "hono";
-import { createHash as createHash4, randomUUID as randomUUID3 } from "crypto";
+import { createHash as createHash5, randomUUID as randomUUID4 } from "crypto";
 
 // src/serp-intelligence/page-snapshot-extractor.ts
-import { createHash as createHash3 } from "crypto";
+import { createHash as createHash4 } from "crypto";
 import pLimit3 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 createHash3("sha256").update(value).digest("hex");
+  return createHash4("sha256").update(value).digest("hex");
 }
 function countWords(markdown) {
   const matches = markdown.trim().match(/\b[\p{L}\p{N}][\p{L}\p{N}'-]*\b/gu);
@@ -15274,10 +15688,10 @@ async function capturePageSnapshot(target, options = {}) {
     const completedAtDate = /* @__PURE__ */ new Date();
     const completedAt = completedAtDate.toISOString();
     const durationMs = completedAtDate.getTime() - startedAtDate.getTime();
-    const text = stripMarkdown(extraction.bodyMarkdown);
+    const text2 = stripMarkdown(extraction.bodyMarkdown);
     const htmlContent = truncateContent(extraction.bodyHtml, maxContentChars);
     const markdownContent = truncateContent(extraction.bodyMarkdown, maxContentChars);
-    const textContent = truncateContent(text, maxContentChars);
+    const textContent = truncateContent(text2, maxContentChars);
     const schemaTypes = getSchemaTypes(extraction.schema, extraction.kpo.schemaTypes);
     const metrics = countLinks(extraction.bodyHtml, extraction.url);
     const wordCount = countWords(extraction.bodyMarkdown);
@@ -15342,7 +15756,7 @@ async function capturePageSnapshot(target, options = {}) {
       hashes: {
         htmlSha256: sha256(extraction.bodyHtml),
         markdownSha256: contentSha256,
-        textSha256: sha256(text)
+        textSha256: sha256(text2)
       },
       diagnostics,
       ...contentIncluded ? {
@@ -15403,7 +15817,7 @@ async function capturePageSnapshots(targets, options = {}) {
 }
 
 // src/serp-intelligence/schemas.ts
-import { z as z24 } from "zod";
+import { z as z25 } from "zod";
 var SerpIntelligenceDeviceValues = ["desktop", "mobile"];
 var SerpIntelligenceProxyModeValues = ["location", "configured", "none"];
 var SerpIntelligenceAttemptOutcomeValues = [
@@ -15465,181 +15879,181 @@ function isPublicHttpUrl(value) {
     return false;
   }
 }
-var SerpIntelligencePublicHttpUrlSchema = z24.string().url().refine(isPublicHttpUrl, "url must be a public HTTP or HTTPS URL");
-var SerpIntelligenceCaptureBodySchema = z24.object({
-  query: z24.string().trim().min(1, "query is required"),
-  location: z24.string().trim().min(1).optional(),
-  gl: z24.string().trim().length(2).default("us"),
-  hl: z24.string().trim().length(2).default("en"),
-  device: z24.enum(SerpIntelligenceDeviceValues).default("desktop"),
-  proxyMode: z24.enum(SerpIntelligenceProxyModeValues).default(DEFAULT_PROXY_MODE),
-  proxyZip: z24.string().regex(/^\d{5}$/).optional(),
-  pages: z24.number().int().min(1).max(2).default(1),
-  debug: z24.boolean().default(false),
-  includePageSnapshots: z24.boolean().default(false),
-  pageSnapshotLimit: z24.number().int().min(0).max(10).default(0)
+var SerpIntelligencePublicHttpUrlSchema = z25.string().url().refine(isPublicHttpUrl, "url must be a public HTTP or HTTPS URL");
+var SerpIntelligenceCaptureBodySchema = z25.object({
+  query: z25.string().trim().min(1, "query is required"),
+  location: z25.string().trim().min(1).optional(),
+  gl: z25.string().trim().length(2).default("us"),
+  hl: z25.string().trim().length(2).default("en"),
+  device: z25.enum(SerpIntelligenceDeviceValues).default("desktop"),
+  proxyMode: z25.enum(SerpIntelligenceProxyModeValues).default(DEFAULT_PROXY_MODE),
+  proxyZip: z25.string().regex(/^\d{5}$/).optional(),
+  pages: z25.number().int().min(1).max(2).default(1),
+  debug: z25.boolean().default(false),
+  includePageSnapshots: z25.boolean().default(false),
+  pageSnapshotLimit: z25.number().int().min(0).max(10).default(0)
 }).strict();
-var SerpIntelligencePageSnapshotRequestSchema = z24.object({
+var SerpIntelligencePageSnapshotRequestSchema = z25.object({
   url: SerpIntelligencePublicHttpUrlSchema,
-  sourceKind: z24.enum(SerpPageSnapshotSourceKindValues).default("configured_target"),
-  sourcePosition: z24.number().int().min(1).optional()
+  sourceKind: z25.enum(SerpPageSnapshotSourceKindValues).default("configured_target"),
+  sourcePosition: z25.number().int().min(1).optional()
 }).strict();
-var SerpIntelligencePageSnapshotsBodySchema = z24.object({
-  urls: z24.array(SerpIntelligencePublicHttpUrlSchema).min(1).max(25).optional(),
-  targets: z24.array(SerpIntelligencePageSnapshotRequestSchema).min(1).max(25).optional(),
-  maxConcurrency: z24.number().int().min(1).max(5).default(2),
-  timeoutMs: z24.number().int().min(1e3).max(6e4).default(15e3),
-  debug: z24.boolean().default(false)
+var SerpIntelligencePageSnapshotsBodySchema = z25.object({
+  urls: z25.array(SerpIntelligencePublicHttpUrlSchema).min(1).max(25).optional(),
+  targets: z25.array(SerpIntelligencePageSnapshotRequestSchema).min(1).max(25).optional(),
+  maxConcurrency: z25.number().int().min(1).max(5).default(2),
+  timeoutMs: z25.number().int().min(1e3).max(6e4).default(15e3),
+  debug: z25.boolean().default(false)
 }).strict().superRefine((body, ctx) => {
   const hasUrls = Boolean(body.urls?.length);
   const hasTargets = Boolean(body.targets?.length);
   if (hasUrls === hasTargets) {
     ctx.addIssue({
-      code: z24.ZodIssueCode.custom,
+      code: z25.ZodIssueCode.custom,
       message: "provide exactly one of urls or targets",
       path: hasUrls ? ["targets"] : ["urls"]
     });
   }
 });
-var SerpIntelligenceAICitationSchema = z24.object({
-  text: z24.string(),
-  href: z24.string()
+var SerpIntelligenceAICitationSchema = z25.object({
+  text: z25.string(),
+  href: z25.string()
 }).strict();
-var SerpIntelligenceOrganicResultSchema = z24.object({
-  position: z24.number().int().min(1),
-  title: z24.string(),
-  url: z24.string(),
-  domain: z24.string(),
-  cite: z24.string().nullable(),
-  snippet: z24.string().nullable(),
-  isRedditStyle: z24.boolean(),
-  inlineRating: z24.object({
-    value: z24.string(),
-    count: z24.string()
+var SerpIntelligenceOrganicResultSchema = z25.object({
+  position: z25.number().int().min(1),
+  title: z25.string(),
+  url: z25.string(),
+  domain: z25.string(),
+  cite: z25.string().nullable(),
+  snippet: z25.string().nullable(),
+  isRedditStyle: z25.boolean(),
+  inlineRating: z25.object({
+    value: z25.string(),
+    count: z25.string()
   }).strict().nullable()
 }).strict();
-var SerpIntelligenceLocationEvidenceSchema = z24.object({
-  status: z24.enum(SerpIntelligenceLocalizationStatusValues),
-  expected: z24.object({
-    city: z24.string(),
-    regionCode: z24.string().nullable(),
-    canonicalLocation: z24.string()
+var SerpIntelligenceLocationEvidenceSchema = z25.object({
+  status: z25.enum(SerpIntelligenceLocalizationStatusValues),
+  expected: z25.object({
+    city: z25.string(),
+    regionCode: z25.string().nullable(),
+    canonicalLocation: z25.string()
   }).strict().nullable(),
-  candidates: z24.array(z24.object({
-    city: z24.string(),
-    regionCode: z24.string(),
-    count: z24.number().int().min(0),
-    examples: z24.array(z24.string())
+  candidates: z25.array(z25.object({
+    city: z25.string(),
+    regionCode: z25.string(),
+    count: z25.number().int().min(0),
+    examples: z25.array(z25.string())
   }).strict())
 }).strict();
-var SerpIntelligenceHarvestResultSchema = z24.object({
-  seed: z24.string(),
-  location: z24.string().nullable(),
-  extractedAt: z24.string(),
-  totalQuestions: z24.number().int().min(0),
-  surface: z24.enum(["web", "aim", "unknown"]),
-  aiOverview: z24.object({
-    detected: z24.boolean(),
-    text: z24.string().nullable(),
-    citations: z24.array(SerpIntelligenceAICitationSchema),
-    expanded: z24.boolean().optional(),
-    fullyExpanded: z24.boolean().optional(),
-    sections: z24.array(z24.string()).optional()
+var SerpIntelligenceHarvestResultSchema = z25.object({
+  seed: z25.string(),
+  location: z25.string().nullable(),
+  extractedAt: z25.string(),
+  totalQuestions: z25.number().int().min(0),
+  surface: z25.enum(["web", "aim", "unknown"]),
+  aiOverview: z25.object({
+    detected: z25.boolean(),
+    text: z25.string().nullable(),
+    citations: z25.array(SerpIntelligenceAICitationSchema),
+    expanded: z25.boolean().optional(),
+    fullyExpanded: z25.boolean().optional(),
+    sections: z25.array(z25.string()).optional()
   }).strict(),
-  aiMode: z24.object({
-    detected: z24.boolean(),
-    text: z24.string().nullable(),
-    citations: z24.array(SerpIntelligenceAICitationSchema)
+  aiMode: z25.object({
+    detected: z25.boolean(),
+    text: z25.string().nullable(),
+    citations: z25.array(SerpIntelligenceAICitationSchema)
   }).strict(),
-  tree: z24.array(z24.unknown()),
-  flat: z24.array(z24.unknown()),
-  videos: z24.array(z24.unknown()),
-  forums: z24.array(z24.unknown()),
-  organicResults: z24.array(SerpIntelligenceOrganicResultSchema),
-  localPack: z24.array(z24.unknown()),
-  entityIds: z24.object({
-    entities: z24.array(z24.object({
-      name: z24.string(),
-      kgId: z24.string().nullable(),
-      cid: z24.string().nullable(),
-      gcid: z24.string().nullable()
+  tree: z25.array(z25.unknown()),
+  flat: z25.array(z25.unknown()),
+  videos: z25.array(z25.unknown()),
+  forums: z25.array(z25.unknown()),
+  organicResults: z25.array(SerpIntelligenceOrganicResultSchema),
+  localPack: z25.array(z25.unknown()),
+  entityIds: z25.object({
+    entities: z25.array(z25.object({
+      name: z25.string(),
+      kgId: z25.string().nullable(),
+      cid: z25.string().nullable(),
+      gcid: z25.string().nullable()
     }).strict()),
-    kgIds: z24.array(z24.string()),
-    cids: z24.array(z24.string()),
-    gcids: z24.array(z24.string())
+    kgIds: z25.array(z25.string()),
+    cids: z25.array(z25.string()),
+    gcids: z25.array(z25.string())
   }).strict(),
-  stats: z24.object({
-    seed: z24.string(),
-    totalQuestions: z24.number().int().min(0),
-    maxDepthReached: z24.number().int().min(0),
-    durationMs: z24.number().min(0),
-    errorCount: z24.number().int().min(0)
+  stats: z25.object({
+    seed: z25.string(),
+    totalQuestions: z25.number().int().min(0),
+    maxDepthReached: z25.number().int().min(0),
+    durationMs: z25.number().min(0),
+    errorCount: z25.number().int().min(0)
   }).strict(),
-  diagnostics: z24.object({
-    completionStatus: z24.enum(["paa_found", "no_paa", "serp_only"]),
-    problem: z24.null(),
-    warnings: z24.array(z24.unknown()).optional(),
-    debug: z24.object({
+  diagnostics: z25.object({
+    completionStatus: z25.enum(["paa_found", "no_paa", "serp_only"]),
+    problem: z25.null(),
+    warnings: z25.array(z25.unknown()).optional(),
+    debug: z25.object({
       locationEvidence: SerpIntelligenceLocationEvidenceSchema.optional()
     }).passthrough().optional()
   }).passthrough(),
-  whatPeopleSaying: z24.array(z24.unknown())
+  whatPeopleSaying: z25.array(z25.unknown())
 }).strict();
-var SerpIntelligenceCaptureAttemptSchema = z24.object({
-  attemptNumber: z24.number().int().min(1),
-  outcome: z24.enum(SerpIntelligenceAttemptOutcomeValues),
-  startedAt: z24.string().optional(),
-  completedAt: z24.string().optional(),
-  durationMs: z24.number().min(0).optional(),
-  problemCode: z24.string().optional(),
-  message: z24.string().optional(),
-  kernelSessionId: z24.string().nullable().optional(),
-  cleanupSucceeded: z24.boolean().nullable().optional()
+var SerpIntelligenceCaptureAttemptSchema = z25.object({
+  attemptNumber: z25.number().int().min(1),
+  outcome: z25.enum(SerpIntelligenceAttemptOutcomeValues),
+  startedAt: z25.string().optional(),
+  completedAt: z25.string().optional(),
+  durationMs: z25.number().min(0).optional(),
+  problemCode: z25.string().optional(),
+  message: z25.string().optional(),
+  kernelSessionId: z25.string().nullable().optional(),
+  cleanupSucceeded: z25.boolean().nullable().optional()
 }).strict();
-var SerpPageSnapshotCaptureSchema = z24.object({
+var SerpPageSnapshotCaptureSchema = z25.object({
   url: SerpIntelligencePublicHttpUrlSchema,
   requestedUrl: SerpIntelligencePublicHttpUrlSchema,
   finalUrl: SerpIntelligencePublicHttpUrlSchema.nullable(),
-  sourceKind: z24.enum(SerpPageSnapshotSourceKindValues),
-  sourcePosition: z24.number().int().min(1).nullable(),
-  status: z24.enum(SerpPageFetchStatusValues),
-  fetchedVia: z24.enum(SerpPageFetchedViaValues).nullable(),
-  httpStatus: z24.number().int().min(100).max(599).nullable(),
-  contentType: z24.string().nullable(),
-  title: z24.string().nullable(),
+  sourceKind: z25.enum(SerpPageSnapshotSourceKindValues),
+  sourcePosition: z25.number().int().min(1).nullable(),
+  status: z25.enum(SerpPageFetchStatusValues),
+  fetchedVia: z25.enum(SerpPageFetchedViaValues).nullable(),
+  httpStatus: z25.number().int().min(100).max(599).nullable(),
+  contentType: z25.string().nullable(),
+  title: z25.string().nullable(),
   canonicalUrl: SerpIntelligencePublicHttpUrlSchema.nullable(),
-  metaDescription: z24.string().nullable(),
-  headings: z24.array(z24.object({
-    level: z24.number().int().min(1).max(6),
-    text: z24.string()
+  metaDescription: z25.string().nullable(),
+  headings: z25.array(z25.object({
+    level: z25.number().int().min(1).max(6),
+    text: z25.string()
   }).strict()).default([]),
-  artifact: z24.object({
-    htmlBlobUrl: z24.string().url().nullable(),
-    textBlobUrl: z24.string().url().nullable(),
-    markdownBlobUrl: z24.string().url().nullable(),
-    screenshotBlobUrl: z24.string().url().nullable(),
-    contentSha256: z24.string().nullable(),
-    capturedAt: z24.string().nullable()
+  artifact: z25.object({
+    htmlBlobUrl: z25.string().url().nullable(),
+    textBlobUrl: z25.string().url().nullable(),
+    markdownBlobUrl: z25.string().url().nullable(),
+    screenshotBlobUrl: z25.string().url().nullable(),
+    contentSha256: z25.string().nullable(),
+    capturedAt: z25.string().nullable()
   }).strict(),
-  error: z24.object({
-    code: z24.string(),
-    message: z24.string()
+  error: z25.object({
+    code: z25.string(),
+    message: z25.string()
   }).strict().nullable()
 }).strict();
-var SerpIntelligenceCaptureResponseSchema = z24.object({
+var SerpIntelligenceCaptureResponseSchema = z25.object({
   harvestResult: SerpIntelligenceHarvestResultSchema,
-  attempts: z24.array(SerpIntelligenceCaptureAttemptSchema),
+  attempts: z25.array(SerpIntelligenceCaptureAttemptSchema),
   locationEvidence: SerpIntelligenceLocationEvidenceSchema.nullable(),
-  pageSnapshotArtifacts: z24.array(SerpPageSnapshotCaptureSchema),
-  billing: z24.object({
-    creditsUsed: z24.number().min(0).optional(),
-    requestId: z24.string().optional(),
-    jobId: z24.string().optional()
+  pageSnapshotArtifacts: z25.array(SerpPageSnapshotCaptureSchema),
+  billing: z25.object({
+    creditsUsed: z25.number().min(0).optional(),
+    requestId: z25.string().optional(),
+    jobId: z25.string().optional()
   }).strict().optional()
 }).strict();
-var SerpIntelligencePageSnapshotsResponseSchema = z24.object({
-  pageSnapshotArtifacts: z24.array(SerpPageSnapshotCaptureSchema),
-  attempts: z24.array(SerpIntelligenceCaptureAttemptSchema).default([])
+var SerpIntelligencePageSnapshotsResponseSchema = z25.object({
+  pageSnapshotArtifacts: z25.array(SerpPageSnapshotCaptureSchema),
+  attempts: z25.array(SerpIntelligenceCaptureAttemptSchema).default([])
 }).strict();
 
 // src/serp-intelligence/serp-capture-service.ts
@@ -15875,9 +16289,9 @@ async function logRequestEventBestEffort(input) {
   }
 }
 function captureBillingKeys(userId, suppliedKey, body) {
-  const responseKey = suppliedKey?.trim() || randomUUID3();
-  const requestFingerprint = createHash4("sha256").update(JSON.stringify(body)).digest("hex");
-  const keyDigest = createHash4("sha256").update(String(userId)).update("\0").update(responseKey).digest("hex");
+  const responseKey = suppliedKey?.trim() || randomUUID4();
+  const requestFingerprint = createHash5("sha256").update(JSON.stringify(body)).digest("hex");
+  const keyDigest = createHash5("sha256").update(String(userId)).update("\0").update(responseKey).digest("hex");
   return {
     responseKey,
     debitKey: `serp-capture:${userId}:${keyDigest}`,
@@ -16729,11 +17143,11 @@ mcpApp.all("/", async (c) => {
 });
 
 // src/api/browser-agent-routes.ts
-import { randomUUID as randomUUID5 } from "crypto";
+import { randomUUID as randomUUID6 } from "crypto";
 import { Hono as Hono18 } from "hono";
 
 // src/api/browser-agent-db.ts
-import { randomUUID as randomUUID4 } from "crypto";
+import { randomUUID as randomUUID5 } from "crypto";
 var _ready = false;
 var _migrationPromise = null;
 async function migrateBrowserAgent() {
@@ -16864,7 +17278,7 @@ async function runBrowserAgentMigration() {
 }
 async function createExtensionRow(input) {
   const db = getDb();
-  const id = `bext_${randomUUID4().replace(/-/g, "").slice(0, 20)}`;
+  const id = `bext_${randomUUID5().replace(/-/g, "").slice(0, 20)}`;
   await db.execute({
     sql: `INSERT INTO browser_agent_extensions (id, user_id, name, backend_id, backend_name, source, source_url, size_bytes)
           VALUES (?, ?, ?, ?, ?, ?, ?, ?)`,
@@ -16899,7 +17313,7 @@ async function deleteExtensionRow(userId, name) {
 }
 async function createAuthConnectionRow(input) {
   const db = getDb();
-  const connectionId = `authc_${randomUUID4().replace(/-/g, "").slice(0, 20)}`;
+  const connectionId = `authc_${randomUUID5().replace(/-/g, "").slice(0, 20)}`;
   await db.execute({
     sql: `INSERT INTO browser_auth_connections (connection_id, domain, profile, account_email, note, status, browser_agent_session_id)
           VALUES (?, ?, ?, ?, ?, 'NEEDS_AUTH', ?)`,
@@ -16933,7 +17347,7 @@ async function listAuthConnectionsByProfile(profile) {
 }
 async function createSessionRow(input) {
   const db = getDb();
-  const id = `bas_${randomUUID4().replace(/-/g, "").slice(0, 20)}`;
+  const id = `bas_${randomUUID5().replace(/-/g, "").slice(0, 20)}`;
   await db.execute({
     sql: `INSERT INTO browser_agent_sessions (id, runtime_session_id, live_view_url, cdp_ws_url, status, label, user_id, concurrency_lock_id, last_action_at)
           VALUES (?, ?, ?, ?, 'open', ?, ?, ?, datetime('now'))`,
@@ -17002,7 +17416,7 @@ async function recordAction(input) {
     sql: `INSERT INTO browser_agent_actions (id, session_id, type, params_json, ok, error)
           VALUES (?, ?, ?, ?, ?, ?)`,
     args: [
-      `baa_${randomUUID4().replace(/-/g, "").slice(0, 20)}`,
+      `baa_${randomUUID5().replace(/-/g, "").slice(0, 20)}`,
       input.sessionId,
       input.type,
       input.params == null ? null : JSON.stringify(input.params),
@@ -17122,9 +17536,9 @@ var FanoutCdpCapture = class {
     const ct = this.ctById.get(requestId) || "";
     const client2 = this.client;
     const p = client2.send("Network.getResponseBody", { requestId }).then((r) => {
-      const text = r.base64Encoded ? Buffer.from(String(r.body), "base64").toString("utf8") : String(r.body || "");
-      if (text) {
-        this.bodies.push({ url, ct, text });
+      const text2 = r.base64Encoded ? Buffer.from(String(r.body), "base64").toString("utf8") : String(r.body || "");
+      if (text2) {
+        this.bodies.push({ url, ct, text: text2 });
         if (this.isAnswerUrl(url)) this.answerStreams++;
       }
     }).catch(() => void 0);
@@ -17168,14 +17582,14 @@ function unesc(s) {
 function stripCitationMarkers(s) {
   return String(s || "").replace(/[-]/g, "").replace(/cite(?:turn\d+\w+?\d+)+/g, "").replace(/\s+/g, " ").trim();
 }
-function sliceBalanced(text, openIdx) {
-  const open = text[openIdx];
+function sliceBalanced(text2, openIdx) {
+  const open = text2[openIdx];
   const close = open === "[" ? "]" : "}";
   let depth = 0;
   let inStr = false;
   let esc = false;
-  for (let i = openIdx; i < text.length; i++) {
-    const ch = text[i];
+  for (let i = openIdx; i < text2.length; i++) {
+    const ch = text2[i];
     if (inStr) {
       if (esc) esc = false;
       else if (ch === "\\") esc = true;
@@ -17189,18 +17603,18 @@ function sliceBalanced(text, openIdx) {
     if (ch === open) depth++;
     else if (ch === close) {
       depth--;
-      if (depth === 0) return text.slice(openIdx, i + 1);
+      if (depth === 0) return text2.slice(openIdx, i + 1);
     }
   }
   return null;
 }
-function findJsonValues(text, field) {
+function findJsonValues(text2, field) {
   const out = [];
   const re = new RegExp('"' + field + '"\\s*:\\s*(\\[|\\{)', "g");
   let m;
-  while (m = re.exec(text)) {
+  while (m = re.exec(text2)) {
     const openIdx = m.index + m[0].length - 1;
-    const slice = sliceBalanced(text, openIdx);
+    const slice = sliceBalanced(text2, openIdx);
     if (slice) {
       try {
         out.push(JSON.parse(slice));
@@ -17334,8 +17748,8 @@ var chatgptAdapter = {
       }
       return s;
     };
-    const addSnippet = (url, title, text) => {
-      const clean2 = stripCitationMarkers(text);
+    const addSnippet = (url, title, text2) => {
+      const clean2 = stripCitationMarkers(text2);
       if (!isExternal(url) || clean2.length < 2) return;
       snippets.set(normUrl(url), { url, domain: domainOf(url), title: title || domainOf(url), text: clean2.slice(0, 400) });
     };
@@ -17685,7 +18099,7 @@ var COMPOSER_SELECTORS = [
   'div[contenteditable="true"]',
   "textarea"
 ];
-async function sendPrompt(page, text) {
+async function sendPrompt(page, text2) {
   for (const selector of COMPOSER_SELECTORS) {
     const locator = page.locator(selector).first();
     try {
@@ -17695,7 +18109,7 @@ async function sendPrompt(page, text) {
     }
     await locator.click({ timeout: 4e3 }).catch(() => void 0);
     await locator.focus().catch(() => void 0);
-    await page.keyboard.type(text, { delay: 12 });
+    await page.keyboard.type(text2, { delay: 12 });
     await page.waitForTimeout(300).catch(() => void 0);
     await page.keyboard.press("Enter");
     return true;
@@ -17729,9 +18143,9 @@ async function runFanoutCapture(page, input) {
     if (!adapter) {
       throw new Error(`query_fanout_workflow supports chatgpt.com and claude.ai only; the session is on ${hostname || "an unknown page"}. Navigate there first with browser_goto.`);
     }
-    const text = cap.bestAnswerText();
-    const parsed = adapter.parse(text, input.prompt || "");
-    const result = buildFanoutResult({ platform: adapter.platform, parsed, prompt: input.prompt || "", ready: true, rawBytes: text.length });
+    const text2 = cap.bestAnswerText();
+    const parsed = adapter.parse(text2, input.prompt || "");
+    const result = buildFanoutResult({ platform: adapter.platform, parsed, prompt: input.prompt || "", ready: true, rawBytes: text2.length });
     const enriched = enrichFanout(result, { firstPartyDomain: input.first_party_domain });
     const exports = input.export ? exportFanout(enriched) : null;
     return { result: enriched, exports };
@@ -17849,10 +18263,10 @@ async function click(runtimeSessionId, x, y, opts = {}) {
     ...opts.numClicks ? { num_clicks: opts.numClicks } : {}
   });
 }
-async function typeText(runtimeSessionId, text, delayMs) {
+async function typeText(runtimeSessionId, text2, delayMs) {
   const k = client();
   await k.browsers.computer.typeText(runtimeSessionId, {
-    text,
+    text: text2,
     ...typeof delayMs === "number" ? { delay: delayMs } : {}
   });
 }
@@ -17915,8 +18329,8 @@ async function readPage(cdpWsUrl) {
           bottom: Math.round(r.bottom)
         });
       }
-      const text = (document.body?.innerText || "").replace(/\n{3,}/g, "\n\n").trim().slice(0, 6e3);
-      return { text, els: out };
+      const text2 = (document.body?.innerText || "").replace(/\n{3,}/g, "\n\n").trim().slice(0, 6e3);
+      return { text: text2, els: out };
     });
     return {
       url,
@@ -18049,13 +18463,13 @@ async function locatePageTargets(cdpWsUrl, targets) {
         const match = target.match === "exact" ? "exact" : "contains";
         try {
           const selector = target.selector?.trim();
-          const text = target.text?.trim();
-          const candidates = selector ? selectorMatches(selector) : text ? textMatches(text, match) : [];
+          const text2 = target.text?.trim();
+          const candidates = selector ? selectorMatches(selector) : text2 ? textMatches(text2, match) : [];
           const selected = candidates[index];
           return {
             name: target.name ?? null,
             selector: selector || null,
-            text: text || null,
+            text: text2 || null,
             match,
             index,
             found: Boolean(selected),
@@ -18563,13 +18977,13 @@ function buildBrowserAgentRoutes() {
     const row = await loadOpenSession(c.req.param("id"), user.id);
     if (!row) return c.json({ error: "not found" }, 404);
     const body = await c.req.json().catch(() => ({}));
-    const text = typeof body.text === "string" ? body.text : "";
-    if (!text) return c.json({ error: "text is required" }, 400);
+    const text2 = typeof body.text === "string" ? body.text : "";
+    if (!text2) return c.json({ error: "text is required" }, 400);
     const t0 = Date.now();
     try {
-      await typeText(row.runtime_session_id, text, typeof body.delay === "number" ? body.delay : void 0);
+      await typeText(row.runtime_session_id, text2, typeof body.delay === "number" ? body.delay : void 0);
       await charge(row.id, user.id, t0);
-      await recordAction({ sessionId: row.id, type: "type", params: { length: text.length }, ok: true });
+      await recordAction({ sessionId: row.id, type: "type", params: { length: text2.length }, ok: true });
       return c.json({ ok: true });
     } catch (err) {
       await charge(row.id, user.id, t0);
@@ -18690,7 +19104,7 @@ function buildBrowserAgentRoutes() {
     }
     const existing = await getExtensionRow(user.id, name);
     if (existing) return c.json({ error: `an extension named "${name}" already exists \u2014 delete it first or pick another name` }, 409);
-    const backendName = `u${user.id}_${randomUUID5().replace(/-/g, "")}`;
+    const backendName = `u${user.id}_${randomUUID6().replace(/-/g, "")}`;
     try {
       const imported = await importExtensionFromStore(storeUrl, backendName);
       const row = await createExtensionRow({
@@ -19043,7 +19457,7 @@ stripeApp.post("/webhooks", async (c) => {
     const lineTierId = invoice.lines.data.map(linePriceId).find((id) => id && id in SUBSCRIPTION_TIERS);
     if (lineTierId) {
       const tier = SUBSCRIPTION_TIERS[lineTierId];
-      const user = await resolveUser(invoice.customer, invoice.customer_email ?? void 0);
+      const user = await resolveUser2(invoice.customer, invoice.customer_email ?? void 0);
       if (user && invoice.id && !await ledgerExistsForStripePI(invoice.id)) {
         await creditMc(user.id, tier.credits_mc, LedgerOperation.SUBSCRIPTION, `${tier.label} subscription credits`, invoice.id);
         await setSubscriptionTier(user.id, tier.tier, tier.concurrency, invoice.subscription ?? user.subscription_id);
@@ -19057,7 +19471,7 @@ stripeApp.post("/webhooks", async (c) => {
     const priceId = sub.items.data[0]?.price?.id;
     if (priceId && priceId in MEMORY_PLANS) {
       const mem = MEMORY_PLANS[priceId];
-      const user2 = await resolveUser(sub.customer, sub.customer_email);
+      const user2 = await resolveUser2(sub.customer, sub.customer_email);
       if (user2) {
         const live = sub.status === "active" || sub.status === "trialing";
         const newMemoryPlan = live ? mem.plan : "free";
@@ -19108,7 +19522,7 @@ function linePriceId(line) {
   const l = line;
   return l?.price?.id ?? l?.pricing?.price_details?.price ?? l?.plan?.id;
 }
-async function resolveUser(customerId, emailFallback) {
+async function resolveUser2(customerId, emailFallback) {
   let user = await getUserByStripeCustomerId(customerId);
   if (user) return user;
   if (!emailFallback) return void 0;
@@ -19120,7 +19534,7 @@ async function resolveUser(customerId, emailFallback) {
 // src/api/oauth-routes.ts
 import { Hono as Hono20 } from "hono";
 import { getCookie, setCookie } from "hono/cookie";
-import { createHash as createHash5, randomBytes as randomBytes2, randomUUID as randomUUID6 } from "crypto";
+import { createHash as createHash6, randomBytes as randomBytes2, randomUUID as randomUUID7 } 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";
@@ -19153,7 +19567,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 = createHash5("sha256").update(JSON.stringify({ e: publicJwk.e, kty: publicJwk.kty, n: publicJwk.n })).digest("base64url").slice(0, 16);
+  const kid = createHash6("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";
@@ -19463,12 +19877,12 @@ oauthApp.post("/oauth/authorize", async (c) => {
 });
 function pkceMatches(verifier, challenge) {
   if (!verifier) return false;
-  const computed = createHash5("sha256").update(verifier).digest("base64url");
+  const computed = createHash6("sha256").update(verifier).digest("base64url");
   return computed === challenge;
 }
 async function mintAccessToken(identity, scope, plan, audience) {
   const { privateKey, kid } = await getKeys();
-  return new SignJWT({ scope, plan }).setProtectedHeader({ alg: "RS256", kid }).setIssuer(ISSUER).setSubject(identity).setAudience(audience).setIssuedAt().setJti(randomUUID6()).setExpirationTime(`${ACCESS_TTL_SECONDS}s`).sign(privateKey);
+  return new SignJWT({ scope, plan }).setProtectedHeader({ alg: "RS256", kid }).setIssuer(ISSUER).setSubject(identity).setAudience(audience).setIssuedAt().setJti(randomUUID7()).setExpirationTime(`${ACCESS_TTL_SECONDS}s`).sign(privateKey);
 }
 function tokenErrorResponse(c, error, description, status) {
   return c.json({ error, error_description: description }, status);
@@ -20811,16 +21225,16 @@ function startSiteAuditWorker() {
 // src/api/server.ts
 import { createMiddleware as createMiddleware3 } from "hono/factory";
 import { getCookie as getCookie2, setCookie as setCookie2, deleteCookie } from "hono/cookie";
-import Stripe2 from "stripe";
+import Stripe3 from "stripe";
 
 // src/api/page-diff.ts
-import { createHash as createHash6 } from "crypto";
+import { createHash as createHash7 } 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 createHash6("sha256").update(value).digest("hex");
+  return createHash7("sha256").update(value).digest("hex");
 }
 function truncateForStorage(value, maxChars = MAX_SNAPSHOT_CONTENT_CHARS) {
   if (value.length <= maxChars) return { value, truncated: false };
@@ -20927,7 +21341,7 @@ async function persistScrapeBody(user, opts) {
 }
 
 // src/api/connection-memory-import.ts
-import { createHash as createHash7 } from "crypto";
+import { createHash as createHash8 } 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;
@@ -20957,7 +21371,7 @@ function canonicalJson(value) {
   return JSON.stringify(value);
 }
 function sha2562(value) {
-  return createHash7("sha256").update(value).digest("hex");
+  return createHash8("sha256").update(value).digest("hex");
 }
 function sensitiveKey(key) {
   const normalized = key.toLowerCase().replace(/[^a-z0-9]/g, "");
@@ -21226,7 +21640,7 @@ async function cleanupExpiredScrapeBlobs(maxAgeMs = SCRAPE_BLOB_TTL_MS) {
 }
 
 // src/api/connected-data-export.ts
-import { randomUUID as randomUUID7 } from "crypto";
+import { randomUUID as randomUUID8 } from "crypto";
 var CONNECTED_DATA_INLINE_BUDGET_BYTES = Number(
   process.env.MCP_SCRAPER_CONNECTED_DATA_INLINE_BUDGET_BYTES ?? 5e4
 );
@@ -21352,7 +21766,7 @@ function finitePositive(value, fallback) {
   return Number.isFinite(value) && value > 0 ? value : fallback;
 }
 async function collectConnectedDataExport(args) {
-  const exportId = randomUUID7();
+  const exportId = randomUUID8();
   const now = args.now ?? Date.now;
   const startedAt = now();
   const budgetMs = finitePositive(CONNECTED_DATA_EXPORT_BUDGET_MS, 24e4);
@@ -21464,7 +21878,7 @@ ${lines.length ? `${lines.join("\n")}
 }
 
 // src/api/search-console-table-export.ts
-import { randomUUID as randomUUID8 } from "crypto";
+import { randomUUID as randomUUID9 } from "crypto";
 var SEARCH_CONSOLE_TABLE_EXPORT_MAX_ROWS = 5e4;
 var SEARCH_CONSOLE_TABLE_EXPORT_PAGE_SIZE = 2e3;
 var SEARCH_CONSOLE_TABLE_EXPORT_MAX_BYTES = 50 * 1024 * 1024;
@@ -21564,7 +21978,7 @@ async function exportSearchConsoleTableData(args) {
     offset += rows.length;
     if (stoppedForBytes || rows.length < limit || offset >= matchedRows) break;
   }
-  const exportId = randomUUID8();
+  const exportId = randomUUID9();
   const artifact = await args.writeArtifact({
     ownerId: args.ownerId,
     exportId,
@@ -21799,77 +22213,730 @@ async function dbUsage(identity, plan) {
 }
 
 // src/api/nango-control.ts
-import { createHash as createHash8 } from "crypto";
-var DEFAULT_NANGO_CONTROL_URL = "https://mcp-scraper-scheduler.vercel.app";
-var DISABLED_NANGO_TOOLS = {
-  "google-mail": /* @__PURE__ */ new Set(["list-filters"]),
-  slack: /* @__PURE__ */ new Set(["search-files", "search-messages"])
-};
-var CONNECTION_SYNC_REQUIRED_TOOLS = {
-  "google-mail": ["list-messages", "get-message"],
-  "google-calendar": ["list-events", "get-event"],
-  zoom: [
-    "list-meetings",
-    "get-meeting",
-    "list-recordings",
-    "get-recording",
-    "get-meeting-transcript"
-  ],
-  "github-getting-started": [
-    "list-repositories",
-    "list-issues",
-    "list-pull-requests",
-    "list-commits",
-    "list-releases",
-    "list-workflows",
-    "list-workflow-runs"
-  ],
-  "google-search-console": [
-    "list-sites",
-    "query-search-analytics"
-  ],
-  resend: [
-    "list-emails",
-    "get-email",
-    "list-received-emails",
-    "get-received-email",
-    "list-logs",
-    "get-log",
-    "list-contacts",
-    "get-contact",
-    "list-broadcasts",
-    "get-broadcast",
-    "list-templates",
-    "get-template"
-  ],
-  "meta-marketing-api": [
-    "list-ad-accounts",
-    "list-campaigns",
-    "list-ad-sets",
-    "list-ads",
-    "list-ad-creatives",
-    "get-insights"
-  ]
-};
-var CONNECTION_SYNC_OPTIONAL_TOOLS = {
-  "meta-marketing-api": [
-    "list-catalogs",
-    "list-datasets",
-    "list-custom-audiences",
-    "list-ad-images",
-    "list-ad-videos",
-    "list-ad-rules"
-  ]
-};
-function connectionSyncPolicyIssues(selections) {
-  const issues = [];
-  for (const selection of selections) {
-    const required = CONNECTION_SYNC_REQUIRED_TOOLS[selection.providerConfigKey];
-    if (!required) {
-      issues.push({ providerConfigKey: selection.providerConfigKey, code: "unsupported_provider" });
-      continue;
-    }
-    const allowed = new Set(selection.allowedTools);
+import { createHash as createHash10, randomUUID as randomUUID12 } from "crypto";
+
+// src/api/main-nango-transport.ts
+import { createHash as createHash9, randomUUID as randomUUID11 } from "crypto";
+import { Client } from "@modelcontextprotocol/sdk/client/index.js";
+import { StreamableHTTPClientTransport } from "@modelcontextprotocol/sdk/client/streamableHttp.js";
+
+// src/api/service-connections.ts
+import { randomUUID as randomUUID10 } from "crypto";
+var schemaReady2 = null;
+var schemaDb = null;
+function ensureServiceConnectionsSchema() {
+  const currentDb = getDb();
+  if (schemaReady2 && schemaDb === currentDb) return schemaReady2;
+  schemaDb = currentDb;
+  schemaReady2 = (async () => {
+    const db = currentDb;
+    await db.execute(`
+      CREATE TABLE IF NOT EXISTS service_connections (
+        id                         TEXT PRIMARY KEY,
+        user_id                    INTEGER NOT NULL REFERENCES users(id),
+        provider_config_key        TEXT NOT NULL,
+        provider                   TEXT,
+        transport                  TEXT NOT NULL,
+        upstream_connection_id     TEXT,
+        label                      TEXT,
+        lifecycle_status           TEXT NOT NULL DEFAULT 'pending',
+        operational_status         TEXT NOT NULL DEFAULT 'unknown',
+        reconnect_required         INTEGER NOT NULL DEFAULT 0,
+        actions_enabled            INTEGER NOT NULL DEFAULT 0,
+        read_tools_json            TEXT NOT NULL DEFAULT '[]',
+        action_tools_json          TEXT NOT NULL DEFAULT '[]',
+        tool_revision              TEXT,
+        last_checked_at            TEXT,
+        last_successful_call_at    TEXT,
+        last_failure_at            TEXT,
+        last_failure_code          TEXT,
+        last_failure_retryable     INTEGER,
+        consecutive_failures       INTEGER NOT NULL DEFAULT 0,
+        vault_name                 TEXT,
+        table_name                 TEXT,
+        legacy_owner_identity      TEXT,
+        created_at                 TEXT NOT NULL DEFAULT (datetime('now')),
+        updated_at                 TEXT NOT NULL DEFAULT (datetime('now')),
+        UNIQUE(user_id, provider_config_key, upstream_connection_id)
+      )
+    `);
+    await db.execute(`CREATE INDEX IF NOT EXISTS service_connections_user_updated ON service_connections(user_id, updated_at DESC)`);
+    await db.execute(`CREATE INDEX IF NOT EXISTS service_connections_upstream ON service_connections(provider_config_key, upstream_connection_id)`);
+    await db.execute(`
+      CREATE TABLE IF NOT EXISTS service_connection_health_events (
+        id                    TEXT PRIMARY KEY,
+        connection_id         TEXT NOT NULL REFERENCES service_connections(id) ON DELETE CASCADE,
+        operational_status    TEXT NOT NULL,
+        failure_code          TEXT,
+        retryable             INTEGER,
+        evidence_source       TEXT NOT NULL,
+        created_at            TEXT NOT NULL DEFAULT (datetime('now'))
+      )
+    `);
+    await db.execute(`CREATE INDEX IF NOT EXISTS service_connection_health_events_connection ON service_connection_health_events(connection_id, created_at DESC)`);
+    await db.execute(`
+      CREATE TABLE IF NOT EXISTS service_connection_action_audit (
+        id                    TEXT PRIMARY KEY,
+        connection_id         TEXT NOT NULL REFERENCES service_connections(id) ON DELETE CASCADE,
+        user_id               INTEGER NOT NULL REFERENCES users(id),
+        tool                  TEXT NOT NULL,
+        request_id            TEXT NOT NULL,
+        status                TEXT NOT NULL,
+        error_code            TEXT,
+        created_at            TEXT NOT NULL DEFAULT (datetime('now')),
+        UNIQUE(user_id, request_id)
+      )
+    `);
+  })().catch((error) => {
+    schemaReady2 = null;
+    schemaDb = null;
+    throw error;
+  });
+  return schemaReady2;
+}
+function parseTools(value) {
+  if (typeof value !== "string") return [];
+  try {
+    const parsed = JSON.parse(value);
+    return Array.isArray(parsed) ? parsed.filter((item) => typeof item === "string") : [];
+  } catch {
+    return [];
+  }
+}
+function rowToRecord(row) {
+  return {
+    id: String(row.id),
+    userId: Number(row.user_id),
+    providerConfigKey: String(row.provider_config_key),
+    provider: typeof row.provider === "string" ? row.provider : null,
+    transport: row.transport === "remote_mcp" ? "remote_mcp" : "nango",
+    upstreamConnectionId: typeof row.upstream_connection_id === "string" ? row.upstream_connection_id : null,
+    label: typeof row.label === "string" ? row.label : null,
+    lifecycleStatus: String(row.lifecycle_status),
+    operationalStatus: String(row.operational_status),
+    reconnectRequired: Number(row.reconnect_required) === 1,
+    actionsEnabled: Number(row.actions_enabled) === 1,
+    readTools: parseTools(row.read_tools_json),
+    actionTools: parseTools(row.action_tools_json),
+    toolRevision: typeof row.tool_revision === "string" ? row.tool_revision : null,
+    lastCheckedAt: typeof row.last_checked_at === "string" ? row.last_checked_at : null,
+    lastSuccessfulCallAt: typeof row.last_successful_call_at === "string" ? row.last_successful_call_at : null,
+    lastFailureAt: typeof row.last_failure_at === "string" ? row.last_failure_at : null,
+    lastFailureCode: typeof row.last_failure_code === "string" ? row.last_failure_code : null,
+    lastFailureRetryable: row.last_failure_retryable === null || row.last_failure_retryable === void 0 ? null : Number(row.last_failure_retryable) === 1,
+    consecutiveFailures: Number(row.consecutive_failures ?? 0),
+    vaultName: typeof row.vault_name === "string" ? row.vault_name : null,
+    tableName: typeof row.table_name === "string" ? row.table_name : null,
+    createdAt: String(row.created_at),
+    updatedAt: String(row.updated_at)
+  };
+}
+async function userIdForIdentity(identity) {
+  const user = await getUserByEmail(identity.normalize("NFKC").trim().toLowerCase());
+  if (!user) throw new Error("service_connection_user_not_found");
+  return Number(user.id);
+}
+async function reconcileDiscoveredNangoConnections(identity, discovered) {
+  await ensureServiceConnectionsSchema();
+  const db = getDb();
+  const userId = await userIdForIdentity(identity);
+  for (const connection of discovered) {
+    await db.execute({
+      sql: `
+        INSERT INTO service_connections (
+          id, user_id, provider_config_key, provider, transport, upstream_connection_id,
+          label, lifecycle_status, reconnect_required, legacy_owner_identity, created_at, updated_at
+        ) VALUES (?, ?, ?, ?, 'nango', ?, ?, ?, ?, ?, COALESCE(?, datetime('now')), COALESCE(?, datetime('now')))
+        ON CONFLICT(user_id, provider_config_key, upstream_connection_id) DO UPDATE SET
+          provider = excluded.provider,
+          label = COALESCE(excluded.label, service_connections.label),
+          lifecycle_status = excluded.lifecycle_status,
+          reconnect_required = excluded.reconnect_required,
+          updated_at = excluded.updated_at
+      `,
+      args: [
+        randomUUID10(),
+        userId,
+        connection.providerConfigKey,
+        connection.provider,
+        connection.upstreamConnectionId,
+        connection.label,
+        connection.lifecycleStatus,
+        connection.reconnectRequired ? 1 : 0,
+        identity,
+        connection.createdAt,
+        connection.updatedAt
+      ]
+    });
+  }
+  return listServiceConnections(identity, "nango");
+}
+async function listServiceConnections(identity, transport) {
+  await ensureServiceConnectionsSchema();
+  const userId = await userIdForIdentity(identity);
+  const result = await getDb().execute({
+    sql: `SELECT * FROM service_connections WHERE user_id = ?${transport ? " AND transport = ?" : ""} AND lifecycle_status <> 'disconnected' ORDER BY updated_at DESC`,
+    args: transport ? [userId, transport] : [userId]
+  });
+  return result.rows.map((row) => rowToRecord(row));
+}
+async function getOwnedServiceConnection(identity, connectionId) {
+  await ensureServiceConnectionsSchema();
+  const userId = await userIdForIdentity(identity);
+  const result = await getDb().execute({
+    sql: "SELECT * FROM service_connections WHERE id = ? AND user_id = ? LIMIT 1",
+    args: [connectionId, userId]
+  });
+  const row = result.rows[0];
+  return row ? rowToRecord(row) : null;
+}
+async function updateServiceConnectionTools(connectionId, readTools, actionTools, toolRevision) {
+  await ensureServiceConnectionsSchema();
+  await getDb().execute({
+    sql: `UPDATE service_connections SET read_tools_json = ?, action_tools_json = ?, tool_revision = ?, updated_at = datetime('now') WHERE id = ?`,
+    args: [JSON.stringify(readTools), JSON.stringify(actionTools), toolRevision, connectionId]
+  });
+}
+async function recordServiceConnectionHealth(args) {
+  await ensureServiceConnectionsSchema();
+  const now = (/* @__PURE__ */ new Date()).toISOString();
+  await getDb().execute({
+    sql: `
+      UPDATE service_connections SET
+        operational_status = ?, last_checked_at = ?,
+        last_successful_call_at = CASE WHEN ? = 'available' THEN ? ELSE last_successful_call_at END,
+        last_failure_at = CASE WHEN ? IN ('degraded', 'unavailable') THEN ? ELSE NULL END,
+        last_failure_code = ?, last_failure_retryable = ?,
+        consecutive_failures = CASE WHEN ? = 'available' THEN 0 ELSE consecutive_failures + 1 END,
+        updated_at = datetime('now')
+      WHERE id = ?
+    `,
+    args: [
+      args.operationalStatus,
+      now,
+      args.operationalStatus,
+      now,
+      args.operationalStatus,
+      now,
+      args.failureCode ?? null,
+      args.retryable == null ? null : args.retryable ? 1 : 0,
+      args.operationalStatus,
+      args.connectionId
+    ]
+  });
+  await getDb().execute({
+    sql: `INSERT INTO service_connection_health_events (id, connection_id, operational_status, failure_code, retryable, evidence_source) VALUES (?, ?, ?, ?, ?, ?)`,
+    args: [randomUUID10(), args.connectionId, args.operationalStatus, args.failureCode ?? null, args.retryable == null ? null : args.retryable ? 1 : 0, args.evidenceSource]
+  });
+}
+async function setServiceConnectionActions(identity, connectionId, enabled) {
+  const connection = await getOwnedServiceConnection(identity, connectionId);
+  if (!connection || connection.lifecycleStatus === "disconnected") throw new Error("service_connection_not_found");
+  await getDb().execute({
+    sql: `UPDATE service_connections SET actions_enabled = ?, updated_at = datetime('now') WHERE id = ? AND user_id = ?`,
+    args: [enabled ? 1 : 0, connectionId, connection.userId]
+  });
+  return enabled;
+}
+async function markServiceConnectionDisconnected(identity, connectionId) {
+  const connection = await getOwnedServiceConnection(identity, connectionId);
+  if (!connection) throw new Error("service_connection_not_found");
+  await getDb().execute({
+    sql: `UPDATE service_connections SET lifecycle_status = 'disconnected', operational_status = 'unknown', reconnect_required = 0, updated_at = datetime('now') WHERE id = ? AND user_id = ?`,
+    args: [connectionId, connection.userId]
+  });
+  const remaining = await getDb().execute({
+    sql: `SELECT COUNT(*) AS count FROM service_connections WHERE user_id = ? AND transport = 'nango' AND lifecycle_status = 'connected'`,
+    args: [connection.userId]
+  });
+  return Number(remaining.rows[0]?.count ?? 0);
+}
+async function recordServiceConnectionAction(args) {
+  await ensureServiceConnectionsSchema();
+  const connection = await getOwnedServiceConnection(args.identity, args.connectionId);
+  if (!connection) throw new Error("service_connection_not_found");
+  await getDb().execute({
+    sql: `UPDATE service_connection_action_audit SET status = ?, error_code = ? WHERE user_id = ? AND request_id = ? AND connection_id = ?`,
+    args: [args.status, args.errorCode ?? null, connection.userId, args.requestId, connection.id]
+  });
+}
+async function claimServiceConnectionAction(args) {
+  await ensureServiceConnectionsSchema();
+  const connection = await getOwnedServiceConnection(args.identity, args.connectionId);
+  if (!connection) throw new Error("service_connection_not_found");
+  const inserted = await getDb().execute({
+    sql: `INSERT OR IGNORE INTO service_connection_action_audit (id, connection_id, user_id, tool, request_id, status) VALUES (?, ?, ?, ?, ?, 'started')`,
+    args: [randomUUID10(), connection.id, connection.userId, args.tool, args.requestId]
+  });
+  if (Number(inserted.rowsAffected ?? 0) === 1) return { claimed: true };
+  const existing = await getDb().execute({
+    sql: `SELECT status, error_code FROM service_connection_action_audit WHERE user_id = ? AND request_id = ? LIMIT 1`,
+    args: [connection.userId, args.requestId]
+  });
+  return {
+    claimed: false,
+    status: String(existing.rows[0]?.status ?? "unknown"),
+    errorCode: typeof existing.rows[0]?.error_code === "string" ? existing.rows[0].error_code : null
+  };
+}
+
+// src/api/main-nango-transport.ts
+var DEFAULT_NANGO_MCP_URL = "https://api.nango.dev/mcp";
+var NANGO_TIMEOUT_MS = 2e4;
+var NANGO_CONNECTION_PAGE_SIZE = 100;
+var NANGO_CONNECTION_MAX_PAGES = 20;
+var MAIN_INTEGRATION_CONTRACT_VERSION = "2026-07-16.1";
+var MAIN_INTEGRATION_CONTRACT_HASH = "f037859ec80c2ea2fac6e4a67c1a59f3200dd22d3642c97789b9bb3236723d3e";
+var MainNangoTransportError = class extends Error {
+  status;
+  code;
+  retryable;
+  constructor(message, status, code, retryable = status === 429 || status >= 500) {
+    super(message);
+    this.name = "MainNangoTransportError";
+    this.status = status;
+    this.code = code;
+    this.retryable = retryable;
+  }
+};
+function asRecord(value) {
+  return value && typeof value === "object" && !Array.isArray(value) ? value : null;
+}
+function text(value) {
+  return typeof value === "string" && value.trim() ? value.trim() : null;
+}
+function arrayAt(payload, key) {
+  if (Array.isArray(payload)) return payload;
+  const root = asRecord(payload);
+  if (Array.isArray(root?.[key])) return root[key];
+  if (Array.isArray(root?.data)) return root.data;
+  const data = asRecord(root?.data);
+  return Array.isArray(data?.[key]) ? data[key] : [];
+}
+function nangoSecret() {
+  const secret2 = process.env.NANGO_SECRET_KEY?.trim();
+  if (!secret2) throw new MainNangoTransportError("Nango is not configured.", 503, "nango_not_configured");
+  return secret2;
+}
+function nangoMcpUrl() {
+  try {
+    return new URL(process.env.NANGO_MCP_URL?.trim() || DEFAULT_NANGO_MCP_URL);
+  } catch {
+    throw new MainNangoTransportError("Nango MCP URL is invalid.", 503, "nango_invalid_url");
+  }
+}
+async function nangoRequest(path5, options = {}) {
+  const url = new URL(path5, `${nangoMcpUrl().origin}/`);
+  for (const [key, value] of Object.entries(options.query ?? {})) {
+    if (value !== void 0) url.searchParams.set(key, String(value));
+  }
+  let response;
+  try {
+    response = await fetch(url, {
+      method: options.method ?? "GET",
+      headers: {
+        authorization: `Bearer ${nangoSecret()}`,
+        accept: "application/json",
+        ...options.body ? { "content-type": "application/json" } : {}
+      },
+      body: options.body ? JSON.stringify(options.body) : void 0,
+      signal: AbortSignal.timeout(NANGO_TIMEOUT_MS)
+    });
+  } catch {
+    throw new MainNangoTransportError("Nango is temporarily unavailable.", 503, "connection_transport_unavailable");
+  }
+  const raw = await response.text();
+  let payload = {};
+  try {
+    payload = raw ? JSON.parse(raw) : {};
+  } catch {
+    throw new MainNangoTransportError("Nango returned an invalid response.", 502, "nango_invalid_response");
+  }
+  if (!response.ok) {
+    const status = response.status === 400 || response.status === 403 || response.status === 404 || response.status === 409 || response.status === 429 || response.status === 503 ? response.status : 502;
+    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"
+    );
+  }
+  return payload;
+}
+function normalizedIdentity(value) {
+  const valueText = text(value);
+  return valueText ? valueText.normalize("NFKC").toLowerCase() : null;
+}
+function connectionIdentityMatches(value, identity) {
+  const row = asRecord(value);
+  const tags = asRecord(row?.tags);
+  const endUser = asRecord(row?.end_user);
+  const expected = normalizedIdentity(identity);
+  if (!expected) return false;
+  const emails = [normalizedIdentity(tags?.end_user_email), normalizedIdentity(endUser?.email)].filter((candidate) => !!candidate);
+  if (emails.some((candidate) => candidate !== expected)) return false;
+  const ids = [normalizedIdentity(tags?.end_user_id), normalizedIdentity(endUser?.id)].filter((candidate) => !!candidate && candidate.includes("@"));
+  if (ids.some((candidate) => candidate !== expected)) return false;
+  return emails.length > 0 ? emails.includes(expected) : ids.includes(expected);
+}
+function discoveredConnection(value) {
+  const row = asRecord(value);
+  const upstreamConnectionId = text(row?.connection_id);
+  const providerConfigKey = text(row?.provider_config_key);
+  if (!upstreamConnectionId || !providerConfigKey) return null;
+  const tags = asRecord(row?.tags);
+  const endUser = asRecord(row?.end_user);
+  const errors = Array.isArray(row?.errors) ? row.errors : [];
+  const authError = errors.some((error) => text(asRecord(error)?.type) === "auth");
+  return {
+    upstreamConnectionId,
+    providerConfigKey,
+    provider: text(row?.provider) ?? providerConfigKey,
+    label: text(tags?.end_user_display_name) ?? text(endUser?.display_name) ?? text(tags?.end_user_email) ?? text(endUser?.email),
+    lifecycleStatus: authError ? "needs_reauth" : "connected",
+    reconnectRequired: authError,
+    createdAt: text(row?.created_at) ?? text(row?.created),
+    updatedAt: text(row?.updated_at)
+  };
+}
+async function discoverOwnedNangoConnections(identity) {
+  const rows = [];
+  for (let page = 0; page < NANGO_CONNECTION_MAX_PAGES; page += 1) {
+    const payload = await nangoRequest("/connections", {
+      query: { limit: NANGO_CONNECTION_PAGE_SIZE, page }
+    });
+    const pageRows = arrayAt(payload, "connections");
+    rows.push(...pageRows);
+    if (pageRows.length < NANGO_CONNECTION_PAGE_SIZE) break;
+  }
+  const discovered = rows.filter((row) => connectionIdentityMatches(row, identity)).map(discoveredConnection).filter((connection) => connection !== null);
+  return reconcileDiscoveredNangoConnections(identity, discovered);
+}
+async function listNangoCatalogDirect() {
+  const [integrationsPayload, providersPayload] = await Promise.all([
+    nangoRequest("/integrations"),
+    nangoRequest("/providers")
+  ]);
+  const providers = /* @__PURE__ */ new Map();
+  for (const value of arrayAt(providersPayload, "providers")) {
+    const row = asRecord(value);
+    const name = text(row?.name);
+    if (row && name) providers.set(name, row);
+  }
+  return arrayAt(integrationsPayload, "integrations").flatMap((value) => {
+    const row = asRecord(value);
+    const id = text(row?.unique_key) ?? text(row?.id);
+    const provider = text(row?.provider);
+    if (!id || !provider) return [];
+    const definition = providers.get(provider);
+    return [{
+      id,
+      provider,
+      displayName: text(row?.display_name) ?? text(definition?.display_name) ?? id,
+      authMode: text(definition?.auth_mode),
+      categories: Array.isArray(definition?.categories) ? definition.categories : [],
+      docsUrl: text(definition?.docs),
+      logoUrl: text(row?.logo),
+      safeDefaultAllowedTools: [],
+      actionTools: [],
+      setupStatus: "ready"
+    }];
+  });
+}
+function connectDefaults(providerConfigKey) {
+  const scopes = {
+    linkedin: "openid profile email w_member_social",
+    "github-getting-started": "repo workflow read:org read:user user:email",
+    "google-drive": "openid profile email https://www.googleapis.com/auth/drive",
+    "google-search-console": "openid profile email https://www.googleapis.com/auth/webmasters.readonly https://www.googleapis.com/auth/webmasters"
+  };
+  const scope = scopes[providerConfigKey];
+  return scope ? { [providerConfigKey]: { connection_config: { oauth_scopes_override: scope } } } : void 0;
+}
+function sessionPayload(value) {
+  const root = asRecord(value);
+  const data = asRecord(root?.data) ?? root;
+  const connectLink = text(data?.connect_link);
+  if (!connectLink) throw new MainNangoTransportError("Nango did not return a connect link.", 502, "nango_missing_connect_link");
+  return { connectLink, expiresAt: text(data?.expires_at) };
+}
+async function createNangoSessionDirect(identity, providerConfigKey) {
+  const defaults = connectDefaults(providerConfigKey);
+  return sessionPayload(await nangoRequest("/connect/sessions", {
+    method: "POST",
+    body: {
+      tags: { end_user_id: identity, end_user_email: identity },
+      allowed_integrations: [providerConfigKey],
+      ...defaults ? { integrations_config_defaults: defaults } : {}
+    }
+  }));
+}
+async function createNangoReconnectSessionDirect(identity, connectionId) {
+  const connection = await requireOwnedActiveConnection(identity, connectionId, true);
+  const defaults = connectDefaults(connection.providerConfigKey);
+  return sessionPayload(await nangoRequest("/connect/sessions/reconnect", {
+    method: "POST",
+    body: {
+      connection_id: connection.upstreamConnectionId,
+      integration_id: connection.providerConfigKey,
+      tags: { end_user_id: identity, end_user_email: identity },
+      ...defaults ? { integrations_config_defaults: defaults } : {}
+    }
+  }));
+}
+async function deleteNangoConnectionDirect(identity, connectionId) {
+  const connection = await requireOwnedActiveConnection(identity, connectionId, true);
+  try {
+    await nangoRequest(`/connections/${encodeURIComponent(connection.upstreamConnectionId)}`, {
+      method: "DELETE",
+      query: { provider_config_key: connection.providerConfigKey }
+    });
+  } catch (error) {
+    if (!(error instanceof MainNangoTransportError) || error.status !== 404) throw error;
+  }
+}
+async function requireOwnedActiveConnection(identity, connectionId, allowNeedsReauth = false) {
+  const connection = await getOwnedServiceConnection(identity, connectionId);
+  if (!connection || connection.transport !== "nango" || !connection.upstreamConnectionId) {
+    throw new MainNangoTransportError("Service connection not found.", 404, "connection_not_found", false);
+  }
+  if (connection.lifecycleStatus !== "connected" && !(allowNeedsReauth && connection.lifecycleStatus === "needs_reauth")) {
+    throw new MainNangoTransportError("Service connection requires reconnection.", 409, "connection_inactive", false);
+  }
+  return connection;
+}
+function classifyTool(tool) {
+  if (tool.annotations?.readOnlyHint === true) return "read";
+  if (tool.annotations?.readOnlyHint === false) return "action";
+  return /^(get|list|search|query|read|download|fetch|find|lookup|inspect|describe|check)-/i.test(tool.name) ? "read" : "action";
+}
+async function withNangoClient(connection, run) {
+  const transport = new StreamableHTTPClientTransport(nangoMcpUrl(), {
+    requestInit: {
+      headers: {
+        Authorization: `Bearer ${nangoSecret()}`,
+        "connection-id": connection.upstreamConnectionId,
+        "provider-config-key": connection.providerConfigKey
+      }
+    }
+  });
+  const client2 = new Client({ name: "mcp-scraper-integrations", version: "1.0.0" }, { capabilities: {} });
+  try {
+    await client2.connect(transport);
+    const value = await run(client2);
+    await recordServiceConnectionHealth({
+      connectionId: connection.id,
+      operationalStatus: "available",
+      evidenceSource: "nango_mcp"
+    });
+    return value;
+  } catch (error) {
+    await recordServiceConnectionHealth({
+      connectionId: connection.id,
+      operationalStatus: "unavailable",
+      failureCode: "connection_transport_unavailable",
+      retryable: true,
+      evidenceSource: "nango_mcp"
+    }).catch(() => void 0);
+    if (error instanceof MainNangoTransportError) throw error;
+    throw new MainNangoTransportError("The service connection is temporarily unavailable.", 503, "connection_transport_unavailable");
+  } finally {
+    await client2.close().catch(() => void 0);
+  }
+}
+async function listNangoToolsDirect(identity, connectionId) {
+  const connection = await requireOwnedActiveConnection(identity, connectionId);
+  const listed = await withNangoClient(connection, (client2) => client2.listTools());
+  const tools = listed.tools.flatMap((raw) => {
+    const inputSchema = asRecord(raw.inputSchema);
+    if (!raw.name || !inputSchema) return [];
+    return [{
+      name: raw.name,
+      ...raw.title ? { title: raw.title } : {},
+      ...raw.description ? { description: raw.description } : {},
+      inputSchema,
+      ...asRecord(raw.outputSchema) ? { outputSchema: asRecord(raw.outputSchema) } : {},
+      ...asRecord(raw.annotations) ? { annotations: asRecord(raw.annotations) } : {}
+    }];
+  });
+  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 = createHash9("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 };
+}
+async function callNangoToolDirect(args) {
+  const { connection, tools } = await listNangoToolsDirect(args.identity, args.connectionId);
+  const selected = tools.find((tool) => tool.name === args.tool);
+  if (!selected) throw new MainNangoTransportError("The requested provider tool is unavailable.", 404, "live_tool_missing", false);
+  const actualClassification = classifyTool(selected);
+  if (actualClassification !== args.classification) {
+    throw new MainNangoTransportError("The provider tool classification does not match this operation.", 403, "tool_not_allowed", false);
+  }
+  if (actualClassification === "action" && !connection.actionsEnabled) {
+    throw new MainNangoTransportError("Actions are disabled for this service connection.", 403, "actions_disabled", false);
+  }
+  await preflightConnectedUsage({
+    identity: args.identity,
+    ratePolicyVersion: CONNECTED_USAGE_RATE_POLICY_VERSION
+  });
+  const requestId = args.requestId?.trim() || randomUUID11();
+  const idempotencyKey = `main-nango:${createHash9("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;
+  let providerError;
+  try {
+    result = await withNangoClient(connection, (client2) => client2.callTool({ name: args.tool, arguments: args.input }));
+  } catch (error) {
+    providerError = error;
+  }
+  const completedAt = /* @__PURE__ */ new Date();
+  await settleConnectedUsage({
+    identity: args.identity,
+    idempotencyKey,
+    ratePolicyVersion: CONNECTED_USAGE_RATE_POLICY_VERSION,
+    connectionId: connection.id,
+    providerConfigKey: connection.providerConfigKey,
+    functionRuns: 1,
+    proxyRequests: 0,
+    computeMilliseconds: Math.max(0, Math.round(performance.now() - started)),
+    sourceSurface: "main_mcp",
+    metadata: {
+      toolName: args.tool,
+      operationKind: args.operationKind ?? args.classification,
+      outcome: providerError ? "error" : "partial",
+      requestId: requestId.length <= 200 ? requestId : createHash9("sha256").update(requestId).digest("hex"),
+      startedAt: startedAt.toISOString(),
+      completedAt: completedAt.toISOString()
+    }
+  });
+  if (providerError) throw providerError;
+  return result;
+}
+async function describeNangoToolDirect(identity, connectionId, toolName) {
+  const { connection, tools } = await listNangoToolsDirect(identity, connectionId);
+  const tool = tools.find((candidate) => candidate.name === toolName);
+  if (!tool) throw new MainNangoTransportError("The requested provider tool is unavailable.", 404, "live_tool_missing", false);
+  const classification = classifyTool(tool);
+  const callable = classification === "read" || connection.actionsEnabled;
+  const projected = {
+    name: tool.name,
+    ...tool.title ? { title: tool.title } : {},
+    ...tool.description ? { description: tool.description } : {},
+    inputSchema: tool.inputSchema,
+    ...tool.outputSchema ? { outputSchema: tool.outputSchema } : {},
+    ...tool.annotations ? { annotations: tool.annotations } : {}
+  };
+  return {
+    ...projected,
+    classification,
+    callable,
+    blockedReason: callable ? null : "actions_disabled",
+    requiredPermissions: [],
+    missingPermissions: [],
+    requiredFeatures: [],
+    missingFeatures: [],
+    transport: "nango",
+    providerConfigKey: connection.providerConfigKey,
+    providerContractVersion: MAIN_INTEGRATION_CONTRACT_VERSION,
+    providerContractHash: MAIN_INTEGRATION_CONTRACT_HASH,
+    protocolVersion: null,
+    schemaSource: "live_tools_list",
+    schemaHash: createHash9("sha256").update(JSON.stringify(projected)).digest("hex"),
+    fetchedAt: (/* @__PURE__ */ new Date()).toISOString()
+  };
+}
+
+// src/api/nango-control.ts
+var DEFAULT_NANGO_CONTROL_URL = "https://mcp-scraper-scheduler.vercel.app";
+function mainOwnsIntegrations() {
+  const configured = process.env.INTEGRATION_OWNER?.trim().toLowerCase();
+  if (configured) return configured !== "legacy_scheduler";
+  return !process.env.NANGO_CONTROL_URL?.trim();
+}
+function asNangoControlError(error) {
+  if (error instanceof NangoControlError) return error;
+  if (error instanceof MainNangoTransportError) {
+    return new NangoControlError(error.message, error.status, error.code, error.retryable);
+  }
+  if (error instanceof Error && error.message === "service_connection_user_not_found") {
+    return new NangoControlError("The connection owner was not found.", 404, "connection_not_found", false);
+  }
+  if (error instanceof Error && error.message === "service_connection_not_found") {
+    return new NangoControlError("The service connection was not found.", 404, "connection_not_found", false);
+  }
+  return new NangoControlError("The service connection request failed.", 502, "connection_control_failed", true);
+}
+var DISABLED_NANGO_TOOLS = {
+  "google-mail": /* @__PURE__ */ new Set(["list-filters"]),
+  slack: /* @__PURE__ */ new Set(["search-files", "search-messages"])
+};
+var CONNECTION_SYNC_REQUIRED_TOOLS = {
+  "google-mail": ["list-messages", "get-message"],
+  "google-calendar": ["list-events", "get-event"],
+  zoom: [
+    "list-meetings",
+    "get-meeting",
+    "list-recordings",
+    "get-recording",
+    "get-meeting-transcript"
+  ],
+  "github-getting-started": [
+    "list-repositories",
+    "list-issues",
+    "list-pull-requests",
+    "list-commits",
+    "list-releases",
+    "list-workflows",
+    "list-workflow-runs"
+  ],
+  "google-search-console": [
+    "list-sites",
+    "query-search-analytics"
+  ],
+  resend: [
+    "list-emails",
+    "get-email",
+    "list-received-emails",
+    "get-received-email",
+    "list-logs",
+    "get-log",
+    "list-contacts",
+    "get-contact",
+    "list-broadcasts",
+    "get-broadcast",
+    "list-templates",
+    "get-template"
+  ],
+  "meta-marketing-api": [
+    "list-ad-accounts",
+    "list-campaigns",
+    "list-ad-sets",
+    "list-ads",
+    "list-ad-creatives",
+    "get-insights"
+  ]
+};
+var CONNECTION_SYNC_OPTIONAL_TOOLS = {
+  "meta-marketing-api": [
+    "list-catalogs",
+    "list-datasets",
+    "list-custom-audiences",
+    "list-ad-images",
+    "list-ad-videos",
+    "list-ad-rules"
+  ]
+};
+function connectionSyncPolicyIssues(selections) {
+  const issues = [];
+  for (const selection of selections) {
+    const required = CONNECTION_SYNC_REQUIRED_TOOLS[selection.providerConfigKey];
+    if (!required) {
+      issues.push({ providerConfigKey: selection.providerConfigKey, code: "unsupported_provider" });
+      continue;
+    }
+    const allowed = new Set(selection.allowedTools);
     const missingTools = required.filter((tool) => !allowed.has(tool));
     if (missingTools.length > 0) {
       issues.push({ providerConfigKey: selection.providerConfigKey, code: "missing_required_tools", missingTools });
@@ -21990,7 +23057,28 @@ var SAFE_CONTROL_ERROR_CODES = /* @__PURE__ */ new Set([
   "connection_control_failed",
   "missing_provider_permission",
   "permission_verification_unavailable",
-  "meta_app_feature_not_enabled"
+  "meta_app_feature_not_enabled",
+  "insufficient_credits",
+  "pending_cost",
+  "rate_policy_mismatch",
+  "connected_usage_billing_unavailable",
+  "action_outcome_unknown",
+  "billing_dispatch_incomplete",
+  "billing_dispatch_busy"
+]);
+var FIXED_CONTROL_ERROR_MESSAGES = /* @__PURE__ */ new Map([
+  [
+    "action_outcome_unknown",
+    "The previous connected action may have completed, so it was not run again. Verify the provider before retrying with a new Idempotency-Key."
+  ],
+  [
+    "billing_dispatch_incomplete",
+    "A previous connected action could not be confirmed safely. Contact support before retrying."
+  ],
+  [
+    "billing_dispatch_busy",
+    "Another connected action is currently being finalized. Retry shortly with the same Idempotency-Key."
+  ]
 ]);
 var CONTROL_ERROR_CODE_ALIASES = /* @__PURE__ */ new Map([
   ["connection_not_active", "connection_inactive"],
@@ -22000,13 +23088,14 @@ var CONTROL_ERROR_CODE_ALIASES = /* @__PURE__ */ new Map([
   ["tool_not_available", "live_tool_missing"]
 ]);
 function controlErrorStatus(status) {
-  if (status === 400 || status === 403 || status === 404 || status === 409 || status === 429 || status === 502 || status === 503) {
+  if (status === 400 || status === 402 || status === 403 || status === 404 || status === 409 || status === 429 || status === 502 || status === 503) {
     return status;
   }
   return status >= 500 ? 503 : 502;
 }
 function defaultControlErrorCode(status) {
   if (status === 400) return "invalid_request";
+  if (status === 402) return "insufficient_credits";
   if (status === 403) return "actions_disabled";
   if (status === 404) return "connection_not_found";
   if (status === 409) return "connection_inactive";
@@ -22016,6 +23105,7 @@ function defaultControlErrorCode(status) {
 }
 function defaultControlErrorMessage(status) {
   if (status === 400) return "The connection request was invalid.";
+  if (status === 402) return "There are not enough Credits to run this connected operation.";
   if (status === 403) return "Actions are disabled for this service connection.";
   if (status === 404) return "The service connection was not found.";
   if (status === 409) return "The service connection is not currently usable.";
@@ -22031,7 +23121,8 @@ function safeControlErrorPayload(body, responseStatus) {
   const normalizedCandidateCode = candidateCode ? CONTROL_ERROR_CODE_ALIASES.get(candidateCode) ?? candidateCode : null;
   const code = normalizedCandidateCode && SAFE_CONTROL_ERROR_CODES.has(normalizedCandidateCode) ? normalizedCandidateCode : defaultControlErrorCode(status);
   const candidateMessage = record ? firstString(record, ["error", "message"], 500) : null;
-  const message = normalizedCandidateCode && SAFE_CONTROL_ERROR_CODES.has(normalizedCandidateCode) && candidateMessage ? candidateMessage.replace(/[\u0000-\u001f\u007f]/g, " ") : defaultControlErrorMessage(status);
+  const fixedMessage = FIXED_CONTROL_ERROR_MESSAGES.get(code);
+  const message = fixedMessage ?? (normalizedCandidateCode && SAFE_CONTROL_ERROR_CODES.has(normalizedCandidateCode) && candidateMessage ? candidateMessage.replace(/[\u0000-\u001f\u007f]/g, " ") : defaultControlErrorMessage(status));
   const retryable = record && typeof record.retryable === "boolean" ? record.retryable : status === 429 || status >= 500;
   return { status, code, message, retryable };
 }
@@ -22054,10 +23145,10 @@ async function controlRequest(path5, init, timeoutMs = 2e4) {
       true
     );
   });
-  const text = await response.text();
+  const text2 = await response.text();
   let body = {};
   try {
-    body = text ? JSON.parse(text) : {};
+    body = text2 ? JSON.parse(text2) : {};
   } catch {
     body = {};
   }
@@ -22088,7 +23179,9 @@ function sanitizeScheduleConnectionSelections(value) {
   return selections;
 }
 async function getNangoCatalog() {
-  const body = await controlRequest("/api/internal/nango/catalog");
+  const body = mainOwnsIntegrations() ? { providers: await listNangoCatalogDirect().catch((error) => {
+    throw asNangoControlError(error);
+  }) } : await controlRequest("/api/internal/nango/catalog");
   const rows = arrayFromPayload(body, ["providers", "catalog", "integrations", "services"]);
   const result = [];
   for (const row of rows) {
@@ -22103,9 +23196,10 @@ async function getNangoCatalog() {
     const authMode = firstString(row, ["authMode", "auth_mode"], 100);
     const categories = cleanStringArray(row.categories);
     const disabledTools = DISABLED_NANGO_TOOLS[providerConfigKey];
-    const safeDefaultAllowedTools = cleanTools(
+    const catalogAllowedTools = cleanTools(
       row.safeDefaultAllowedTools ?? row.safe_default_allowed_tools ?? row.defaultAllowedTools ?? row.default_allowed_tools ?? row.allowedTools ?? row.allowed_tools
     ).filter((tool) => !disabledTools?.has(tool));
+    const safeDefaultAllowedTools = catalogAllowedTools.length > 0 ? catalogAllowedTools : mainOwnsIntegrations() ? [...CONNECTION_SYNC_REQUIRED_TOOLS[providerConfigKey] ?? []] : [];
     const actionTools = cleanTools(
       row.actionTools ?? row.action_tools ?? row.writeTools ?? row.write_tools
     ).filter((tool) => !disabledTools?.has(tool));
@@ -22161,8 +23255,88 @@ async function getNangoCatalog() {
   }
   return result;
 }
-async function getNangoConnections(identity) {
-  const query = new URLSearchParams({ identity }).toString();
+async function getNangoConnections(identity, options = {}) {
+  if (mainOwnsIntegrations()) {
+    let connections;
+    try {
+      connections = await discoverOwnedNangoConnections(identity);
+    } catch (error) {
+      try {
+        connections = await listServiceConnections(identity, "nango");
+      } catch {
+        throw asNangoControlError(error);
+      }
+    }
+    return Promise.all(connections.map(async (stored) => {
+      let connection = stored;
+      if (!options.summaryOnly && stored.lifecycleStatus === "connected") {
+        try {
+          connection = (await listNangoToolsDirect(identity, stored.id)).connection;
+        } catch {
+          connection = await getOwnedServiceConnection(identity, stored.id) ?? stored;
+        }
+      }
+      return {
+        connectionId: connection.id,
+        providerConfigKey: connection.providerConfigKey,
+        provider: connection.provider,
+        label: connection.label || connection.providerConfigKey,
+        providerAccountId: null,
+        providerAccountEmail: null,
+        providerAccountName: null,
+        providerIdentityStatus: "unavailable",
+        status: connection.reconnectRequired ? "needs_reauth" : "connected",
+        lifecycleStatus: connection.lifecycleStatus,
+        operationalStatus: connection.operationalStatus,
+        billingActive: connection.lifecycleStatus === "connected",
+        reconnectRequired: connection.reconnectRequired,
+        actionsEnabled: connection.actionsEnabled,
+        readTools: connection.readTools,
+        actionTools: connection.actionTools,
+        toolCapabilities: [
+          ...connection.readTools.map((name) => ({
+            name,
+            classification: "read",
+            requiredPermissions: [],
+            requiredFeatures: [],
+            available: connection.operationalStatus !== "unavailable",
+            blockedReason: null,
+            missingPermissions: [],
+            missingFeatures: []
+          })),
+          ...connection.actionTools.map((name) => ({
+            name,
+            classification: "action",
+            requiredPermissions: [],
+            requiredFeatures: [],
+            available: connection.operationalStatus !== "unavailable",
+            blockedReason: null,
+            missingPermissions: [],
+            missingFeatures: []
+          }))
+        ],
+        grantedPermissions: [],
+        enabledFeatures: [],
+        permissionVerification: null,
+        mcpEndpoint: null,
+        schemaDiscovery: "compatibility_describe",
+        toolRevision: connection.toolRevision,
+        vaultName: connection.vaultName,
+        tableName: connection.tableName,
+        createdAt: connection.createdAt,
+        updatedAt: connection.updatedAt,
+        lastCheckedAt: connection.lastCheckedAt,
+        lastSuccessfulCallAt: connection.lastSuccessfulCallAt,
+        lastFailureAt: connection.lastFailureAt,
+        lastFailureCode: connection.lastFailureCode,
+        lastFailureRetryable: connection.lastFailureRetryable
+      };
+    }));
+  }
+  const query = new URLSearchParams({
+    identity,
+    ...options.summaryOnly ? { view: "billing_summary" } : {}
+  }).toString();
   const body = await controlRequest(`/api/internal/nango/connections?${query}`);
   const rows = arrayFromPayload(body, ["connections"]);
   const result = [];
@@ -22172,7 +23346,14 @@ async function getNangoConnections(identity) {
     const providerConfigKey = firstString(row, ["providerConfigKey", "provider_config_key", "integrationId", "integration_id", "provider"]);
     if (!connectionId || !providerConfigKey) continue;
     const provider = firstString(row, ["provider"]);
-    const label = firstString(row, ["label", "accountLabel", "account_label", "displayName", "display_name", "endUserEmail", "end_user_email"]) || providerConfigKey;
+    const providerAccountId = firstString(row, ["providerAccountId", "provider_account_id"], 512);
+    const providerAccountEmail = firstString(row, ["providerAccountEmail", "provider_account_email"], 320)?.toLowerCase() ?? null;
+    const providerAccountName = firstString(row, ["providerAccountName", "provider_account_name"], 300);
+    const rawLabel = firstString(row, ["label", "accountLabel", "account_label", "displayName", "display_name"]);
+    const safeLegacyLabel = rawLabel?.toLowerCase() === identity.trim().toLowerCase() ? null : rawLabel;
+    const label = providerAccountEmail || providerAccountName || safeLegacyLabel || providerConfigKey;
+    const rawProviderIdentityStatus = firstString(row, ["providerIdentityStatus", "provider_identity_status"], 32);
+    const providerIdentityStatus = rawProviderIdentityStatus === "verified" || rawProviderIdentityStatus === "unavailable" ? rawProviderIdentityStatus : providerAccountId || providerAccountEmail || providerAccountName ? "verified" : "pending";
     const rawStatus = firstString(row, ["status"], 64) || "connected";
     const reconnectRequired = row.reconnectRequired === true || row.reconnect_required === true || rawStatus === "needs_reauth" || rawStatus === "reauth_required" || rawStatus === "invalid" || rawStatus === "error" || rawStatus === "revoked" || rawStatus === "disabled";
     const toolCapabilities = [];
@@ -22204,7 +23385,12 @@ async function getNangoConnections(identity) {
       providerConfigKey,
       provider,
       label,
+      providerAccountId,
+      providerAccountEmail,
+      providerAccountName,
+      providerIdentityStatus,
       status: reconnectRequired ? "needs_reauth" : "connected",
+      billingActive: row.billingActive !== false && row.billing_active !== false && rawStatus !== "revoked",
       reconnectRequired,
       actionsEnabled: row.actionsEnabled === true || row.actions_enabled === true,
       readTools: cleanTools(row.readTools ?? row.read_tools),
@@ -22224,6 +23410,30 @@ async function getNangoConnections(identity) {
   }
   return result;
 }
+async function deleteNangoConnection(identity, connectionId) {
+  if (mainOwnsIntegrations()) {
+    try {
+      await deleteNangoConnectionDirect(identity, connectionId);
+      await controlRequest(`/api/internal/integrations/${encodeURIComponent(connectionId)}/purge`, {
+        method: "POST",
+        body: JSON.stringify({ identity })
+      });
+      return await markServiceConnectionDisconnected(identity, connectionId);
+    } catch (error) {
+      throw asNangoControlError(error);
+    }
+  }
+  const body = await controlRequest("/api/internal/nango/connections", {
+    method: "DELETE",
+    body: JSON.stringify({ identity, connectionId })
+  });
+  const data = unwrapData(body);
+  if (!isRecord2(data) || data.ok !== true) {
+    throw new NangoControlError("The connection service returned an invalid deletion response.");
+  }
+  const remaining = Number(data.remainingConnections);
+  return Number.isSafeInteger(remaining) && remaining >= 0 ? remaining : 0;
+}
 function sanitizeConnectSession(body) {
   const data = unwrapData(body);
   if (!isRecord2(data)) throw new NangoControlError("The connection service returned an invalid connect session.");
@@ -22236,6 +23446,14 @@ function sanitizeConnectSession(body) {
   };
 }
 async function createNangoConnectSession(identity, providerConfigKey) {
+  if (mainOwnsIntegrations()) {
+    try {
+      const session = await createNangoSessionDirect(identity, providerConfigKey);
+      return { ...session, sessionToken: null };
+    } catch (error) {
+      throw asNangoControlError(error);
+    }
+  }
   const body = await controlRequest("/api/internal/nango/connect-session", {
     method: "POST",
     body: JSON.stringify({ identity, email: identity, provider: providerConfigKey })
@@ -22243,6 +23461,14 @@ async function createNangoConnectSession(identity, providerConfigKey) {
   return sanitizeConnectSession(body);
 }
 async function createNangoReconnectSession(identity, connectionId) {
+  if (mainOwnsIntegrations()) {
+    try {
+      const session = await createNangoReconnectSessionDirect(identity, connectionId);
+      return { ...session, sessionToken: null };
+    } catch (error) {
+      throw asNangoControlError(error);
+    }
+  }
   const body = await controlRequest("/api/internal/nango/reconnect-session", {
     method: "POST",
     body: JSON.stringify({ identity, connectionId, email: identity })
@@ -22296,6 +23522,7 @@ async function putScheduleConnectionBindings(identity, scheduleActionId, connect
       scheduleId: scheduleActionId,
       connections: connections.map((connection) => ({
         connectionId: connection.connectionId,
+        providerConfigKey: connection.providerConfigKey,
         allowedTools: connection.allowedTools
       }))
     })
@@ -22324,6 +23551,13 @@ async function deleteScheduleConnectionBindings(identity, scheduleActionId) {
   });
 }
 async function setScheduleConnectionActionsEnabled(identity, connectionId, enabled) {
+  if (mainOwnsIntegrations()) {
+    try {
+      return await setServiceConnectionActions(identity, connectionId, enabled);
+    } catch (error) {
+      throw asNangoControlError(error);
+    }
+  }
   const body = await controlRequest("/api/internal/nango/connections/actions/enable", {
     method: "POST",
     body: JSON.stringify({ identity, connectionId, enabled })
@@ -22332,15 +23566,71 @@ async function setScheduleConnectionActionsEnabled(identity, connectionId, enabl
   if (!isRecord2(data) || !isRecord2(data.connection)) return enabled;
   return data.connection.actionsEnabled === true;
 }
-async function callScheduleConnectionAction(identity, connectionId, input, tool) {
+async function callScheduleConnectionAction(identity, connectionId, input, tool, idempotencyKey) {
+  const requestId = `main-connected-action:${createHash10("sha256").update(identity).update("\0").update(idempotencyKey?.trim() || randomUUID12()).digest("hex")}`;
+  if (mainOwnsIntegrations()) {
+    const selectedTool = tool?.trim();
+    if (!selectedTool) throw new NangoControlError("An action tool is required.", 400, "invalid_request", false);
+    try {
+      const claim = await claimServiceConnectionAction({ identity, connectionId, tool: selectedTool, requestId });
+      if (!claim.claimed) {
+        throw new NangoControlError(
+          "The previous connected action may have completed, so it was not run again.",
+          409,
+          "action_outcome_unknown",
+          false
+        );
+      }
+      const result = await callNangoToolDirect({
+        identity,
+        connectionId,
+        tool: selectedTool,
+        input,
+        classification: "action",
+        requestId,
+        operationKind: "action"
+      });
+      await recordServiceConnectionAction({ identity, connectionId, tool: selectedTool, requestId, status: "succeeded" });
+      return result;
+    } catch (error) {
+      const normalized = asNangoControlError(error);
+      if (normalized.code !== "action_outcome_unknown") {
+        await recordServiceConnectionAction({
+          identity,
+          connectionId,
+          tool: selectedTool,
+          requestId,
+          status: normalized.retryable ? "unknown" : "failed",
+          errorCode: normalized.code
+        }).catch(() => void 0);
+      }
+      throw normalized;
+    }
+  }
   const body = await controlRequest("/api/internal/nango/connections/actions/call", {
     method: "POST",
+    headers: { "x-request-id": requestId },
     body: JSON.stringify({ identity, connectionId, ...tool ? { tool } : {}, input })
   });
   const data = unwrapData(body);
   return isRecord2(data) ? data.result ?? data : data;
 }
-async function callScheduleConnectionRead(identity, connectionId, tool, args) {
+async function callScheduleConnectionRead(identity, connectionId, tool, args, idempotencyKey) {
+  if (mainOwnsIntegrations()) {
+    try {
+      return await callNangoToolDirect({
+        identity,
+        connectionId,
+        tool,
+        input: args ?? {},
+        classification: "read",
+        requestId: idempotencyKey,
+        operationKind: "read"
+      });
+    } catch (error) {
+      throw asNangoControlError(error);
+    }
+  }
   const body = await controlRequest("/api/internal/nango/connections/actions/read", {
     method: "POST",
     body: JSON.stringify({ identity, connectionId, tool, args: args ?? {} })
@@ -22348,6 +23638,22 @@ async function callScheduleConnectionRead(identity, connectionId, tool, args) {
   const data = unwrapData(body);
   return isRecord2(data) ? data.result ?? data : data;
 }
+async function testNangoConnection(identity, connectionId) {
+  if (!mainOwnsIntegrations()) {
+    throw new NangoControlError(
+      "Connection testing requires main-MCP integration ownership.",
+      503,
+      "connection_transport_unavailable",
+      true
+    );
+  }
+  try {
+    const { tools } = await listNangoToolsDirect(identity, connectionId);
+    return { operationalStatus: "available", checkedAt: (/* @__PURE__ */ new Date()).toISOString(), toolCount: tools.length };
+  } catch (error) {
+    throw asNangoControlError(error);
+  }
+}
 function sanitizeToolSchema(value) {
   if (!isRecord2(value) || value.type !== "object") return null;
   try {
@@ -22402,9 +23708,18 @@ function canonicalJson2(value) {
   return JSON.stringify(value);
 }
 function projectedToolSchemaHash(tool) {
-  return createHash8("sha256").update(canonicalJson2(tool)).digest("hex");
+  return createHash10("sha256").update(canonicalJson2(tool)).digest("hex");
 }
 async function describeNangoTool(identity, connectionId, tool, fresh) {
+  if (mainOwnsIntegrations()) {
+    let direct;
+    try {
+      direct = await describeNangoToolDirect(identity, connectionId, tool);
+    } catch (error) {
+      throw asNangoControlError(error);
+    }
+    return sanitizeNangoToolDescription(direct, tool);
+  }
   const body = await controlRequest("/api/internal/nango/connections/actions/describe", {
     method: "POST",
     body: JSON.stringify({
@@ -22414,6 +23729,9 @@ async function describeNangoTool(identity, connectionId, tool, fresh) {
       ...fresh === void 0 ? {} : { fresh }
     })
   });
+  return sanitizeNangoToolDescription(body, tool);
+}
+function sanitizeNangoToolDescription(body, tool) {
   const data = unwrapData(body);
   const rawTool = isRecord2(data) && isRecord2(data.tool) ? data.tool : data;
   if (!isRecord2(rawTool)) {
@@ -22496,6 +23814,13 @@ async function describeNangoTool(identity, connectionId, tool, fresh) {
   };
 }
 async function callScheduleConnectionExportPage(identity, input) {
+  if (mainOwnsIntegrations()) {
+    try {
+      return await callMainOwnedExportPage(identity, input);
+    } catch (error) {
+      throw asNangoControlError(error);
+    }
+  }
   const body = await controlRequest("/api/internal/nango/connections/export-page", {
     method: "POST",
     body: JSON.stringify({ identity, ...input })
@@ -22532,6 +23857,118 @@ async function callScheduleConnectionExportPage(identity, input) {
     untrustedContent: true
   };
 }
+function unwrapMcpToolJson(value) {
+  if (!isRecord2(value)) return value;
+  if (isRecord2(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") {
+      try {
+        return JSON.parse(textPart.text);
+      } catch {
+        return textPart.text;
+      }
+    }
+  }
+  return value;
+}
+function rowsFromToolResult(value, keys) {
+  const unwrapped = unwrapMcpToolJson(value);
+  if (Array.isArray(unwrapped)) return unwrapped;
+  if (!isRecord2(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 !== "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);
+  }
+  const match = input.cursor?.match(/^gsc1:(\d{1,4}):(\d{1,5})$/);
+  if (input.cursor && !match) throw new NangoControlError("Search Console export cursor is invalid.", 400, "invalid_request", false);
+  const siteIndex = match ? Number(match[1]) : 0;
+  const startRow = match ? Number(match[2]) : 0;
+  const listed = await callNangoToolDirect({
+    identity,
+    connectionId: input.connectionId,
+    tool: "list-sites",
+    input: {},
+    classification: "read",
+    requestId: `export:${input.connectionId}:${input.dataset}:${input.from}:${input.to}:${input.cursor ?? "start"}:list-sites`,
+    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;
+    return siteUrl2 ? [siteUrl2] : [];
+  }).sort().slice(0, 1e4);
+  if (siteIndex >= sites.length) {
+    return {
+      providerConfigKey: connection.providerConfigKey,
+      dataset: "search_console_performance",
+      records: [],
+      nextCursor: null,
+      complete: true,
+      counts: { listed: 0, exported: 0, failed: 0 },
+      warnings: ["search_console_returns_top_rows_not_guaranteed_exhaustive"],
+      untrustedContent: true
+    };
+  }
+  const siteUrl = sites[siteIndex];
+  const endExclusive = new Date(input.to);
+  endExclusive.setUTCDate(endExclusive.getUTCDate() - 1);
+  const performance2 = await callNangoToolDirect({
+    identity,
+    connectionId: input.connectionId,
+    tool: "query-search-analytics",
+    input: {
+      siteUrl,
+      startDate: input.from.slice(0, 10),
+      endDate: endExclusive.toISOString().slice(0, 10),
+      dimensions: ["date", "query", "page", "country", "device"],
+      dataState: "final",
+      rowLimit: input.pageSize,
+      startRow
+    },
+    classification: "read",
+    requestId: `export:${input.connectionId}:${input.dataset}:${input.from}:${input.to}:${input.cursor ?? "start"}:query`,
+    operationKind: "export"
+  });
+  const rows = rowsFromToolResult(performance2, ["rows"]).slice(0, input.pageSize);
+  const records = rows.map((value, index) => {
+    const row = isRecord2(value) ? value : {};
+    const keys = Array.isArray(row.keys) ? row.keys.map((item) => String(item ?? "")) : [];
+    const date = keys[0] || null;
+    return {
+      id: `${siteUrl}:${startRow + index}`,
+      dataset: "search_console_performance",
+      siteUrl,
+      date,
+      occurredAt: date ? `${date}T12:00:00.000Z` : null,
+      query: keys[1] || null,
+      page: keys[2] || null,
+      country: keys[3] || null,
+      device: keys[4] || null,
+      clicks: typeof row.clicks === "number" ? row.clicks : 0,
+      impressions: typeof row.impressions === "number" ? row.impressions : 0,
+      ctr: typeof row.ctr === "number" ? row.ctr : 0,
+      position: typeof row.position === "number" ? row.position : 0
+    };
+  });
+  const nextStartRow = startRow + rows.length;
+  const nextCursor = rows.length === input.pageSize && nextStartRow < 5e4 ? `gsc1:${siteIndex}:${nextStartRow}` : siteIndex + 1 < sites.length ? `gsc1:${siteIndex + 1}:0` : null;
+  return {
+    providerConfigKey: connection.providerConfigKey,
+    dataset: "search_console_performance",
+    records,
+    nextCursor,
+    complete: nextCursor === null,
+    counts: { listed: rows.length, exported: records.length, failed: 0 },
+    warnings: ["search_console_returns_top_rows_not_guaranteed_exhaustive"],
+    untrustedContent: true
+  };
+}
 
 // src/api/resend-control.ts
 var DEFAULT_CONNECTION_CONTROL_URL = "https://mcp-scraper-scheduler.vercel.app";
@@ -22641,10 +24078,10 @@ async function controlRequest2(path5, init, timeoutMs = 2e4) {
   }).catch((err) => {
     throw new ResendControlError(`Resend connection control is unavailable: ${err instanceof Error ? err.message : "network error"}`);
   });
-  const text = await response.text();
+  const text2 = await response.text();
   let body = {};
   try {
-    body = text ? JSON.parse(text) : {};
+    body = text2 ? JSON.parse(text2) : {};
   } catch {
     body = {};
   }
@@ -22703,11 +24140,22 @@ async function getResendConnections(identity) {
     const pending = ["pending", "pending_oauth", "authorizing", "authorization_pending"].includes(rawStatus);
     const active = ["active", "connected", "ready"].includes(rawStatus);
     const reconnectRequired = row.reconnectRequired === true || row.reconnect_required === true || !pending && !active;
+    const providerAccountId = firstString2(row, ["providerAccountId", "provider_account_id"], 512);
+    const providerAccountEmail = firstString2(row, ["providerAccountEmail", "provider_account_email"], 320)?.toLowerCase() ?? null;
+    const providerAccountName = firstString2(row, ["providerAccountName", "provider_account_name"], 300);
+    const rawLabel = firstString2(row, ["label", "accountLabel", "account_label", "displayName", "display_name"]);
+    const safeLegacyLabel = rawLabel?.toLowerCase() === identity.trim().toLowerCase() ? null : rawLabel;
+    const rawProviderIdentityStatus = firstString2(row, ["providerIdentityStatus", "provider_identity_status"], 32);
+    const providerIdentityStatus = rawProviderIdentityStatus === "verified" || rawProviderIdentityStatus === "unavailable" ? rawProviderIdentityStatus : providerAccountId || providerAccountEmail || providerAccountName ? "verified" : pending ? "pending" : "unavailable";
     result.push({
       connectionId,
       providerConfigKey: RESEND_PROVIDER_CONFIG_KEY,
       provider: RESEND_PROVIDER_CONFIG_KEY,
-      label: firstString2(row, ["label", "accountLabel", "account_label", "displayName", "display_name"]) || "Resend account",
+      label: providerAccountEmail || providerAccountName || safeLegacyLabel || "Resend account",
+      providerAccountId,
+      providerAccountEmail,
+      providerAccountName,
+      providerIdentityStatus,
       status: pending ? "pending_oauth" : reconnectRequired ? "needs_reauth" : "connected",
       reconnectRequired,
       actionsEnabled: row.actionsEnabled === true || row.actions_enabled === true,
@@ -22845,6 +24293,289 @@ async function callResendExportPage(identity, input) {
   };
 }
 
+// src/api/scheduler-integration-auth.ts
+import { createHash as createHash11, createHmac as createHmac4, timingSafeEqual as timingSafeEqual3 } from "crypto";
+var MAX_CLOCK_SKEW_MS = 5 * 60 * 1e3;
+var SchedulerIntegrationAuthError = class extends Error {
+  code;
+  constructor(code) {
+    super(code);
+    this.name = "SchedulerIntegrationAuthError";
+    this.code = code;
+  }
+};
+function signingSecret() {
+  const secret2 = process.env.SCHEDULER_INTEGRATION_SIGNING_SECRET?.trim();
+  if (!secret2) throw new SchedulerIntegrationAuthError("not_configured");
+  return secret2;
+}
+function schedulerIntegrationSignature(args) {
+  const bodyHash = createHash11("sha256").update(args.body).digest("hex");
+  return createHmac4("sha256", args.secret).update(`${args.method.toUpperCase()}
+${args.path}
+${args.timestamp}
+${args.nonce}
+${bodyHash}`).digest("hex");
+}
+async function claimNonce(nonce, timestampMs) {
+  await ensureServiceConnectionsSchema();
+  await getDb().execute(`
+    CREATE TABLE IF NOT EXISTS service_connection_scheduler_nonces (
+      nonce       TEXT PRIMARY KEY,
+      expires_at  TEXT NOT NULL,
+      created_at  TEXT NOT NULL DEFAULT (datetime('now'))
+    )
+  `);
+  await getDb().execute(`DELETE FROM service_connection_scheduler_nonces WHERE expires_at < datetime('now')`);
+  try {
+    await getDb().execute({
+      sql: `INSERT INTO service_connection_scheduler_nonces (nonce, expires_at) VALUES (?, ?)`,
+      args: [nonce, new Date(timestampMs + MAX_CLOCK_SKEW_MS).toISOString()]
+    });
+  } catch {
+    throw new SchedulerIntegrationAuthError("replayed_request");
+  }
+}
+async function verifySchedulerIntegrationRequest(request, rawBody) {
+  const timestamp = request.headers.get("x-scheduler-timestamp")?.trim() ?? "";
+  const nonce = request.headers.get("x-scheduler-nonce")?.trim() ?? "";
+  const signature = request.headers.get("x-scheduler-signature")?.trim().toLowerCase() ?? "";
+  const requestId = request.headers.get("x-scheduler-request-id")?.trim() ?? "";
+  const timestampMs = Date.parse(timestamp);
+  if (!timestamp || !nonce || !signature || !requestId || nonce.length > 200 || requestId.length > 200 || !Number.isFinite(timestampMs)) {
+    throw new SchedulerIntegrationAuthError("invalid_signature");
+  }
+  if (Math.abs(Date.now() - timestampMs) > MAX_CLOCK_SKEW_MS) {
+    throw new SchedulerIntegrationAuthError("expired_request");
+  }
+  const expected = schedulerIntegrationSignature({
+    method: request.method,
+    path: new URL(request.url).pathname,
+    timestamp,
+    nonce,
+    body: rawBody,
+    secret: signingSecret()
+  });
+  const suppliedBytes = Buffer.from(signature, "hex");
+  const expectedBytes = Buffer.from(expected, "hex");
+  if (suppliedBytes.length !== expectedBytes.length || !timingSafeEqual3(suppliedBytes, expectedBytes)) {
+    throw new SchedulerIntegrationAuthError("invalid_signature");
+  }
+  await claimNonce(nonce, timestampMs);
+  return { requestId };
+}
+
+// src/api/connected-account-billing.ts
+import Stripe2 from "stripe";
+var DEFAULT_CONNECTED_ACCOUNT_PRICE_ID = "price_1TtYPAS8aAcsk3TGHOgrDZiQ";
+var STRIPE_API_VERSION = "2026-02-25.clover";
+async function ensureConnectedAccountBillingSchema() {
+  await getDb().execute(`CREATE TABLE IF NOT EXISTS connected_account_billing (
+    user_id INTEGER PRIMARY KEY,
+    stripe_subscription_id TEXT,
+    stripe_subscription_item_id TEXT,
+    price_id TEXT,
+    quantity INTEGER NOT NULL DEFAULT 0,
+    status TEXT NOT NULL DEFAULT 'pending',
+    last_error_code TEXT,
+    synced_at TEXT,
+    updated_at TEXT NOT NULL DEFAULT (datetime('now'))
+  )`);
+}
+async function getConnectedAccountBillingState(userId) {
+  await ensureConnectedAccountBillingSchema();
+  const result = await getDb().execute({
+    sql: "SELECT * FROM connected_account_billing WHERE user_id = ? LIMIT 1",
+    args: [Number(userId)]
+  });
+  return result.rows[0] ? result.rows[0] : null;
+}
+async function setConnectedAccountBillingState(input) {
+  await ensureConnectedAccountBillingSchema();
+  await getDb().execute({
+    sql: `INSERT INTO connected_account_billing
+      (user_id, stripe_subscription_id, stripe_subscription_item_id, price_id, quantity, status, last_error_code, synced_at, updated_at)
+      VALUES (?, ?, ?, ?, ?, ?, ?, CASE WHEN ? THEN datetime('now') ELSE NULL END, datetime('now'))
+      ON CONFLICT(user_id) DO UPDATE SET
+        stripe_subscription_id = excluded.stripe_subscription_id,
+        stripe_subscription_item_id = excluded.stripe_subscription_item_id,
+        price_id = excluded.price_id,
+        quantity = excluded.quantity,
+        status = excluded.status,
+        last_error_code = excluded.last_error_code,
+        synced_at = CASE WHEN ? THEN datetime('now') ELSE connected_account_billing.synced_at END,
+        updated_at = datetime('now')`,
+    args: [
+      Number(input.userId),
+      input.stripeSubscriptionId,
+      input.stripeSubscriptionItemId,
+      input.priceId,
+      input.quantity,
+      input.status,
+      input.lastErrorCode,
+      input.synced ? 1 : 0,
+      input.synced ? 1 : 0
+    ]
+  });
+  const state = await getConnectedAccountBillingState(input.userId);
+  if (!state) throw new Error("connected account billing state was not persisted");
+  return state;
+}
+var ConnectedAccountBillingError = class extends Error {
+  constructor(message, code, status = 409) {
+    super(message);
+    this.code = code;
+    this.status = status;
+    this.name = "ConnectedAccountBillingError";
+  }
+  code;
+  status;
+};
+function connectedAccountPriceId() {
+  const configured = process.env.CONNECTED_ACCOUNT_PRICE_ID?.trim();
+  if (configured) return configured;
+  return DEFAULT_CONNECTED_ACCOUNT_PRICE_ID || null;
+}
+function connectedAccountBillingView(actualQuantity, state) {
+  const quantity = Math.max(0, Math.round(actualQuantity));
+  return {
+    provider: "nango",
+    billingMode: "flat_recurring_usd_plus_credits",
+    priceId: connectedAccountPriceId(),
+    unitAmountUsd: CONNECTED_ACTIVE_CONNECTION_MONTHLY_USD,
+    interval: "month",
+    quantity,
+    projectedMonthlyUsd: quantity * CONNECTED_ACTIVE_CONNECTION_MONTHLY_USD,
+    status: state?.status ?? "pending",
+    lastErrorCode: state?.last_error_code ?? null,
+    syncedAt: state?.synced_at ?? null,
+    usage: CONNECTED_USAGE_RATE_POLICY.usage
+  };
+}
+function findBasePlanItem(subscription) {
+  return subscription.items.data.find((item) => !!item.price?.id && item.price.id in SUBSCRIPTION_TIERS);
+}
+function findConnectedAccountItem(subscription, priceId = connectedAccountPriceId()) {
+  return priceId ? subscription.items.data.find((item) => item.price?.id === priceId) : void 0;
+}
+function liveSubscription(subscription) {
+  return subscription.status === "active" || subscription.status === "trialing";
+}
+function safeStripeErrorCode(error) {
+  if (error instanceof ConnectedAccountBillingError) return error.code;
+  return "stripe_connection_billing_failed";
+}
+async function persistFailure(user, actualQuantity, error, subscriptionItemId = null) {
+  await setConnectedAccountBillingState({
+    userId: user.id,
+    stripeSubscriptionId: user.subscription_id,
+    stripeSubscriptionItemId: subscriptionItemId,
+    priceId: connectedAccountPriceId(),
+    quantity: actualQuantity,
+    status: error instanceof ConnectedAccountBillingError && error.code !== "stripe_connection_billing_failed" ? "blocked" : "error",
+    lastErrorCode: safeStripeErrorCode(error),
+    synced: false
+  });
+}
+async function reconcileConnectedAccountBilling(user, actualQuantity, stripeClient) {
+  if (!Number.isSafeInteger(actualQuantity) || actualQuantity < 0) {
+    throw new Error("actualQuantity must be a non-negative safe integer");
+  }
+  const priceId = connectedAccountPriceId();
+  if (!priceId) {
+    const error = new ConnectedAccountBillingError(
+      "Connected-account billing is not configured.",
+      "connected_account_price_not_configured",
+      503
+    );
+    await persistFailure(user, actualQuantity, error);
+    throw error;
+  }
+  if (!user.subscription_id) {
+    if (actualQuantity === 0) {
+      const state = await setConnectedAccountBillingState({
+        userId: user.id,
+        stripeSubscriptionId: null,
+        stripeSubscriptionItemId: null,
+        priceId,
+        quantity: 0,
+        status: "synced",
+        lastErrorCode: null,
+        synced: true
+      });
+      return connectedAccountBillingView(0, state);
+    }
+    const error = new ConnectedAccountBillingError(
+      "An active paid plan is required before connected accounts can be billed.",
+      "paid_plan_required",
+      403
+    );
+    await persistFailure(user, actualQuantity, error);
+    throw error;
+  }
+  const client2 = stripeClient ?? (() => {
+    const secret2 = process.env.STRIPE_SECRET_KEY?.trim();
+    if (!secret2) {
+      throw new ConnectedAccountBillingError(
+        "Stripe is not configured.",
+        "connected_account_price_not_configured",
+        503
+      );
+    }
+    return new Stripe2(secret2, { apiVersion: STRIPE_API_VERSION });
+  })();
+  let currentItem;
+  try {
+    const subscription = await client2.subscriptions.retrieve(user.subscription_id);
+    currentItem = findConnectedAccountItem(subscription, priceId);
+    if (!liveSubscription(subscription)) {
+      throw new ConnectedAccountBillingError(
+        "The plan subscription is not active.",
+        "subscription_not_active",
+        402
+      );
+    }
+    if (!findBasePlanItem(subscription)) {
+      throw new ConnectedAccountBillingError(
+        "The base plan item could not be found on this subscription.",
+        "subscription_plan_item_missing",
+        409
+      );
+    }
+    const currentQuantity = Math.max(0, currentItem?.quantity ?? 0);
+    let resultingItem = currentItem;
+    if (actualQuantity !== currentQuantity) {
+      const updated = await client2.subscriptions.update(subscription.id, {
+        items: actualQuantity === 0 ? currentItem ? [{ id: currentItem.id, deleted: true }] : [] : currentItem ? [{ id: currentItem.id, quantity: actualQuantity }] : [{ price: priceId, quantity: actualQuantity }],
+        proration_behavior: "create_prorations"
+      });
+      resultingItem = findConnectedAccountItem(updated, priceId);
+    }
+    const state = await setConnectedAccountBillingState({
+      userId: user.id,
+      stripeSubscriptionId: subscription.id,
+      stripeSubscriptionItemId: resultingItem?.id ?? null,
+      priceId,
+      quantity: actualQuantity,
+      status: "synced",
+      lastErrorCode: null,
+      synced: true
+    });
+    return connectedAccountBillingView(actualQuantity, state);
+  } catch (error) {
+    await persistFailure(user, actualQuantity, error, currentItem?.id ?? null);
+    if (error instanceof ConnectedAccountBillingError) throw error;
+    throw new ConnectedAccountBillingError(
+      "Unable to update connected-account billing in Stripe.",
+      "stripe_connection_billing_failed",
+      503
+    );
+  }
+}
+async function currentConnectedAccountBillingView(userId, actualQuantity) {
+  return connectedAccountBillingView(actualQuantity, await getConnectedAccountBillingState(userId));
+}
+
 // src/api/server.ts
 var secureCookies2 = process.env.NODE_ENV === "production" || process.env.VERCEL === "1";
 var isProduction2 = secureCookies2;
@@ -22939,7 +24670,7 @@ var requirePaidSchedulingTier = createMiddleware3(async (c, next) => {
   return next();
 });
 var app = new Hono24();
-var STRIPE_API_VERSION = "2026-02-25.clover";
+var STRIPE_API_VERSION2 = "2026-02-25.clover";
 function requireStripeSecret() {
   const secret2 = process.env.STRIPE_SECRET_KEY?.trim();
   if (secret2) return secret2;
@@ -22949,7 +24680,7 @@ function requireStripeSecret() {
 async function createSignupStripeCustomer(email) {
   const secret2 = requireStripeSecret();
   if (!secret2) return null;
-  const stripeClient = new Stripe2(secret2, { apiVersion: STRIPE_API_VERSION });
+  const stripeClient = new Stripe3(secret2, { apiVersion: STRIPE_API_VERSION2 });
   const customer = await stripeClient.customers.create({
     email,
     description: "MCP Scraper free account",
@@ -23021,7 +24752,7 @@ app.post("/auth/register", requireAllowedOrigin, async (c) => {
     const user = await createUser(normalizedEmail, void 0, password, stripeCustomerId ?? void 0);
     if (stripeCustomerId) {
       try {
-        const stripeClient = new Stripe2(process.env.STRIPE_SECRET_KEY, { apiVersion: STRIPE_API_VERSION });
+        const stripeClient = new Stripe3(process.env.STRIPE_SECRET_KEY, { apiVersion: STRIPE_API_VERSION2 });
         await stripeClient.customers.update(stripeCustomerId, {
           metadata: {
             app: "mcp-scraper",
@@ -23070,9 +24801,26 @@ app.post("/auth/logout", requireAllowedOrigin, (c) => {
 });
 app.post("/account/delete", requireAllowedOrigin, sessionAuth, async (c) => {
   const user = c.get("sessionUser");
+  if (process.env.SCHEDULE_INTEGRATIONS_SECRET?.trim()) {
+    try {
+      const [nangoConnections, resendConnections] = await Promise.all([
+        getNangoConnections(user.email, { summaryOnly: true }),
+        getResendConnections(user.email)
+      ]);
+      for (const connection of nangoConnections) {
+        await deleteNangoConnection(user.email, connection.connectionId);
+      }
+      for (const connection of resendConnections) {
+        await deleteResendConnection(user.email, connection.connectionId);
+      }
+    } catch (err) {
+      console.error("[account/delete] failed to remove provider connections", err instanceof Error ? err.message : String(err));
+      return c.json({ error: "Could not remove every connected account \u2014 please retry before deleting the account." }, 502);
+    }
+  }
   const secret2 = requireStripeSecret();
   if (secret2 && user.stripe_customer_id) {
-    const stripeClient = new Stripe2(secret2, { apiVersion: STRIPE_API_VERSION });
+    const stripeClient = new Stripe3(secret2, { apiVersion: STRIPE_API_VERSION2 });
     const subs = await stripeClient.subscriptions.list({ customer: user.stripe_customer_id, status: "all", limit: 100 });
     for (const sub of subs.data) {
       if (sub.status === "active" || sub.status === "trialing" || sub.status === "past_due") {
@@ -23397,7 +25145,7 @@ app.post("/memory/checkout", auth2, async (c) => {
     if (!priceId || !MEMORY_PLANS[priceId]) return c.json({ error: "Invalid priceId \u2014 must be a memory plan price." }, 400);
     const secret2 = process.env.STRIPE_SECRET_KEY?.trim();
     if (!secret2) return c.json({ error: "Stripe is not configured." }, 503);
-    const stripeClient = new Stripe2(secret2, { apiVersion: STRIPE_API_VERSION });
+    const stripeClient = new Stripe3(secret2, { apiVersion: STRIPE_API_VERSION2 });
     let customerId = user.stripe_customer_id;
     if (!customerId) {
       const customer = await stripeClient.customers.create({ email: user.email });
@@ -23432,7 +25180,7 @@ app.post("/memory/portal", auth2, async (c) => {
     if (!user.stripe_customer_id) return c.json({ error: "No billing account yet \u2014 subscribe first." }, 409);
     const secret2 = process.env.STRIPE_SECRET_KEY?.trim();
     if (!secret2) return c.json({ error: "Stripe is not configured." }, 503);
-    const stripeClient = new Stripe2(secret2, { apiVersion: STRIPE_API_VERSION });
+    const stripeClient = new Stripe3(secret2, { apiVersion: STRIPE_API_VERSION2 });
     const session = await stripeClient.billingPortal.sessions.create({
       customer: user.stripe_customer_id,
       return_url: `${appOrigin()}/memory`
@@ -23455,6 +25203,14 @@ app.post("/schedule-checkout", auth2, async (c) => {
 });
 function scheduleConnectionError(c, err, fallback) {
   if (err instanceof ScheduleConnectionValidationError) return c.json({ ok: false, error: err.message }, 400);
+  if (err instanceof ConnectedAccountBillingError) {
+    return c.json({
+      ok: false,
+      error: err.message,
+      code: err.code,
+      errorCode: err.code
+    }, err.status);
+  }
   if (err instanceof NangoControlError) {
     return c.json({
       ok: false,
@@ -23468,6 +25224,9 @@ function scheduleConnectionError(c, err, fallback) {
   console.error("[schedule-connections]", err instanceof Error ? err.message : String(err));
   return c.json({ ok: false, error: fallback }, 502);
 }
+function connectedActionIdempotencyKey(c) {
+  return c.req.header("idempotency-key") ?? c.req.header("x-idempotency-key");
+}
 function connectionMemoryImportError(c, err) {
   return c.json({
     ok: false,
@@ -23559,6 +25318,9 @@ async function combinedConnections(identity) {
     })) : []
   ];
 }
+function billableNangoConnectionCount(connections) {
+  return connections.filter((connection) => connection.billingActive).length;
+}
 async function isResendConnection(identity, connectionId, providerHint) {
   if (providerHint === "resend") return true;
   if (providerHint) return false;
@@ -23604,17 +25366,43 @@ app.get("/schedule-connection-catalog", auth2, async (c) => {
 app.get("/schedule-connections", auth2, async (c) => {
   try {
     const user = c.get("user");
-    return c.json({ ok: true, connections: await combinedConnections(user.email) });
+    const connections = await combinedConnections(user.email);
+    const nangoQuantity = connections.filter(
+      (connection) => connection.transport === "nango" && connection.billingActive
+    ).length;
+    return c.json({
+      ok: true,
+      connections,
+      billing: await currentConnectedAccountBillingView(user.id, nangoQuantity)
+    });
   } catch (err) {
     return scheduleConnectionError(c, err, "Unable to load service connections.");
   }
 });
+app.post("/schedule-connections/billing/reconcile", auth2, requireIntegrationsTier, async (c) => {
+  const user = c.get("user");
+  try {
+    const quantity = billableNangoConnectionCount(await getNangoConnections(user.email, { summaryOnly: true }));
+    return c.json({
+      ok: true,
+      billing: await reconcileConnectedAccountBilling(user, quantity)
+    });
+  } catch (err) {
+    return scheduleConnectionError(c, err, "Unable to synchronize connected-account billing.");
+  }
+});
 app.post("/schedule-connections/session", auth2, requireIntegrationsTier, async (c) => {
   const user = c.get("user");
   const body = await c.req.json().catch(() => ({}));
   const providerConfigKey = providerConfigKeyFrom(body.providerConfigKey);
   if (!providerConfigKey) return c.json({ ok: false, error: "providerConfigKey is required." }, 400);
   try {
+    if (providerConfigKey !== "resend") {
+      await reconcileConnectedAccountBilling(
+        user,
+        billableNangoConnectionCount(await getNangoConnections(user.email, { summaryOnly: true }))
+      );
+    }
     const session = providerConfigKey === "resend" ? await createResendConnectSession(user.email, resendOAuthCallbackUrl()) : await createNangoConnectSession(user.email, providerConfigKey);
     return c.json({ ok: true, ...session });
   } catch (err) {
@@ -23637,11 +25425,23 @@ app.delete("/schedule-connections/:id", auth2, async (c) => {
   const body = await c.req.json().catch(() => ({}));
   const providerConfigKey = providerConfigKeyFrom(body.providerConfigKey);
   try {
-    if (!await isResendConnection(user.email, c.req.param("id"), providerConfigKey)) {
-      return c.json({ ok: false, error: "Disconnect is not available for this connection type yet." }, 409);
+    if (await isResendConnection(user.email, c.req.param("id"), providerConfigKey)) {
+      await deleteResendConnection(user.email, c.req.param("id"));
+      return c.json({ ok: true, transport: "remote_mcp" });
     }
-    await deleteResendConnection(user.email, c.req.param("id"));
-    return c.json({ ok: true });
+    const remainingConnections = await deleteNangoConnection(user.email, c.req.param("id"));
+    let billing;
+    try {
+      billing = await reconcileConnectedAccountBilling(user, remainingConnections);
+    } catch (billingError2) {
+      console.error("[schedule-connections/delete/billing]", billingError2 instanceof Error ? billingError2.message : String(billingError2));
+    }
+    return c.json({
+      ok: true,
+      transport: "nango",
+      remainingConnections,
+      billing: billing ?? await currentConnectedAccountBillingView(user.id, remainingConnections)
+    });
   } catch (err) {
     return scheduleConnectionError(c, err, "Unable to disconnect this service connection.");
   }
@@ -23658,6 +25458,72 @@ app.post("/schedule-connections/:id/enable-actions", auth2, requireIntegrationsT
     return scheduleConnectionError(c, err, "Unable to update this connection's action setting.");
   }
 });
+app.post("/schedule-connections/:id/test", auth2, requireIntegrationsTier, async (c) => {
+  const user = c.get("user");
+  const body = await c.req.json().catch(() => ({}));
+  const providerConfigKey = providerConfigKeyFrom(body.providerConfigKey);
+  try {
+    if (await isResendConnection(user.email, c.req.param("id"), providerConfigKey)) {
+      return c.json({
+        ok: false,
+        code: "connection_test_not_supported",
+        error: "Resend connection testing will be enabled after its credential migration to the main MCP."
+      }, 409);
+    }
+    return c.json({ ok: true, ...await testNangoConnection(user.email, c.req.param("id")) });
+  } catch (err) {
+    return scheduleConnectionError(c, err, "Unable to test this service connection.");
+  }
+});
+function schedulerIntegrationAuthError(c, error) {
+  if (error instanceof SchedulerIntegrationAuthError) {
+    const status = error.code === "not_configured" ? 503 : error.code === "replayed_request" ? 409 : 401;
+    return c.json({ ok: false, code: error.code, error: "Scheduler integration authorization failed." }, status);
+  }
+  return scheduleConnectionError(c, error, "The scheduler integration request failed.");
+}
+app.post("/api/internal/integrations/:id/describe", async (c) => {
+  const rawBody = await c.req.text();
+  try {
+    await verifySchedulerIntegrationRequest(c.req.raw, rawBody);
+    const body = JSON.parse(rawBody);
+    const identity = typeof body.identity === "string" ? body.identity.trim() : "";
+    const tool = providerConfigKeyFrom(body.tool);
+    if (!identity || !tool) return c.json({ ok: false, code: "invalid_request", error: "identity and tool are required." }, 400);
+    return c.json({ ok: true, tool: await describeNangoTool(identity, c.req.param("id"), tool, true) });
+  } catch (error) {
+    return schedulerIntegrationAuthError(c, error);
+  }
+});
+app.post("/api/internal/integrations/:id/execute", async (c) => {
+  const rawBody = await c.req.text();
+  try {
+    const authResult = await verifySchedulerIntegrationRequest(c.req.raw, rawBody);
+    const body = JSON.parse(rawBody);
+    const identity = typeof body.identity === "string" ? body.identity.trim() : "";
+    const tool = providerConfigKeyFrom(body.tool);
+    const args = body.args && typeof body.args === "object" && !Array.isArray(body.args) ? body.args : null;
+    if (!identity || !tool || !args || body.classification !== "read" && body.classification !== "action") {
+      return c.json({ ok: false, code: "invalid_request", error: "identity, tool, classification, and args are required." }, 400);
+    }
+    const result = body.classification === "action" ? await callScheduleConnectionAction(identity, c.req.param("id"), args, tool, authResult.requestId) : await callScheduleConnectionRead(identity, c.req.param("id"), tool, args, authResult.requestId);
+    return c.json({ ok: true, result });
+  } catch (error) {
+    return schedulerIntegrationAuthError(c, error);
+  }
+});
+app.post("/api/internal/integrations/:id/test", async (c) => {
+  const rawBody = await c.req.text();
+  try {
+    await verifySchedulerIntegrationRequest(c.req.raw, rawBody);
+    const body = JSON.parse(rawBody);
+    const identity = typeof body.identity === "string" ? body.identity.trim() : "";
+    if (!identity) return c.json({ ok: false, code: "invalid_request", error: "identity is required." }, 400);
+    return c.json({ ok: true, ...await testNangoConnection(identity, c.req.param("id")) });
+  } catch (error) {
+    return schedulerIntegrationAuthError(c, error);
+  }
+});
 app.get("/oauth/resend/callback", async (c) => {
   const code = c.req.query("code")?.trim();
   const state = c.req.query("state")?.trim();
@@ -23690,7 +25556,13 @@ app.post("/schedule-connections/actions/slack/send-message", auth2, requireInteg
     return c.json({ ok: false, error: "connectionId, channel, and text are required." }, 400);
   }
   try {
-    const result = await callScheduleConnectionAction(user.email, connectionId, { channel: body.channel, text: body.text });
+    const result = await callScheduleConnectionAction(
+      user.email,
+      connectionId,
+      { channel: body.channel, text: body.text },
+      void 0,
+      connectedActionIdempotencyKey(c)
+    );
     return c.json({ ok: true, result });
   } catch (err) {
     return scheduleConnectionError(c, err, "Unable to send the Slack message.");
@@ -23704,7 +25576,13 @@ app.post("/schedule-connections/actions/gmail/send-message", auth2, requireInteg
     return c.json({ ok: false, error: "connectionId, to, subject, and body are required." }, 400);
   }
   try {
-    const result = await callScheduleConnectionAction(user.email, connectionId, { to: body.to, subject: body.subject, body: body.body });
+    const result = await callScheduleConnectionAction(
+      user.email,
+      connectionId,
+      { to: body.to, subject: body.subject, body: body.body },
+      void 0,
+      connectedActionIdempotencyKey(c)
+    );
     return c.json({ ok: true, result });
   } catch (err) {
     return scheduleConnectionError(c, err, "Unable to send the email.");
@@ -23728,7 +25606,7 @@ app.post("/schedule-connections/actions/google-calendar/create-event", auth2, re
       start: { dateTime: body.startDateTime, timeZone },
       end: { dateTime: body.endDateTime, timeZone },
       attendees
-    });
+    }, void 0, connectedActionIdempotencyKey(c));
     return c.json({ ok: true, result });
   } catch (err) {
     return scheduleConnectionError(c, err, "Unable to create the calendar event.");
@@ -23748,7 +25626,7 @@ app.post("/schedule-connections/actions/zoom/create-meeting", auth2, requireInte
       durationMinutes: typeof body.durationMinutes === "number" ? body.durationMinutes : 30,
       timezone: typeof body.timezone === "string" ? body.timezone : void 0,
       agenda: body.agenda
-    });
+    }, void 0, connectedActionIdempotencyKey(c));
     return c.json({ ok: true, result });
   } catch (err) {
     return scheduleConnectionError(c, err, "Unable to create the Zoom meeting.");
@@ -23961,13 +25839,31 @@ app.post("/schedule-connections/actions/call", auth2, requireIntegrationsTier, a
       user.email,
       connectionId,
       body.args,
-      tool
+      tool,
+      connectedActionIdempotencyKey(c)
     );
     return c.json({ ok: true, result });
   } catch (err) {
     return scheduleConnectionError(c, err, "Unable to run this connection action.");
   }
 });
+async function forwardIntegrationAlias(c, targetPath) {
+  const url = new URL(c.req.url);
+  url.pathname = targetPath;
+  return await app.fetch(new Request(url, c.req.raw));
+}
+app.get("/integrations", (c) => forwardIntegrationAlias(c, "/schedule-connections"));
+app.get("/integrations/catalog", (c) => forwardIntegrationAlias(c, "/schedule-connection-catalog"));
+app.post("/integrations/session", (c) => forwardIntegrationAlias(c, "/schedule-connections/session"));
+app.post("/integrations/billing/reconcile", (c) => forwardIntegrationAlias(c, "/schedule-connections/billing/reconcile"));
+app.post("/integrations/:id/reconnect-session", (c) => forwardIntegrationAlias(c, `/schedule-connections/${encodeURIComponent(c.req.param("id"))}/reconnect-session`));
+app.post("/integrations/:id/enable-actions", (c) => forwardIntegrationAlias(c, `/schedule-connections/${encodeURIComponent(c.req.param("id"))}/enable-actions`));
+app.post("/integrations/:id/test", (c) => forwardIntegrationAlias(c, `/schedule-connections/${encodeURIComponent(c.req.param("id"))}/test`));
+app.delete("/integrations/:id", (c) => forwardIntegrationAlias(c, `/schedule-connections/${encodeURIComponent(c.req.param("id"))}`));
+app.post("/integrations/actions/read", (c) => forwardIntegrationAlias(c, "/schedule-connections/actions/read"));
+app.post("/integrations/actions/describe", (c) => forwardIntegrationAlias(c, "/schedule-connections/actions/describe"));
+app.post("/integrations/actions/call", (c) => forwardIntegrationAlias(c, "/schedule-connections/actions/call"));
+app.post("/integrations/actions/export", (c) => forwardIntegrationAlias(c, "/schedule-connections/actions/export"));
 app.post("/schedule-link", auth2, requirePaidSchedulingTier, async (c) => {
   try {
     const user = c.get("user");
@@ -24733,7 +26629,7 @@ app.post("/billing/concurrency/checkout", requireAllowedOrigin, sessionAuth, asy
     if (user.concurrency_stripe_sub_id) return c.json({ error: "Already subscribed \u2014 cancel existing slot first to change." }, 409);
     const secret2 = process.env.STRIPE_SECRET_KEY?.trim();
     if (!secret2) return c.json({ error: "Stripe is not configured." }, 503);
-    const stripeClient = new Stripe2(secret2, { apiVersion: STRIPE_API_VERSION });
+    const stripeClient = new Stripe3(secret2, { apiVersion: STRIPE_API_VERSION2 });
     let customerId = user.stripe_customer_id;
     if (!customerId) {
       const customer = await stripeClient.customers.create({ email: user.email });
@@ -24766,7 +26662,7 @@ app.post("/billing/subscribe", requireAllowedOrigin, sessionAuth, async (c) => {
     if (!tier) return c.json({ error: "Invalid tier. Choose starter, growth, or scale." }, 400);
     const secret2 = process.env.STRIPE_SECRET_KEY?.trim();
     if (!secret2) return c.json({ error: "Stripe is not configured." }, 503);
-    const stripeClient = new Stripe2(secret2, { apiVersion: STRIPE_API_VERSION });
+    const stripeClient = new Stripe3(secret2, { apiVersion: STRIPE_API_VERSION2 });
     let customerId = user.stripe_customer_id;
     if (!customerId) {
       const customer = await stripeClient.customers.create({ email: user.email });
@@ -24775,7 +26671,7 @@ app.post("/billing/subscribe", requireAllowedOrigin, sessionAuth, async (c) => {
     }
     if (user.subscription_id) {
       const sub = await stripeClient.subscriptions.retrieve(user.subscription_id);
-      const itemId = sub.items.data[0]?.id;
+      const itemId = findBasePlanItem(sub)?.id;
       if (itemId) {
         await stripeClient.subscriptions.update(user.subscription_id, {
           items: [{ id: itemId, price: tier.price_id }],
@@ -24809,7 +26705,7 @@ app.post("/billing/portal", requireAllowedOrigin, sessionAuth, async (c) => {
     if (!user.stripe_customer_id) return c.json({ error: "No billing account yet \u2014 subscribe first." }, 409);
     const secret2 = requireStripeSecret();
     if (!secret2) return c.json({ error: "Stripe is not configured." }, 503);
-    const stripeClient = new Stripe2(secret2, { apiVersion: STRIPE_API_VERSION });
+    const stripeClient = new Stripe3(secret2, { apiVersion: STRIPE_API_VERSION2 });
     const session = await stripeClient.billingPortal.sessions.create({
       customer: user.stripe_customer_id,
       return_url: `${appOrigin()}/billing`
@@ -24839,7 +26735,7 @@ app.post("/billing/concurrency/terminal-checkout", auth2, async (c) => {
     }
     const secret2 = process.env.STRIPE_SECRET_KEY?.trim();
     if (!secret2) return c.json({ error: "Stripe is not configured." }, 503);
-    const stripeClient = new Stripe2(secret2, { apiVersion: STRIPE_API_VERSION });
+    const stripeClient = new Stripe3(secret2, { apiVersion: STRIPE_API_VERSION2 });
     let customerId = user.stripe_customer_id;
     if (!customerId) {
       const customer = await stripeClient.customers.create({ email: user.email });
@@ -24883,7 +26779,7 @@ app.post("/billing/subscribe/terminal-checkout", auth2, async (c) => {
     if (!tier) return c.json({ error: "Invalid tier. Choose starter, growth, or scale.", tiers: Object.keys(SUBSCRIPTION_TIER_BY_KEY) }, 400);
     const secret2 = process.env.STRIPE_SECRET_KEY?.trim();
     if (!secret2) return c.json({ error: "Stripe is not configured." }, 503);
-    const stripeClient = new Stripe2(secret2, { apiVersion: STRIPE_API_VERSION });
+    const stripeClient = new Stripe3(secret2, { apiVersion: STRIPE_API_VERSION2 });
     let customerId = user.stripe_customer_id;
     if (!customerId) {
       const customer = await stripeClient.customers.create({ email: user.email });
@@ -24892,7 +26788,7 @@ app.post("/billing/subscribe/terminal-checkout", auth2, async (c) => {
     }
     if (user.subscription_id) {
       const sub = await stripeClient.subscriptions.retrieve(user.subscription_id);
-      const itemId = sub.items.data[0]?.id;
+      const itemId = findBasePlanItem(sub)?.id;
       if (itemId) {
         await stripeClient.subscriptions.update(user.subscription_id, {
           items: [{ id: itemId, price: tier.price_id }],
@@ -24935,7 +26831,7 @@ app.post("/billing/concurrency/cancel", requireAllowedOrigin, sessionAuth, async
   if (!user.concurrency_stripe_sub_id) return c.json({ error: "No active concurrency subscription." }, 404);
   const stripeSecret = process.env.STRIPE_SECRET_KEY?.trim();
   if (!stripeSecret) return c.json({ error: "Stripe is not configured." }, 503);
-  const stripeClient = new Stripe2(stripeSecret, { apiVersion: STRIPE_API_VERSION });
+  const stripeClient = new Stripe3(stripeSecret, { apiVersion: STRIPE_API_VERSION2 });
   await stripeClient.subscriptions.cancel(user.concurrency_stripe_sub_id);
   const nextSlots = Math.max(0, user.extra_concurrency_slots - 1);
   await setExtraConcurrencySlots(user.id, nextSlots);
@@ -24954,6 +26850,13 @@ app.get("/billing/balance", auth2, async (c) => {
     ledger
   });
 });
+app.get("/billing/connected-usage/history", auth2, async (c) => {
+  return c.json({
+    ok: true,
+    ratePolicy: CONNECTED_USAGE_RATE_POLICY,
+    receipts: await listConnectedUsageHistory(c.get("user").id, 100)
+  });
+});
 app.post("/billing/credits", auth2, async (c) => {
   const user = c.get("user");
   const balanceMc = user.balance_mc;
@@ -24981,6 +26884,7 @@ app.post("/billing/credits", auth2, async (c) => {
       has_subscription: !!user.concurrency_stripe_sub_id,
       upgrade: concurrencySlotBillingInfo()
     },
+    connected_accounts: CONNECTED_USAGE_RATE_POLICY,
     ledger
   });
 });
@@ -24989,7 +26893,7 @@ 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-RV2TYXE3.js");
+  const { drainQueue } = await import("./worker-E3KHQH2F.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] = await Promise.all([
@@ -25017,7 +26921,7 @@ app.post("/api/internal/extract-refinalize/:id", async (c) => {
     return c.json({ error: "Unauthorized" }, 401);
   }
   const jobId = c.req.param("id");
-  const { getExtractJob: getExtractJob2, completeExtractJob: completeExtractJob2 } = await import("./site-extract-repository-2QQSL2QC.js");
+  const { getExtractJob: getExtractJob2, completeExtractJob: completeExtractJob2 } = await import("./site-extract-repository-O36SIFI2.js");
   const { assembleExtractArtifacts } = await import("./extract-bundle-NFFVMUMT.js");
   const job = await getExtractJob2(jobId);
   if (!job) return c.json({ error: "job not found" }, 404);
@@ -25025,7 +26929,7 @@ app.post("/api/internal/extract-refinalize/:id", async (c) => {
   await completeExtractJob2(jobId, stored);
   let settlement = "already_settled_or_refunded";
   if (job.billedMc == null && job.userId != null) {
-    const { settleExtractJob: settleExtractJob2, countSuccessfulPages: countSuccessfulPages2 } = await import("./site-extract-repository-2QQSL2QC.js");
+    const { settleExtractJob: settleExtractJob2, countSuccessfulPages: countSuccessfulPages2 } = await import("./site-extract-repository-O36SIFI2.js");
     const heldMc = Number(job.options.heldMc ?? 0);
     const successful = await countSuccessfulPages2(jobId);
     const usedMc = Math.min(successful * MC_COSTS.page_scrape, heldMc);
@@ -25191,4 +27095,4 @@ app.get("/blog/:slug/", (c) => {
 export {
   app
 };
-//# sourceMappingURL=server-PILR3U5E.js.map
+//# sourceMappingURL=server-UHDJ5TH5.js.map