mcp-scraper 0.19.0 → 0.21.0

package/dist/{server-VWXDE64Y.js → server-PH3VJ74X.js}

@@ -1,9 +1,12 @@
+import {
+  harvestPageMedia
+} from "./chunk-JWIE5NCR.js";
 import {
   classifyHarvestProblem,
   createHarvestAttemptRecorder,
   harvestProblemResponse,
   serializeHarvestProblem
-} from "./chunk-HE2LQPJ2.js";
+} from "./chunk-JBME5WJR.js";
 import {
   BrowserDriver,
   MapsSelectors,
@@ -11,7 +14,7 @@ import {
   deleteKernelProxyId,
   harvest,
   resolveKernelProxyId
-} from "./chunk-2HDMYW4B.js";
+} from "./chunk-ZJDANZTQ.js";
 import {
   HttpMcpToolExecutor,
   MemoryMcpToolExecutor,
@@ -32,7 +35,7 @@ import {
   sanitizeAttempts,
   sanitizeHarvestResult,
   transcribeMediaUrl
-} from "./chunk-O2S5TOCG.js";
+} from "./chunk-XHJJQRNQ.js";
 import {
   auditImages,
   buildLinkReport,
@@ -50,7 +53,7 @@ import {
   recordKernelSession,
   recordVendorUsage,
   runWithCostContext
-} from "./chunk-D7ZT27HY.js";
+} from "./chunk-GMZFQRH2.js";
 import {
   csvRecords,
   listWorkflowDefinitions,
@@ -74,7 +77,7 @@ import {
   RawMapsOverviewSchema,
   RawMapsReviewStatsSchema
 } from "./chunk-XGIPATLV.js";
-import "./chunk-OQHYDW4Q.js";
+import "./chunk-L4LMSXLO.js";
 import {
   completeExtractJob,
   countSuccessfulPages,
@@ -85,7 +88,7 @@ import {
   saveExtractPages,
   setExtractJobTotal,
   settleExtractJob
-} from "./chunk-RUGJE5EB.js";
+} from "./chunk-TUSLATZY.js";
 import {
   BROWSER_OPEN_MIN_BALANCE_MC,
   CONCURRENCY_PRICE_ID,
@@ -100,15 +103,22 @@ import {
   MEMORY_AI_MARGIN_MULTIPLE,
   MEMORY_PLANS,
   MEMORY_PLAN_QUOTA,
+  SCHEDULED_AGENT_LLM_MARKUP,
+  SCHEDULED_AGENT_LLM_MARKUP_BPS,
+  SCHEDULED_RUN_BASE_CREDITS,
+  SCHEDULED_RUN_BASE_MC,
+  SCHEDULED_RUN_DEFAULT_MAX_CREDITS,
   SCHEDULING_PLANS,
   SITE_AUDIT_LLM_MARGIN_MULTIPLE,
   SUBSCRIPTION_TIERS,
   SUBSCRIPTION_TIER_BY_KEY,
+  USD_NANOS,
   VIDEO_ANALYSIS_LLM_MARGIN_MULTIPLE,
   browserActiveCostMc,
   concurrencySlotBillingInfo,
-  insufficientBalanceResponse
-} from "./chunk-HL33CGJF.js";
+  insufficientBalanceResponse,
+  vendorCostUsdToMc
+} from "./chunk-HXGZMMW5.js";
 import {
   CaptchaError,
   RECAPTCHA_INSTRUCTIONS,
@@ -191,7 +201,7 @@ import {
   setUserMemoryCreds,
   upsertPageSnapshot,
   verifyPassword
-} from "./chunk-GL4BW4CP.js";
+} from "./chunk-DZBGULWW.js";
 
 // src/blog/registry.ts
 var posts = [
@@ -4226,285 +4236,6 @@ async function capturePageData(url, opts = {}) {
   }
 }
 
-// src/lib/media-extractor.ts
-import { createWriteStream, mkdirSync } from "fs";
-import { homedir } from "os";
-import { join as join2, extname, basename } from "path";
-import { pipeline } from "stream/promises";
-import { Readable } from "stream";
-var AD_PATTERNS = [
-  "doubleclick.net",
-  "googlesyndication.com",
-  "googletagmanager.com",
-  "google-analytics.com",
-  "googletagservices.com",
-  "adservice.google",
-  "googletag.",
-  "pagead2.googlesyndication",
-  "facebook.net/tr",
-  "connect.facebook.net",
-  "fbcdn.net/rsrc",
-  "analytics.twitter.com",
-  "static.ads-twitter.com",
-  "ads.twitter.com",
-  "t.co/i/adsct",
-  "pixel.advertising.com",
-  "hotjar.com",
-  "clarity.ms",
-  "quantserve.com",
-  "scorecardresearch.com",
-  "newrelic.com",
-  "nr-data.net",
-  "segment.io",
-  "segment.com",
-  "amplitude.com",
-  "mixpanel.com",
-  "heap.io",
-  "fullstory.com",
-  "moatads.com",
-  "criteo.com",
-  "adsrvr.org",
-  "rubiconproject.com",
-  "pubmatic.com",
-  "openx.net",
-  "appnexus.com",
-  "amazon-adsystem.com",
-  "media.net",
-  "yieldmo.com",
-  "triplelift.com",
-  "sharethrough.com",
-  "prebid.",
-  "smaato.net",
-  "indexworm.com",
-  "casalemedia.com",
-  "outbrain.com",
-  "taboola.com",
-  "revcontent.com",
-  "mgid.com",
-  "tawk.to",
-  "intercom.io",
-  "drift.com",
-  "hs-scripts.com",
-  "zopim.com",
-  "livechatinc.com",
-  "userlike.com",
-  "onetrust.com",
-  "cookielaw.org",
-  "cookieinformation.com",
-  "trustarc.com",
-  "/ads/",
-  "/ad/",
-  "/banner/",
-  "/banners/",
-  "/pixel/",
-  "/beacon/",
-  "/tracking/",
-  "/tracker/",
-  "/remarketing/",
-  "/conversion/",
-  "1x1.gif",
-  "spacer.gif",
-  "blank.gif",
-  "transparent.gif"
-];
-var IMAGE_EXTS = /* @__PURE__ */ new Set([".jpg", ".jpeg", ".png", ".webp", ".gif", ".avif", ".svg", ".tiff"]);
-var VIDEO_EXTS = /* @__PURE__ */ new Set([".mp4", ".webm", ".mov", ".avi", ".m4v", ".ogv", ".mkv"]);
-var AUDIO_EXTS = /* @__PURE__ */ new Set([".mp3", ".wav", ".ogg", ".aac", ".m4a", ".flac", ".opus"]);
-function isAdUrl(url) {
-  const lower = url.toLowerCase();
-  return AD_PATTERNS.some((p) => lower.includes(p));
-}
-function isDataUri(url) {
-  return url.startsWith("data:");
-}
-function typeFromUrl(url) {
-  try {
-    const ext = extname(new URL(url).pathname).toLowerCase();
-    if (IMAGE_EXTS.has(ext)) return "image";
-    if (VIDEO_EXTS.has(ext)) return "video";
-    if (AUDIO_EXTS.has(ext)) return "audio";
-  } catch {
-  }
-  return null;
-}
-function typeFromMime(mime) {
-  const lower = mime.toLowerCase();
-  if (lower.startsWith("image/")) return "image";
-  if (lower.startsWith("video/")) return "video";
-  if (lower.startsWith("audio/")) return "audio";
-  return null;
-}
-function resolveUrl(raw, base) {
-  if (!raw || isDataUri(raw)) return null;
-  try {
-    return new URL(raw, base).href;
-  } catch {
-    return null;
-  }
-}
-function safeFilename(url, index) {
-  try {
-    const u = new URL(url);
-    const base = basename(u.pathname).replace(/[^a-zA-Z0-9._-]/g, "_").slice(0, 80);
-    return base || `asset-${index}`;
-  } catch {
-    return `asset-${index}`;
-  }
-}
-function extractMediaUrls(html, baseUrl) {
-  const seen = /* @__PURE__ */ new Set();
-  const urls = [];
-  const add = (raw) => {
-    const resolved = resolveUrl(raw.trim(), baseUrl);
-    if (!resolved || seen.has(resolved) || isAdUrl(resolved)) return;
-    seen.add(resolved);
-    urls.push(resolved);
-  };
-  for (const m of html.matchAll(/<img\s[^>]*>/gi)) {
-    const tag = m[0];
-    for (const attr of ["src", "data-src", "data-lazy-src", "data-original"]) {
-      const v = (tag.match(new RegExp(`\\b${attr}\\s*=\\s*["']([^"']+)["']`, "i")) ?? [])[1];
-      if (v) add(v);
-    }
-    const srcset = (tag.match(/\bsrcset\s*=\s*["']([^"']+)["']/i) ?? [])[1];
-    if (srcset) {
-      for (const part of srcset.split(",")) {
-        const u = part.trim().split(/\s+/)[0];
-        if (u) add(u);
-      }
-    }
-  }
-  for (const m of html.matchAll(/<source\s[^>]*>/gi)) {
-    const tag = m[0];
-    const src = (tag.match(/\bsrc\s*=\s*["']([^"']+)["']/i) ?? [])[1];
-    if (src) add(src);
-    const srcset = (tag.match(/\bsrcset\s*=\s*["']([^"']+)["']/i) ?? [])[1];
-    if (srcset) {
-      for (const part of srcset.split(",")) {
-        const u = part.trim().split(/\s+/)[0];
-        if (u) add(u);
-      }
-    }
-  }
-  for (const m of html.matchAll(/<video\s[^>]*>/gi)) {
-    const tag = m[0];
-    for (const attr of ["src", "poster"]) {
-      const v = (tag.match(new RegExp(`\\b${attr}\\s*=\\s*["']([^"']+)["']`, "i")) ?? [])[1];
-      if (v) add(v);
-    }
-  }
-  for (const m of html.matchAll(/<audio\s[^>]*>/gi)) {
-    const tag = m[0];
-    const v = (tag.match(/\bsrc\s*=\s*["']([^"']+)["']/i) ?? [])[1];
-    if (v) add(v);
-  }
-  for (const m of html.matchAll(/<meta\s[^>]*>/gi)) {
-    const tag = m[0];
-    const prop = (tag.match(/\b(?:property|name)\s*=\s*["']([^"']+)["']/i) ?? [])[1]?.toLowerCase();
-    if (prop === "og:image" || prop === "twitter:image") {
-      const content = (tag.match(/\bcontent\s*=\s*["']([^"']+)["']/i) ?? [])[1];
-      if (content) add(content);
-    }
-  }
-  for (const m of html.matchAll(/background(?:-image)?\s*:\s*url\(\s*["']?([^"')]+)["']?\s*\)/gi)) {
-    add(m[1]);
-  }
-  return urls;
-}
-async function downloadAsset(url, destDir, filename) {
-  const res = await fetch(url, {
-    headers: { "User-Agent": "Mozilla/5.0 (compatible; ThorbitBot/1.0)" },
-    signal: AbortSignal.timeout(15e3)
-  });
-  if (!res.ok) throw new Error(`HTTP ${res.status}`);
-  if (!res.body) throw new Error("Empty response body");
-  const mimeType = res.headers.get("content-type")?.split(";")[0].trim() ?? null;
-  let dest = join2(destDir, filename);
-  if (mimeType && !extname(filename)) {
-    const mimeExt = {
-      "image/jpeg": ".jpg",
-      "image/png": ".png",
-      "image/webp": ".webp",
-      "image/gif": ".gif",
-      "image/svg+xml": ".svg",
-      "image/avif": ".avif",
-      "video/mp4": ".mp4",
-      "video/webm": ".webm",
-      "audio/mpeg": ".mp3",
-      "audio/ogg": ".ogg",
-      "audio/wav": ".wav"
-    };
-    const ext = mimeExt[mimeType];
-    if (ext) dest = dest + ext;
-  }
-  const writer = createWriteStream(dest);
-  await pipeline(Readable.fromWeb(res.body), writer);
-  const { statSync } = await import("fs");
-  const sizeBytes = statSync(dest).size;
-  return { savedPath: dest, sizeBytes, mimeType };
-}
-async function harvestPageMedia(html, pageUrl, options = {}) {
-  const types = options.types ?? ["image", "video", "audio"];
-  const typesSet = new Set(types);
-  const rawUrls = extractMediaUrls(html, pageUrl);
-  const totalFound = rawUrls.length;
-  const filteredUrls = [];
-  const kept = [];
-  for (const url of rawUrls) {
-    const type = typeFromUrl(url);
-    if (!type || !typesSet.has(type)) {
-      filteredUrls.push(url);
-      continue;
-    }
-    kept.push({ url, type });
-  }
-  if (options.outputDir === null) {
-    return {
-      pageUrl,
-      outputDir: null,
-      assets: kept.map(({ url, type }, i) => ({
-        url,
-        type,
-        mimeType: null,
-        filename: safeFilename(url, i),
-        savedPath: null,
-        sizeBytes: null
-      })),
-      filteredCount: filteredUrls.length,
-      totalFound
-    };
-  }
-  const domain = (() => {
-    try {
-      return new URL(pageUrl).hostname.replace(/^www\./, "");
-    } catch {
-      return "unknown";
-    }
-  })();
-  const stamp = (/* @__PURE__ */ new Date()).toISOString().replace(/[:.]/g, "-").slice(0, 19);
-  const outDir = options.outputDir ?? join2(homedir(), "Downloads", "mcp-scraper", "media", `${stamp}-${domain}`);
-  mkdirSync(outDir, { recursive: true });
-  const assets = [];
-  await Promise.allSettled(
-    kept.map(async ({ url, type }, i) => {
-      const filename = safeFilename(url, i);
-      try {
-        const { savedPath, sizeBytes, mimeType } = await downloadAsset(url, outDir, filename);
-        const resolvedType = mimeType ? typeFromMime(mimeType) ?? type : type;
-        assets.push({ url, type: resolvedType, mimeType, filename: basename(savedPath), savedPath, sizeBytes });
-      } catch {
-        assets.push({ url, type, mimeType: null, filename, savedPath: null, sizeBytes: null });
-      }
-    })
-  );
-  assets.sort((a, b) => {
-    if (a.savedPath && !b.savedPath) return -1;
-    if (!a.savedPath && b.savedPath) return 1;
-    return a.url.localeCompare(b.url);
-  });
-  return { pageUrl, outputDir: outDir, assets, filteredCount: filteredUrls.length, totalFound };
-}
-
 // src/api/site-mapper.ts
 var SKIP_EXTENSIONS = /* @__PURE__ */ new Set([
   "jpg",
@@ -5322,7 +5053,7 @@ async function extractSite(opts) {
 }
 
 // src/api/server.ts
-import { Hono as Hono23 } from "hono";
+import { Hono as Hono24 } from "hono";
 import { serve as serveInngest } from "inngest/hono";
 
 // src/inngest/client.ts
@@ -7628,7 +7359,7 @@ var siteExtractFn = inngest.createFunction(
       return buildSeoAudit(pages, job.startUrl);
     }) : null;
     const artifacts = await step.run("finalize", async () => {
-      const { assembleExtractArtifacts } = await import("./extract-bundle-U4D5LW5W.js");
+      const { assembleExtractArtifacts } = await import("./extract-bundle-HMCYUVBJ.js");
       const stored = await assembleExtractArtifacts(job, { branding, imageAudit, seoAudit });
       await completeExtractJob(jobId, stored);
       return stored;
@@ -8248,8 +7979,479 @@ internalMemoryApp.post("/ai-debit", async (c) => {
   return c.json({ ok, mc, balance_mc, insufficient: !ok }, 200);
 });
 
-// src/api/youtube-routes.ts
+// src/api/internal-billing-routes.ts
 import { Hono as Hono3 } from "hono";
+import { z as z10 } from "zod";
+
+// src/api/unified-billing.ts
+import { createHash as createHash2, createHmac, randomUUID, timingSafeEqual } from "crypto";
+var SCHEDULED_RUN_BILLING_CLASS = "scheduled_agent_run";
+var SCHEDULED_RUN_SOURCE_SURFACE = "mastra_scheduler";
+var AUTHORIZATION_TTL_MS = 30 * 60 * 1e3;
+var UnifiedBillingError = class extends Error {
+  constructor(code, message, httpStatus, details = {}) {
+    super(message);
+    this.code = code;
+    this.httpStatus = httpStatus;
+    this.details = details;
+    this.name = "UnifiedBillingError";
+  }
+  code;
+  httpStatus;
+  details;
+};
+function billingSecret() {
+  const secret2 = process.env.INTERNAL_BILLING_SECRET ?? process.env.INTERNAL_MEMORY_DEBIT_SECRET;
+  if (!secret2) throw new UnifiedBillingError("unauthorized", "internal billing secret is not configured", 503);
+  return secret2;
+}
+function normalizeIdentity(identity) {
+  const normalized = identity.trim().toLowerCase();
+  if (!normalized || normalized.length > 320) {
+    throw new UnifiedBillingError("invalid_request", "identity is required", 400);
+  }
+  return normalized;
+}
+function normalizeIdempotencyKey(value) {
+  const key = value.trim();
+  if (!key || key.length > 500) {
+    throw new UnifiedBillingError("invalid_request", "a bounded idempotency key is required", 400);
+  }
+  return key;
+}
+function tokenFor(id, idempotencyKey) {
+  return createHmac("sha256", billingSecret()).update(id).update(":").update(idempotencyKey).digest("base64url");
+}
+function tokenHash(token) {
+  return createHash2("sha256").update(token).digest("hex");
+}
+function verifyToken(row, token) {
+  const expected = Buffer.from(row.token_hash, "hex");
+  const actual = Buffer.from(tokenHash(token), "hex");
+  if (expected.length !== actual.length || !timingSafeEqual(expected, actual)) {
+    throw new UnifiedBillingError("unauthorized", "invalid billing authorization token", 401);
+  }
+}
+function safeMetadata(value) {
+  if (!value) return "{}";
+  return JSON.stringify(value).slice(0, 4e3);
+}
+function mapAuthorization(row, balanceMc) {
+  return {
+    id: row.id,
+    token: tokenFor(row.id, row.idempotency_key),
+    status: row.status,
+    minimumMc: Number(row.minimum_amount_mc),
+    maximumMc: Number(row.maximum_amount_mc),
+    minimumCredits: Number(row.minimum_amount_mc) / MC_PER_CREDIT,
+    maximumCredits: Number(row.maximum_amount_mc) / MC_PER_CREDIT,
+    balanceMc,
+    expiresAt: row.expires_at,
+    reservationMode: "balance_check"
+  };
+}
+async function authorizationById(id) {
+  const result = await getDb().execute({
+    sql: "SELECT id, user_id, idempotency_key, status, minimum_amount_mc, maximum_amount_mc, token_hash, expires_at FROM billing_authorizations WHERE id = ? LIMIT 1",
+    args: [id]
+  });
+  return result.rows[0] ? result.rows[0] : null;
+}
+async function eventByKey(idempotencyKey) {
+  const result = await getDb().execute({
+    sql: "SELECT id, authorization_id, status, amount_mc, raw_cost_usd_nanos, multiplier_bps, metadata FROM billing_events WHERE idempotency_key = ? LIMIT 1",
+    args: [idempotencyKey]
+  });
+  return result.rows[0] ? result.rows[0] : null;
+}
+function mapEvent(row, balanceMc, duplicate) {
+  let reason;
+  if (row.metadata) {
+    try {
+      const metadata = JSON.parse(row.metadata);
+      if (typeof metadata.reason === "string") reason = metadata.reason;
+    } catch {
+    }
+  }
+  const rawNanos = row.raw_cost_usd_nanos == null ? null : Number(row.raw_cost_usd_nanos);
+  const modelMc = Math.max(0, Number(row.amount_mc) - SCHEDULED_RUN_BASE_MC);
+  return {
+    id: row.id,
+    authorizationId: row.authorization_id,
+    status: row.status === "settled" ? "settled" : "cost_pending",
+    amountMc: Number(row.amount_mc),
+    credits: Number(row.amount_mc) / MC_PER_CREDIT,
+    baseMc: SCHEDULED_RUN_BASE_MC,
+    modelMc,
+    rawCostUsd: rawNanos == null ? null : rawNanos / USD_NANOS,
+    multiplierBps: Number(row.multiplier_bps ?? SCHEDULED_AGENT_LLM_MARKUP_BPS),
+    balanceMc,
+    ...reason ? { reason } : {},
+    duplicate
+  };
+}
+async function authorizeScheduledRun(args) {
+  const identity = normalizeIdentity(args.identity);
+  const idempotencyKey = normalizeIdempotencyKey(args.idempotencyKey);
+  const user = await getUserByEmail(identity);
+  if (!user) throw new UnifiedBillingError("user_not_found", "billing identity was not found", 404);
+  const pending = await getDb().execute({
+    sql: "SELECT id FROM billing_events WHERE user_id = ? AND billing_class = ? AND status = 'cost_pending' LIMIT 1",
+    args: [user.id, SCHEDULED_RUN_BILLING_CLASS]
+  });
+  if (pending.rows.length > 0) {
+    throw new UnifiedBillingError("pending_cost", "a previous scheduled run has an unresolved cost", 409);
+  }
+  const existing = await getDb().execute({
+    sql: "SELECT id, user_id, idempotency_key, status, minimum_amount_mc, maximum_amount_mc, token_hash, expires_at FROM billing_authorizations WHERE idempotency_key = ? LIMIT 1",
+    args: [idempotencyKey]
+  });
+  if (existing.rows[0]) {
+    const row = existing.rows[0];
+    if (Number(row.user_id) !== user.id) {
+      throw new UnifiedBillingError(
+        "invalid_request",
+        "the idempotency key is already in use by another billing identity",
+        409
+      );
+    }
+    const balanceMc2 = await reconcileBalanceMc(user.id, user.balance_mc);
+    return mapAuthorization(row, balanceMc2);
+  }
+  const maximumCredits = args.maximumCredits ?? SCHEDULED_RUN_DEFAULT_MAX_CREDITS;
+  if (!Number.isFinite(maximumCredits) || maximumCredits < SCHEDULED_RUN_BASE_MC / MC_PER_CREDIT) {
+    throw new UnifiedBillingError("invalid_request", "maximumCredits must cover the scheduled-run base charge", 400);
+  }
+  const maximumMc = Math.ceil(maximumCredits * MC_PER_CREDIT);
+  const balanceMc = await reconcileBalanceMc(user.id, user.balance_mc);
+  if (balanceMc < SCHEDULED_RUN_BASE_MC) {
+    throw new UnifiedBillingError(
+      "insufficient_credits",
+      "the wallet cannot cover the scheduled-run base charge",
+      402,
+      { balanceMc, requiredMc: SCHEDULED_RUN_BASE_MC }
+    );
+  }
+  const id = randomUUID();
+  const token = tokenFor(id, idempotencyKey);
+  const expiresAt = new Date(Date.now() + AUTHORIZATION_TTL_MS).toISOString();
+  const inserted = await getDb().execute({
+    sql: "INSERT OR IGNORE INTO billing_authorizations (id, user_id, idempotency_key, billing_class, status, minimum_amount_mc, maximum_amount_mc, token_hash, metadata, expires_at) VALUES (?, ?, ?, ?, 'authorized', ?, ?, ?, ?, ?)",
+    args: [
+      id,
+      user.id,
+      idempotencyKey,
+      SCHEDULED_RUN_BILLING_CLASS,
+      SCHEDULED_RUN_BASE_MC,
+      maximumMc,
+      tokenHash(token),
+      safeMetadata(args.metadata),
+      expiresAt
+    ]
+  });
+  if (inserted.rowsAffected === 0) {
+    const raced = await getDb().execute({
+      sql: "SELECT id, user_id, idempotency_key, status, minimum_amount_mc, maximum_amount_mc, token_hash, expires_at FROM billing_authorizations WHERE idempotency_key = ? LIMIT 1",
+      args: [idempotencyKey]
+    });
+    if (!raced.rows[0]) throw new Error("billing authorization insert raced without a readable winner");
+    const row = raced.rows[0];
+    if (Number(row.user_id) !== user.id) {
+      throw new UnifiedBillingError(
+        "invalid_request",
+        "the idempotency key is already in use by another billing identity",
+        409
+      );
+    }
+    return mapAuthorization(row, balanceMc);
+  }
+  return {
+    id,
+    token,
+    status: "authorized",
+    minimumMc: SCHEDULED_RUN_BASE_MC,
+    maximumMc,
+    minimumCredits: SCHEDULED_RUN_BASE_MC / MC_PER_CREDIT,
+    maximumCredits,
+    balanceMc,
+    expiresAt,
+    reservationMode: "balance_check"
+  };
+}
+async function settleScheduledRun(args) {
+  const identity = normalizeIdentity(args.identity);
+  const user = await getUserByEmail(identity);
+  if (!user) throw new UnifiedBillingError("user_not_found", "billing identity was not found", 404);
+  const authorization = await authorizationById(args.authorizationId);
+  if (!authorization || Number(authorization.user_id) !== user.id) {
+    throw new UnifiedBillingError("authorization_not_found", "billing authorization was not found", 404);
+  }
+  verifyToken(authorization, args.authorizationToken);
+  const settlementKey = authorization.id + ":settlement";
+  const existing = await eventByKey(settlementKey);
+  if (existing) {
+    const balanceMc = await reconcileBalanceMc(user.id, user.balance_mc);
+    if (existing.status === "settling") {
+      throw new UnifiedBillingError("settlement_in_progress", "scheduled-run settlement is already in progress", 409);
+    }
+    return mapEvent(existing, balanceMc, true);
+  }
+  if (authorization.status !== "authorized") {
+    throw new UnifiedBillingError("authorization_closed", "billing authorization is no longer open", 409);
+  }
+  if (Date.parse(authorization.expires_at) <= Date.now()) {
+    await getDb().execute({
+      sql: "UPDATE billing_authorizations SET status = 'expired' WHERE id = ? AND status = 'authorized'",
+      args: [authorization.id]
+    });
+    throw new UnifiedBillingError("authorization_expired", "billing authorization expired before settlement", 409);
+  }
+  const rawCostUsd = args.rawCostUsd ?? null;
+  if (args.modelCostStatus === "reported" && (rawCostUsd == null || !Number.isFinite(rawCostUsd) || rawCostUsd < 0)) {
+    throw new UnifiedBillingError("invalid_request", "reported model cost must be a finite non-negative number", 400);
+  }
+  if (args.modelCostStatus === "not_applicable" && rawCostUsd != null && rawCostUsd !== 0) {
+    throw new UnifiedBillingError("invalid_request", "not_applicable model cost cannot include a non-zero cost", 400);
+  }
+  const eventId = randomUUID();
+  const rawCostNanos = rawCostUsd == null ? null : Math.round(rawCostUsd * USD_NANOS);
+  const modelMc = rawCostUsd == null ? 0 : vendorCostUsdToMc(rawCostUsd, SCHEDULED_AGENT_LLM_MARKUP_BPS);
+  const totalMc = SCHEDULED_RUN_BASE_MC + modelMc;
+  const pendingReason = args.modelCostStatus === "missing" ? "openrouter_cost_missing" : totalMc > Number(authorization.maximum_amount_mc) ? "max_credits_per_run_exceeded" : null;
+  if (pendingReason) {
+    await getDb().execute({
+      sql: "INSERT INTO billing_events (id, user_id, authorization_id, idempotency_key, billing_class, source_surface, status, amount_mc, raw_cost_usd_nanos, multiplier_bps, input_tokens, output_tokens, cached_tokens, model_steps, metadata) VALUES (?, ?, ?, ?, ?, ?, 'cost_pending', ?, ?, ?, ?, ?, ?, ?, ?)",
+      args: [
+        eventId,
+        user.id,
+        authorization.id,
+        settlementKey,
+        SCHEDULED_RUN_BILLING_CLASS,
+        SCHEDULED_RUN_SOURCE_SURFACE,
+        totalMc,
+        rawCostNanos,
+        SCHEDULED_AGENT_LLM_MARKUP_BPS,
+        Math.max(0, Math.round(args.inputTokens ?? 0)),
+        Math.max(0, Math.round(args.outputTokens ?? 0)),
+        Math.max(0, Math.round(args.cachedTokens ?? 0)),
+        Math.max(0, Math.round(args.modelSteps ?? 0)),
+        safeMetadata({ ...args.metadata, reason: pendingReason })
+      ]
+    });
+    await getDb().execute({
+      sql: "UPDATE billing_authorizations SET status = 'cost_pending', settled_at = datetime('now') WHERE id = ?",
+      args: [authorization.id]
+    });
+    return {
+      id: eventId,
+      authorizationId: authorization.id,
+      status: "cost_pending",
+      amountMc: totalMc,
+      credits: totalMc / MC_PER_CREDIT,
+      baseMc: SCHEDULED_RUN_BASE_MC,
+      modelMc,
+      rawCostUsd,
+      multiplierBps: SCHEDULED_AGENT_LLM_MARKUP_BPS,
+      balanceMc: await reconcileBalanceMc(user.id, user.balance_mc),
+      reason: pendingReason,
+      duplicate: false
+    };
+  }
+  const claimed = await getDb().execute({
+    sql: "INSERT OR IGNORE INTO billing_events (id, user_id, authorization_id, idempotency_key, billing_class, source_surface, status, amount_mc, raw_cost_usd_nanos, multiplier_bps, input_tokens, output_tokens, cached_tokens, model_steps, metadata) VALUES (?, ?, ?, ?, ?, ?, 'settling', ?, ?, ?, ?, ?, ?, ?, ?)",
+    args: [
+      eventId,
+      user.id,
+      authorization.id,
+      settlementKey,
+      SCHEDULED_RUN_BILLING_CLASS,
+      SCHEDULED_RUN_SOURCE_SURFACE,
+      totalMc,
+      rawCostNanos,
+      SCHEDULED_AGENT_LLM_MARKUP_BPS,
+      Math.max(0, Math.round(args.inputTokens ?? 0)),
+      Math.max(0, Math.round(args.outputTokens ?? 0)),
+      Math.max(0, Math.round(args.cachedTokens ?? 0)),
+      Math.max(0, Math.round(args.modelSteps ?? 0)),
+      safeMetadata(args.metadata)
+    ]
+  });
+  if (claimed.rowsAffected === 0) {
+    const raced = await eventByKey(settlementKey);
+    if (!raced) throw new Error("billing settlement raced without a readable winner");
+    if (raced.status === "settling") {
+      throw new UnifiedBillingError("settlement_in_progress", "scheduled-run settlement is already in progress", 409);
+    }
+    return mapEvent(raced, await reconcileBalanceMc(user.id, user.balance_mc), true);
+  }
+  const debit = await debitMc(
+    user.id,
+    totalMc,
+    LedgerOperation.SCHEDULED_RUN,
+    "scheduled-run:" + authorization.id
+  );
+  if (!debit.ok) {
+    const metadata = safeMetadata({ ...args.metadata, reason: "insufficient_credits_at_settlement" });
+    await getDb().execute({
+      sql: "UPDATE billing_events SET status = 'cost_pending', metadata = ? WHERE id = ?",
+      args: [metadata, eventId]
+    });
+    await getDb().execute({
+      sql: "UPDATE billing_authorizations SET status = 'cost_pending', settled_at = datetime('now') WHERE id = ?",
+      args: [authorization.id]
+    });
+    return {
+      id: eventId,
+      authorizationId: authorization.id,
+      status: "cost_pending",
+      amountMc: totalMc,
+      credits: totalMc / MC_PER_CREDIT,
+      baseMc: SCHEDULED_RUN_BASE_MC,
+      modelMc,
+      rawCostUsd,
+      multiplierBps: SCHEDULED_AGENT_LLM_MARKUP_BPS,
+      balanceMc: debit.balance_mc,
+      reason: "insufficient_credits_at_settlement",
+      duplicate: false
+    };
+  }
+  await getDb().execute({
+    sql: "UPDATE billing_events SET status = 'settled', settled_at = datetime('now') WHERE id = ?",
+    args: [eventId]
+  });
+  await getDb().execute({
+    sql: "UPDATE billing_authorizations SET status = 'settled', settled_at = datetime('now') WHERE id = ?",
+    args: [authorization.id]
+  });
+  return {
+    id: eventId,
+    authorizationId: authorization.id,
+    status: "settled",
+    amountMc: totalMc,
+    credits: totalMc / MC_PER_CREDIT,
+    baseMc: SCHEDULED_RUN_BASE_MC,
+    modelMc,
+    rawCostUsd,
+    multiplierBps: SCHEDULED_AGENT_LLM_MARKUP_BPS,
+    balanceMc: debit.balance_mc,
+    duplicate: false
+  };
+}
+async function voidScheduledRunAuthorization(args) {
+  const identity = normalizeIdentity(args.identity);
+  const user = await getUserByEmail(identity);
+  if (!user) throw new UnifiedBillingError("user_not_found", "billing identity was not found", 404);
+  const authorization = await authorizationById(args.authorizationId);
+  if (!authorization || Number(authorization.user_id) !== user.id) {
+    throw new UnifiedBillingError("authorization_not_found", "billing authorization was not found", 404);
+  }
+  verifyToken(authorization, args.authorizationToken);
+  if (authorization.status === "authorized") {
+    await getDb().execute({
+      sql: "UPDATE billing_authorizations SET status = 'void', metadata = ?, settled_at = datetime('now') WHERE id = ? AND status = 'authorized'",
+      args: [safeMetadata({ reason: args.reason ?? "voided_before_execution" }), authorization.id]
+    });
+    return { ok: true, status: "void" };
+  }
+  return { ok: true, status: authorization.status };
+}
+
+// src/api/internal-billing-routes.ts
+var internalBillingApp = new Hono3();
+var metadataSchema = z10.record(z10.unknown()).optional();
+var authorizeSchema = z10.object({
+  identity: z10.string().min(1).max(320),
+  idempotencyKey: z10.string().min(1).max(500),
+  maximumCredits: z10.number().finite().positive().optional(),
+  metadata: metadataSchema
+});
+var settleSchema = z10.object({
+  identity: z10.string().min(1).max(320),
+  authorizationId: z10.string().uuid(),
+  authorizationToken: z10.string().min(20).max(500),
+  modelCostStatus: z10.enum(["reported", "missing", "not_applicable"]),
+  rawCostUsd: z10.number().finite().nonnegative().nullable().optional(),
+  inputTokens: z10.number().finite().nonnegative().optional(),
+  outputTokens: z10.number().finite().nonnegative().optional(),
+  cachedTokens: z10.number().finite().nonnegative().optional(),
+  modelSteps: z10.number().finite().nonnegative().optional(),
+  metadata: metadataSchema
+});
+var voidSchema = z10.object({
+  identity: z10.string().min(1).max(320),
+  authorizationId: z10.string().uuid(),
+  authorizationToken: z10.string().min(20).max(500),
+  reason: z10.string().max(500).optional()
+});
+function internalRequestAuthorized(header) {
+  const expected = process.env.INTERNAL_BILLING_SECRET ?? process.env.INTERNAL_MEMORY_DEBIT_SECRET;
+  return Boolean(expected && header && header === expected);
+}
+function billingError(error) {
+  if (error instanceof UnifiedBillingError) {
+    return {
+      body: {
+        ok: false,
+        error_code: error.code,
+        error: error.message,
+        ...error.details
+      },
+      status: error.httpStatus
+    };
+  }
+  console.error("[internal-billing] unexpected error", error instanceof Error ? error.message : error);
+  return {
+    body: { ok: false, error_code: "internal_error", error: "internal billing operation failed" },
+    status: 500
+  };
+}
+internalBillingApp.use("*", async (c, next) => {
+  if (!internalRequestAuthorized(c.req.header("x-internal-secret"))) {
+    return c.json({ ok: false, error_code: "unauthorized", error: "unauthorized" }, 401);
+  }
+  await next();
+});
+internalBillingApp.post("/scheduled-run/authorize", async (c) => {
+  const parsed = authorizeSchema.safeParse(await c.req.json().catch(() => null));
+  if (!parsed.success) {
+    return c.json({ ok: false, error_code: "invalid_request", error: "invalid billing authorization request" }, 400);
+  }
+  try {
+    const authorization = await authorizeScheduledRun(parsed.data);
+    return c.json({ ok: true, authorization });
+  } catch (error) {
+    const response = billingError(error);
+    return c.json(response.body, response.status);
+  }
+});
+internalBillingApp.post("/scheduled-run/settle", async (c) => {
+  const parsed = settleSchema.safeParse(await c.req.json().catch(() => null));
+  if (!parsed.success) {
+    return c.json({ ok: false, error_code: "invalid_request", error: "invalid scheduled-run settlement request" }, 400);
+  }
+  try {
+    const settlement = await settleScheduledRun(parsed.data);
+    return c.json({ ok: true, settlement });
+  } catch (error) {
+    const response = billingError(error);
+    return c.json(response.body, response.status);
+  }
+});
+internalBillingApp.post("/scheduled-run/void", async (c) => {
+  const parsed = voidSchema.safeParse(await c.req.json().catch(() => null));
+  if (!parsed.success) {
+    return c.json({ ok: false, error_code: "invalid_request", error: "invalid billing void request" }, 400);
+  }
+  try {
+    return c.json(await voidScheduledRunAuthorization(parsed.data));
+  } catch (error) {
+    const response = billingError(error);
+    return c.json(response.body, response.status);
+  }
+});
+
+// src/api/youtube-routes.ts
+import { Hono as Hono4 } from "hono";
 
 // src/youtube/youtube-harvest.ts
 import { promises as fs } from "fs";
@@ -8257,17 +8459,17 @@ import path4 from "path";
 import Papa from "papaparse";
 
 // src/youtube/schemas.ts
-import { z as z10 } from "zod";
-var YouTubeHarvestOptionsSchema = z10.object({
-  mode: z10.enum(["search", "channel"]),
-  query: z10.string().optional(),
-  channelHandle: z10.string().optional(),
-  maxVideos: z10.number().int().min(1).max(5e3).default(100),
-  downloadMp3: z10.boolean().default(false),
-  outputDir: z10.string().default("./yt-output"),
-  kernelApiKey: z10.string().optional(),
-  kernelProxyId: z10.string().optional(),
-  headless: z10.boolean().default(false)
+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)
 }).refine(
   (o) => o.mode === "search" ? !!o.query : !!o.channelHandle,
   { message: "search mode requires query; channel mode requires channelHandle" }
@@ -9053,67 +9255,68 @@ function createApiKeyAuth() {
 }
 
 // src/api/server-schemas.ts
-import { z as z11 } from "zod";
-var HarvestBodySchema = z11.object({
-  query: z11.string().min(1, "query is required"),
-  location: z11.string().optional(),
-  depth: z11.number().int().min(1).max(4).optional(),
-  maxQuestions: z11.number().int().min(1).optional(),
-  callback_url: z11.string().url().optional(),
-  gl: z11.string().optional(),
-  hl: z11.string().optional(),
-  device: z11.enum(["desktop", "mobile"]).optional(),
-  proxyMode: z11.enum(["location", "configured", "none"]).optional(),
-  proxyZip: z11.string().regex(/^\d{5}$/).optional(),
-  debug: z11.boolean().optional(),
-  serpOnly: z11.boolean().optional(),
-  pages: z11.number().int().min(1).max(2).optional()
-});
-var ExtractUrlBodySchema = z11.object({
-  url: z11.string().min(1, "url is required"),
-  screenshot: z11.boolean().optional(),
-  screenshotDevice: z11.enum(["desktop", "mobile"]).optional(),
-  extractBranding: z11.boolean().optional(),
-  downloadMedia: z11.boolean().optional(),
-  mediaTypes: z11.array(z11.enum(["image", "video", "audio"])).optional(),
-  allowLocal: z11.boolean().optional(),
-  depositToVault: z11.boolean().optional(),
-  vaultName: z11.string().trim().min(1).max(120).optional()
-});
-var DiffPageBodySchema = z11.object({
-  url: z11.string().min(1, "url is required"),
-  allowLocal: z11.boolean().optional(),
-  resetBaseline: z11.boolean().optional()
-});
-var MapUrlsBodySchema = z11.object({
-  url: z11.string().min(1, "url is required"),
-  maxUrls: z11.number().int().min(1).max(2e3).optional(),
-  concurrency: z11.number().int().min(1).max(20).optional(),
-  browserFallback: z11.boolean().optional(),
-  kernelFallback: z11.boolean().optional()
-});
-var ExtractSiteBodySchema = z11.object({
-  url: z11.string().min(1, "url is required"),
-  maxPages: z11.number().int().min(1).max(1e4).optional(),
-  browserFallback: z11.boolean().optional(),
-  kernelFallback: z11.boolean().optional(),
-  rotateProxies: z11.boolean().optional(),
-  rotateProxyEvery: z11.number().int().min(1).max(100).optional(),
-  background: z11.boolean().optional(),
-  formats: z11.array(z11.enum(["markdown", "links", "json", "images", "branding", "issues"])).optional()
-});
-var YoutubeHarvestBodySchema = z11.object({
-  mode: z11.enum(["search", "channel"]),
-  query: z11.string().optional(),
-  channelHandle: z11.string().optional(),
-  maxVideos: z11.number().int().min(1).max(500).optional()
+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 YoutubeTranscribeBodySchema = z11.object({
-  videoId: z11.string().min(1, "videoId is required")
+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")
 });
 
 // src/api/concurrency-gates.ts
-import { randomUUID } from "crypto";
+import { randomUUID as randomUUID2 } from "crypto";
 var DEFAULT_LOCK_TTL_SECONDS = 15 * 60;
 var DEFAULT_RETRY_AFTER_SECONDS = 30;
 var MAX_LOCK_TTL_SECONDS = 24 * 60 * 60;
@@ -9147,7 +9350,7 @@ function lockTtlModifier(ttlSeconds) {
   const ttl = Number.isFinite(ttlSeconds) ? Math.max(30, Math.min(Math.trunc(Number(ttlSeconds)), MAX_LOCK_TTL_SECONDS)) : DEFAULT_LOCK_TTL_SECONDS;
   return `+${ttl} seconds`;
 }
-function safeMetadata(metadata) {
+function safeMetadata2(metadata) {
   if (!metadata) return null;
   try {
     return JSON.stringify(metadata).slice(0, 4e3);
@@ -9231,7 +9434,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_${randomUUID().replace(/-/g, "").slice(0, 24)}`;
+  const lockId = `cl_${randomUUID2().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', ?), ?
@@ -9253,7 +9456,7 @@ async function acquireConcurrencyGate(user, operation, options = {}) {
       user.id,
       operation,
       lockTtlModifier(options.ttlSeconds),
-      safeMetadata(options.metadata),
+      safeMetadata2(options.metadata),
       user.id,
       user.id,
       limit
@@ -9287,7 +9490,7 @@ async function extendConcurrencyGate(lockId, ttlSeconds = DEFAULT_LOCK_TTL_SECON
 }
 
 // src/api/youtube-routes.ts
-var youtubeApp = new Hono3();
+var youtubeApp = new Hono4();
 youtubeApp.post("/harvest", createApiKeyAuth(), async (c) => {
   const raw = await c.req.json().catch(() => ({}));
   const parsed = YoutubeHarvestBodySchema.safeParse(raw);
@@ -9446,14 +9649,14 @@ function fmtTs(secs) {
 }
 
 // src/api/screenshot-routes.ts
-import { Hono as Hono4 } from "hono";
-import { z as z12 } from "zod";
-var ScreenshotBodySchema = z12.object({
-  url: z12.string().trim().min(1, "url is required"),
-  device: z12.string().trim().optional(),
-  allowLocal: z12.boolean().optional()
+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()
 });
-var screenshotApp = new Hono4();
+var screenshotApp = new Hono5();
 screenshotApp.use("*", createApiKeyAuth());
 screenshotApp.post("/", async (c) => {
   const raw = await c.req.json().catch(() => ({}));
@@ -9510,8 +9713,8 @@ screenshotApp.post("/", async (c) => {
 });
 
 // src/api/facebook-ad-routes.ts
-import { Hono as Hono5 } from "hono";
-import { z as z13 } from "zod";
+import { Hono as Hono6 } from "hono";
+import { z as z14 } from "zod";
 
 // src/extractor/FacebookAdExtractor.ts
 var SPRITE_Y_TO_PLATFORM = {
@@ -10404,35 +10607,35 @@ async function extractFacebookOrganicVideoFromPage(page, sourceUrl, quality = "b
 
 // src/api/facebook-ad-routes.ts
 import { fal } from "@fal-ai/client";
-var FacebookAdBodySchema = z13.object({
-  url: z13.string().trim().optional(),
-  libraryId: z13.string().trim().optional(),
-  openModal: z13.boolean().optional()
+var FacebookAdBodySchema = z14.object({
+  url: z14.string().trim().optional(),
+  libraryId: z14.string().trim().optional(),
+  openModal: z14.boolean().optional()
 }).refine((d) => !!d.url || !!d.libraryId, { message: "url or libraryId is required" });
-var FacebookPageIntelBodySchema = z13.object({
-  pageId: z13.string().trim().optional(),
-  query: z13.string().trim().optional(),
-  libraryId: z13.string().trim().optional(),
-  maxAds: z13.number().int().min(1).max(200).optional(),
-  country: z13.string().trim().toUpperCase().optional()
+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()
 }).refine((d) => !!d.pageId || !!d.query || !!d.libraryId, {
   message: "pageId, libraryId, or query is required"
 });
-var FacebookTranscribeBodySchema = z13.object({
-  videoUrl: z13.string().trim().min(1, "videoUrl is required")
+var FacebookTranscribeBodySchema = z14.object({
+  videoUrl: z14.string().trim().min(1, "videoUrl is required")
 });
-var FacebookVideoTranscribeBodySchema = z13.object({
-  url: z13.string().trim().min(1, "url is required"),
-  quality: z13.enum(["best", "hd", "sd"]).default("best")
+var FacebookVideoTranscribeBodySchema = z14.object({
+  url: z14.string().trim().min(1, "url is required"),
+  quality: z14.enum(["best", "hd", "sd"]).default("best")
 });
-var FacebookSearchBodySchema = z13.object({
-  query: z13.string().trim().min(1, "query is required"),
-  country: z13.string().trim().toUpperCase().optional(),
-  maxResults: z13.number().int().min(1).max(20).optional()
+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 FacebookMediaBodySchema = z13.object({
-  url: z13.string().trim().min(1, "url is required"),
-  filename: z13.string().trim().optional()
+var FacebookMediaBodySchema = z14.object({
+  url: z14.string().trim().min(1, "url is required"),
+  filename: z14.string().trim().optional()
 });
 function invalidRequest(message) {
   return { error_code: "invalid_request", message };
@@ -10514,7 +10717,7 @@ async function kernelLaunchOptsResidential() {
   }
   return { headless: true, kernelApiKey: browserServiceApiKey(), kernelProxyId: proxyId, viewport: { width: 1280, height: 900 }, locale: "en-US" };
 }
-var facebookAdApp = new Hono5();
+var facebookAdApp = new Hono6();
 facebookAdApp.post("/ad", createApiKeyAuth(), async (c) => {
   const raw = await c.req.json().catch(() => ({}));
   const parsed = FacebookAdBodySchema.safeParse(raw);
@@ -10858,8 +11061,8 @@ facebookAdApp.post("/media", createApiKeyAuth(), async (c) => {
 });
 
 // src/api/google-ads-routes.ts
-import { Hono as Hono6 } from "hono";
-import { z as z14 } from "zod";
+import { Hono as Hono7 } from "hono";
+import { z as z15 } from "zod";
 
 // src/extractor/GoogleAdsExtractor.ts
 var ORIGIN = "https://adstransparency.google.com";
@@ -11029,19 +11232,19 @@ var GoogleAdsExtractor = class {
 
 // src/api/google-ads-routes.ts
 import { fal as fal2 } from "@fal-ai/client";
-var GoogleAdsSearchBodySchema = z14.object({
-  query: z14.string().trim().min(1, "query is required"),
-  region: z14.string().trim().toUpperCase().length(2).optional(),
-  maxResults: z14.number().int().min(1).max(20).optional()
+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 = z14.object({
-  advertiserId: z14.string().trim().optional(),
-  domain: z14.string().trim().optional(),
-  region: z14.string().trim().toUpperCase().length(2).optional(),
-  maxAds: z14.number().int().min(1).max(200).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()
 }).refine((d) => !!d.advertiserId || !!d.domain, { message: "advertiserId or domain is required" });
-var GoogleAdsTranscribeBodySchema = z14.object({
-  videoUrl: z14.string().trim().min(1, "videoUrl is required")
+var GoogleAdsTranscribeBodySchema = z15.object({
+  videoUrl: z15.string().trim().min(1, "videoUrl is required")
 });
 function invalidRequest2(message) {
   return { error_code: "invalid_request", message };
@@ -11067,7 +11270,7 @@ async function kernelLaunchOptsResidential2() {
 function isBlockedMessage(msg) {
   return msg.toLowerCase().includes("blocked") || msg.toLowerCase().includes("captcha");
 }
-var googleAdsApp = new Hono6();
+var googleAdsApp = new Hono7();
 googleAdsApp.post("/search", createApiKeyAuth(), async (c) => {
   const raw = await c.req.json().catch(() => ({}));
   const parsed = GoogleAdsSearchBodySchema.safeParse(raw);
@@ -11183,11 +11386,11 @@ googleAdsApp.post("/transcribe", createApiKeyAuth(), async (c) => {
 });
 
 // src/api/instagram-routes.ts
-import { Hono as Hono7 } from "hono";
-import { z as z15 } from "zod";
+import { Hono as Hono8 } from "hono";
+import { z as z16 } from "zod";
 import { mkdtempSync, readFileSync as readFileSync2, rmSync, writeFileSync } from "fs";
 import { tmpdir } from "os";
-import { join as join4 } from "path";
+import { join as join3 } from "path";
 import { spawn } from "child_process";
 
 // src/extractor/InstagramContentExtractor.ts
@@ -11546,32 +11749,32 @@ async function extractInstagramMediaFromPage(page, sourceUrl, capturedMediaUrls
 }
 
 // src/api/instagram-routes.ts
-var InstagramProfileContentBodySchema = z15.object({
-  handle: z15.string().trim().optional(),
-  url: z15.string().trim().optional(),
-  profile: z15.string().trim().min(1).optional(),
-  saveProfileChanges: z15.boolean().optional(),
-  save_profile_changes: z15.boolean().optional(),
-  maxItems: z15.number().int().min(1).max(2e3).default(50),
-  maxScrolls: z15.number().int().min(0).max(250).default(10),
-  scrollDelayMs: z15.number().int().min(250).max(5e3).default(1200),
-  stableScrollLimit: z15.number().int().min(1).max(10).default(4)
+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)
 }).refine((d) => !!d.handle || !!d.url, {
   message: "handle or url is required"
 });
-var InstagramMediaTypeSchema = z15.enum(["image", "video", "audio"]);
-var InstagramMediaDownloadBodySchema = z15.object({
-  url: z15.string().trim().min(1, "url is required"),
-  profile: z15.string().trim().min(1).optional(),
-  saveProfileChanges: z15.boolean().optional(),
-  save_profile_changes: z15.boolean().optional(),
-  mediaTypes: z15.array(InstagramMediaTypeSchema).default(["image", "video", "audio"]),
-  downloadMedia: z15.boolean().default(true),
-  downloadAllTracks: z15.boolean().default(false),
-  includeTranscript: z15.boolean().default(false),
-  mux: z15.boolean().default(true)
-});
-var instagramApp = new Hono7();
+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 instagramApp = new Hono8();
 function invalidRequest3(message) {
   return { error_code: "invalid_request", message };
 }
@@ -11785,8 +11988,8 @@ instagramApp.post("/media-download", createApiKeyAuth(), async (c) => {
             downloads.push({ kind, url: track.url, savedPath: stored.url, sizeBytes: stored.bytes, mimeType, error: null });
             const isMuxInput = muxEligible && (track.url === extraction.selectedVideoTrack.url || track.url === extraction.selectedAudioTrack.url);
             if (isMuxInput) {
-              if (!muxWorkDir) muxWorkDir = mkdtempSync(join4(tmpdir(), "ig-mux-"));
-              const localPath = join4(muxWorkDir, trackFilename(track, index, extraction.shortcode));
+              if (!muxWorkDir) muxWorkDir = mkdtempSync(join3(tmpdir(), "ig-mux-"));
+              const localPath = join3(muxWorkDir, trackFilename(track, index, extraction.shortcode));
               writeFileSync(localPath, bytes);
               muxInputs.set(track.url, localPath);
             }
@@ -11795,7 +11998,7 @@ instagramApp.post("/media-download", createApiKeyAuth(), async (c) => {
           }
         }
         if (muxEligible && muxWorkDir && muxInputs.has(extraction.selectedVideoTrack.url) && muxInputs.has(extraction.selectedAudioTrack.url)) {
-          const outPath = join4(muxWorkDir, "muxed.mp4");
+          const outPath = join3(muxWorkDir, "muxed.mp4");
           const muxed = await runFfmpegMux(muxInputs.get(extraction.selectedVideoTrack.url), muxInputs.get(extraction.selectedAudioTrack.url), outPath);
           if (muxed.ok) {
             const stored = await store.put(`${prefix}/muxed.mp4`, readFileSync2(outPath), "video/mp4");
@@ -11851,11 +12054,11 @@ instagramApp.post("/media-download", createApiKeyAuth(), async (c) => {
 });
 
 // src/api/reddit-routes.ts
-import { Hono as Hono8 } from "hono";
-import { z as z16 } from "zod";
-var RedditThreadBodySchema = z16.object({
-  url: z16.string().trim().min(1, "url is required"),
-  maxComments: z16.number().int().min(1).max(2e3).optional()
+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()
 });
 function invalidRequest4(message) {
   return { error_code: "invalid_request", message };
@@ -11911,7 +12114,7 @@ var PARSE_REDDIT = `(() => {
   });
   return { title: title, author: author, score: score, postBody: postBody, blocked: blocked, numComments: comments.length, comments: comments };
 })()`;
-var redditApp = new Hono8();
+var redditApp = new Hono9();
 redditApp.post("/thread", createApiKeyAuth(), async (c) => {
   const raw = await c.req.json().catch(() => ({}));
   const parsed = RedditThreadBodySchema.safeParse(raw);
@@ -11993,14 +12196,14 @@ redditApp.post("/thread", createApiKeyAuth(), async (c) => {
 });
 
 // src/api/video-routes.ts
-import { Hono as Hono9 } from "hono";
-import { z as z17 } from "zod";
+import { Hono as Hono10 } from "hono";
+import { z as z18 } from "zod";
 
 // src/api/memory.ts
 import { createCipheriv, createDecipheriv, randomBytes, scryptSync } from "crypto";
 
 // src/api/session.ts
-import { createHmac, timingSafeEqual } from "crypto";
+import { createHmac as createHmac2, timingSafeEqual as timingSafeEqual2 } from "crypto";
 var isProduction = () => process.env.NODE_ENV === "production" || process.env.VERCEL === "1";
 function getSessionSecret() {
   const configured = process.env.SESSION_SECRET?.trim();
@@ -12012,14 +12215,14 @@ var secret = () => getSessionSecret();
 function safeEqualHex(a, b) {
   if (a.length !== b.length) return false;
   try {
-    return timingSafeEqual(Buffer.from(a, "hex"), Buffer.from(b, "hex"));
+    return timingSafeEqual2(Buffer.from(a, "hex"), Buffer.from(b, "hex"));
   } catch {
     return false;
   }
 }
 function signSession(userId) {
   const payload = String(userId);
-  const sig = createHmac("sha256", secret()).update(payload).digest("hex");
+  const sig = createHmac2("sha256", secret()).update(payload).digest("hex");
   return `${payload}.${sig}`;
 }
 function verifySession(token) {
@@ -12027,7 +12230,7 @@ function verifySession(token) {
   if (dot === -1) return null;
   const payload = token.slice(0, dot);
   const sig = token.slice(dot + 1);
-  const expected = createHmac("sha256", secret()).update(payload).digest("hex");
+  const expected = createHmac2("sha256", secret()).update(payload).digest("hex");
   if (!safeEqualHex(sig, expected)) return null;
   const id = parseInt(payload);
   return isNaN(id) ? null : id;
@@ -12173,13 +12376,13 @@ async function syncScheduleEntitlement(user, enabled, quotaPerPeriod) {
 }
 
 // src/api/video-routes.ts
-var videoApp = new Hono9();
-var AnalyzeBodySchema = z17.object({
-  sourceUrl: z17.string().trim().url("sourceUrl must be a direct video file URL"),
-  intervalS: z17.number().min(1).max(30).optional(),
-  maxFrames: z17.number().int().min(1).max(480).optional(),
-  detail: z17.enum(["fast", "standard", "deep"]).optional(),
-  vault: z17.string().trim().min(1).optional()
+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()
 });
 function invalidRequest5(message) {
   return { error_code: "invalid_request", message };
@@ -12283,7 +12486,7 @@ videoApp.post("/status", createApiKeyAuth(), async (c) => {
 });
 
 // src/api/maps-routes.ts
-import { Hono as Hono10 } from "hono";
+import { Hono as Hono11 } from "hono";
 
 // src/extractor/MapsNavigator.ts
 var MapsNavigator = class {
@@ -12485,7 +12688,7 @@ var MapsReviewCollector = class {
 };
 
 // src/extractor/MapsExtractor.ts
-import { z as z18 } from "zod";
+import { z as z19 } from "zod";
 var MapsExtractor = class {
   constructor(driver) {
     this.driver = driver;
@@ -12693,7 +12896,7 @@ var MapsExtractor = class {
       });
       return rows;
     }, { hoursTable: MapsSelectors.hoursTable, hoursTableAlt: MapsSelectors.hoursTableAlt });
-    const result = z18.array(RawMapsHoursRowSchema).safeParse(raw);
+    const result = z19.array(RawMapsHoursRowSchema).safeParse(raw);
     if (!result.success) {
       console.warn("[MapsExtractor] hours parse failed", result.error.flatten());
       return [];
@@ -12757,7 +12960,7 @@ var MapsExtractor = class {
       });
       return results;
     });
-    const result = z18.array(RawMapsAboutAttributeSchema).safeParse(raw);
+    const result = z19.array(RawMapsAboutAttributeSchema).safeParse(raw);
     if (!result.success) {
       console.warn("[MapsExtractor] about parse failed", result.error.flatten());
       return [];
@@ -13208,7 +13411,7 @@ function mapsErrorResponse(c, err, errorCode) {
     attempts: rotationError?.attempts ?? void 0
   }, retryable ? 503 : 500);
 }
-var mapsApp = new Hono10();
+var mapsApp = new Hono11();
 mapsApp.post("/search", createApiKeyAuth(), async (c) => {
   const user = c.get("user");
   const body = await c.req.json().catch(() => ({}));
@@ -13346,11 +13549,11 @@ mapsApp.post("/place", createApiKeyAuth(), async (c) => {
 });
 
 // src/api/trustpilot-routes.ts
-import { Hono as Hono11 } from "hono";
-import { z as z19 } from "zod";
-var TrustpilotReviewsBodySchema = z19.object({
-  domain: z19.string().trim().min(1, "domain is required"),
-  maxPages: z19.number().int().min(1).max(50).default(5)
+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)
 });
 function invalidRequest6(message) {
   return { error_code: "invalid_request", message };
@@ -13415,7 +13618,7 @@ async function extractReviewCards(page) {
     });
   });
 }
-var trustpilotApp = new Hono11();
+var trustpilotApp = new Hono12();
 trustpilotApp.post("/reviews", createApiKeyAuth(), async (c) => {
   const raw = await c.req.json().catch(() => ({}));
   const parsed = TrustpilotReviewsBodySchema.safeParse(raw);
@@ -13496,11 +13699,11 @@ trustpilotApp.post("/reviews", createApiKeyAuth(), async (c) => {
 });
 
 // src/api/g2-routes.ts
-import { Hono as Hono12 } from "hono";
-import { z as z20 } from "zod";
-var G2ReviewsBodySchema = z20.object({
-  product: z20.string().trim().min(1, "product is required"),
-  maxPages: z20.number().int().min(1).max(50).default(5)
+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)
 });
 function invalidRequest7(message) {
   return { error_code: "invalid_request", message };
@@ -13605,7 +13808,7 @@ async function extractG2ReviewCards(page) {
     });
   });
 }
-var g2App = new Hono12();
+var g2App = new Hono13();
 g2App.post("/reviews", createApiKeyAuth(), async (c) => {
   const raw = await c.req.json().catch(() => ({}));
   const parsed = G2ReviewsBodySchema.safeParse(raw);
@@ -13702,12 +13905,12 @@ g2App.post("/reviews", createApiKeyAuth(), async (c) => {
 });
 
 // src/api/directory-routes.ts
-import { Hono as Hono13 } from "hono";
+import { Hono as Hono14 } from "hono";
 
 // src/directory/directory-workflow.ts
 import { mkdir as mkdir2, writeFile } from "fs/promises";
-import { join as join5 } from "path";
-import { z as z21 } from "zod";
+import { join as join4 } from "path";
+import { z as z22 } from "zod";
 
 // src/directory/location-db.ts
 import { access, readFile } from "fs/promises";
@@ -13868,24 +14071,24 @@ async function resolveDirectoryMarkets(options) {
 }
 
 // src/directory/directory-workflow.ts
-var DirectoryWorkflowOptionsSchema = z21.object({
-  query: z21.string().min(1),
-  state: z21.string().min(2).default("TN"),
-  minPopulation: z21.number().int().min(0).default(1e5),
-  populationYear: z21.union(POPULATION_YEARS.map((year) => z21.literal(year))).default(2025),
-  maxCities: z21.number().int().min(1).max(100).default(25),
-  maxResultsPerCity: z21.number().int().min(1).max(50).default(50),
-  concurrency: z21.number().int().min(1).max(5).default(5),
-  includeZipGroups: z21.boolean().default(true),
-  usZipsCsvPath: z21.string().optional(),
-  saveCsv: z21.boolean().default(true),
-  gl: z21.string().length(2).default("us"),
-  hl: z21.string().length(2).default("en"),
-  proxyMode: z21.enum(["location", "configured", "none"]).default(DEFAULT_MAPS_PROXY_MODE),
-  proxyZip: z21.string().regex(/^\d{5}$/).optional(),
-  debug: z21.boolean().default(false),
-  headless: z21.boolean().default(true),
-  kernelApiKey: z21.string().optional()
+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()
 });
 function errorMessage(err) {
   return err instanceof Error ? err.message : String(err);
@@ -14042,11 +14245,11 @@ function csvRowsFor(result) {
   return rows;
 }
 async function saveDirectoryCsv(result) {
-  const outDir = join5(outputBaseDir(), "directory-workflows");
+  const outDir = join4(outputBaseDir(), "directory-workflows");
   await mkdir2(outDir, { recursive: true });
   const stamp = result.extractedAt.replace(/[:.]/g, "-");
   const slug = `${result.state}-${result.query}`.toLowerCase().replace(/[^a-z0-9]+/g, "-").replace(/^-+|-+$/g, "").slice(0, 80);
-  const path5 = join5(outDir, `${stamp}-${slug}-directory-workflow.csv`);
+  const path5 = join4(outDir, `${stamp}-${slug}-directory-workflow.csv`);
   const headers = [
     "source_query",
     "source_location",
@@ -14106,7 +14309,7 @@ async function runDirectoryWorkflowFromPlan(options, plan) {
 }
 
 // src/api/directory-routes.ts
-var directoryApp = new Hono13();
+var directoryApp = new Hono14();
 directoryApp.post("/run", createApiKeyAuth(), async (c) => {
   const user = c.get("user");
   const body = await c.req.json().catch(() => ({}));
@@ -14177,37 +14380,37 @@ directoryApp.post("/run", createApiKeyAuth(), async (c) => {
 });
 
 // src/api/workflow-routes.ts
-import { createHmac as createHmac2 } from "crypto";
+import { createHmac as createHmac3 } from "crypto";
 import { readFile as readFile2 } from "fs/promises";
-import { Hono as Hono14 } from "hono";
-import { z as z22 } from "zod";
-var workflowApp = new Hono14();
-var WorkflowInputSchema = z22.record(z22.unknown()).default({});
-var WorkflowIdSchema = z22.string().min(1);
-var CadenceSchema = z22.enum(["daily", "weekly", "monthly"]);
-var ScheduleStatusSchema = z22.enum(["active", "paused"]);
-var RunBodySchema = z22.object({
+import { Hono as Hono15 } from "hono";
+import { z as z23 } 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({
   workflowId: WorkflowIdSchema,
   input: WorkflowInputSchema,
-  webhookUrl: z22.string().url().optional()
+  webhookUrl: z23.string().url().optional()
 });
-var ScheduleCreateSchema = z22.object({
+var ScheduleCreateSchema = z23.object({
   workflowId: WorkflowIdSchema,
-  name: z22.string().min(1).max(120).optional(),
+  name: z23.string().min(1).max(120).optional(),
   input: WorkflowInputSchema,
   cadence: CadenceSchema.default("weekly"),
-  timezone: z22.string().min(1).max(64).default("UTC"),
-  webhookUrl: z22.string().url().optional(),
-  nextRunAt: z22.string().datetime().optional()
+  timezone: z23.string().min(1).max(64).default("UTC"),
+  webhookUrl: z23.string().url().optional(),
+  nextRunAt: z23.string().datetime().optional()
 });
-var SchedulePatchSchema = z22.object({
-  name: z22.string().min(1).max(120).optional(),
+var SchedulePatchSchema = z23.object({
+  name: z23.string().min(1).max(120).optional(),
   status: ScheduleStatusSchema.optional(),
   input: WorkflowInputSchema.optional(),
   cadence: CadenceSchema.optional(),
-  timezone: z22.string().min(1).max(64).optional(),
-  webhookUrl: z22.string().url().nullable().optional(),
-  nextRunAt: z22.string().datetime().nullable().optional()
+  timezone: z23.string().min(1).max(64).optional(),
+  webhookUrl: z23.string().url().nullable().optional(),
+  nextRunAt: z23.string().datetime().nullable().optional()
 });
 function hostedWorkflowOutputDir() {
   return workflowOutputBaseDir(process.env.MCP_SCRAPER_WORKFLOW_OUTPUT_DIR?.trim() || "/tmp/mcp-scraper-workflows");
@@ -14265,7 +14468,7 @@ async function readManifestFromSummary(summary) {
 function webhookSignature(body, timestamp) {
   const secret2 = process.env.MCP_SCRAPER_WEBHOOK_SECRET?.trim();
   if (!secret2) return null;
-  return createHmac2("sha256", secret2).update(`${timestamp}.${body}`).digest("hex");
+  return createHmac3("sha256", secret2).update(`${timestamp}.${body}`).digest("hex");
 }
 async function deliverWorkflowWebhook(input) {
   if (!input.webhookUrl) return;
@@ -14711,17 +14914,17 @@ workflowApp.post("/cron/dispatch", async (c) => {
 });
 
 // src/api/serp-intelligence-routes.ts
-import { Hono as Hono15 } from "hono";
+import { Hono as Hono16 } from "hono";
 
 // src/serp-intelligence/page-snapshot-extractor.ts
-import { createHash as createHash2 } from "crypto";
+import { createHash as createHash3 } 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 createHash2("sha256").update(value).digest("hex");
+  return createHash3("sha256").update(value).digest("hex");
 }
 function countWords(markdown) {
   const matches = markdown.trim().match(/\b[\p{L}\p{N}][\p{L}\p{N}'-]*\b/gu);
@@ -15023,7 +15226,7 @@ async function capturePageSnapshots(targets, options = {}) {
 }
 
 // src/serp-intelligence/schemas.ts
-import { z as z23 } from "zod";
+import { z as z24 } from "zod";
 var SerpIntelligenceDeviceValues = ["desktop", "mobile"];
 var SerpIntelligenceProxyModeValues = ["location", "configured", "none"];
 var SerpIntelligenceAttemptOutcomeValues = [
@@ -15085,171 +15288,171 @@ function isPublicHttpUrl(value) {
     return false;
   }
 }
-var SerpIntelligencePublicHttpUrlSchema = z23.string().url().refine(isPublicHttpUrl, "url must be a public HTTP or HTTPS URL");
-var SerpIntelligenceCaptureBodySchema = z23.object({
-  query: z23.string().trim().min(1, "query is required"),
-  location: z23.string().trim().min(1).optional(),
-  gl: z23.string().trim().length(2).default("us"),
-  hl: z23.string().trim().length(2).default("en"),
-  device: z23.enum(SerpIntelligenceDeviceValues).default("desktop"),
-  proxyMode: z23.enum(SerpIntelligenceProxyModeValues).default(DEFAULT_PROXY_MODE),
-  proxyZip: z23.string().regex(/^\d{5}$/).optional(),
-  pages: z23.number().int().min(1).max(2).default(1),
-  debug: z23.boolean().default(false),
-  includePageSnapshots: z23.boolean().default(false),
-  pageSnapshotLimit: z23.number().int().min(0).max(10).default(0)
+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)
 }).strict();
-var SerpIntelligencePageSnapshotRequestSchema = z23.object({
+var SerpIntelligencePageSnapshotRequestSchema = z24.object({
   url: SerpIntelligencePublicHttpUrlSchema,
-  sourceKind: z23.enum(SerpPageSnapshotSourceKindValues).default("configured_target"),
-  sourcePosition: z23.number().int().min(1).optional()
+  sourceKind: z24.enum(SerpPageSnapshotSourceKindValues).default("configured_target"),
+  sourcePosition: z24.number().int().min(1).optional()
 }).strict();
-var SerpIntelligencePageSnapshotsBodySchema = z23.object({
-  urls: z23.array(SerpIntelligencePublicHttpUrlSchema).min(1).max(25),
-  targets: z23.array(SerpIntelligencePageSnapshotRequestSchema).min(1).max(25).optional(),
-  maxConcurrency: z23.number().int().min(1).max(5).default(2),
-  timeoutMs: z23.number().int().min(1e3).max(6e4).default(15e3),
-  debug: z23.boolean().default(false)
+var SerpIntelligencePageSnapshotsBodySchema = z24.object({
+  urls: z24.array(SerpIntelligencePublicHttpUrlSchema).min(1).max(25),
+  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)
 }).strict();
-var SerpIntelligenceAICitationSchema = z23.object({
-  text: z23.string(),
-  href: z23.string()
+var SerpIntelligenceAICitationSchema = z24.object({
+  text: z24.string(),
+  href: z24.string()
 }).strict();
-var SerpIntelligenceOrganicResultSchema = z23.object({
-  position: z23.number().int().min(1),
-  title: z23.string(),
-  url: z23.string(),
-  domain: z23.string(),
-  cite: z23.string().nullable(),
-  snippet: z23.string().nullable(),
-  isRedditStyle: z23.boolean(),
-  inlineRating: z23.object({
-    value: z23.string(),
-    count: z23.string()
+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()
   }).strict().nullable()
 }).strict();
-var SerpIntelligenceLocationEvidenceSchema = z23.object({
-  status: z23.enum(SerpIntelligenceLocalizationStatusValues),
-  expected: z23.object({
-    city: z23.string(),
-    regionCode: z23.string().nullable(),
-    canonicalLocation: z23.string()
+var SerpIntelligenceLocationEvidenceSchema = z24.object({
+  status: z24.enum(SerpIntelligenceLocalizationStatusValues),
+  expected: z24.object({
+    city: z24.string(),
+    regionCode: z24.string().nullable(),
+    canonicalLocation: z24.string()
   }).strict().nullable(),
-  candidates: z23.array(z23.object({
-    city: z23.string(),
-    regionCode: z23.string(),
-    count: z23.number().int().min(0),
-    examples: z23.array(z23.string())
+  candidates: z24.array(z24.object({
+    city: z24.string(),
+    regionCode: z24.string(),
+    count: z24.number().int().min(0),
+    examples: z24.array(z24.string())
   }).strict())
 }).strict();
-var SerpIntelligenceHarvestResultSchema = z23.object({
-  seed: z23.string(),
-  location: z23.string().nullable(),
-  extractedAt: z23.string(),
-  totalQuestions: z23.number().int().min(0),
-  surface: z23.enum(["web", "aim", "unknown"]),
-  aiOverview: z23.object({
-    detected: z23.boolean(),
-    text: z23.string().nullable(),
-    citations: z23.array(SerpIntelligenceAICitationSchema),
-    expanded: z23.boolean().optional(),
-    fullyExpanded: z23.boolean().optional(),
-    sections: z23.array(z23.string()).optional()
+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()
   }).strict(),
-  aiMode: z23.object({
-    detected: z23.boolean(),
-    text: z23.string().nullable(),
-    citations: z23.array(SerpIntelligenceAICitationSchema)
+  aiMode: z24.object({
+    detected: z24.boolean(),
+    text: z24.string().nullable(),
+    citations: z24.array(SerpIntelligenceAICitationSchema)
   }).strict(),
-  tree: z23.array(z23.unknown()),
-  flat: z23.array(z23.unknown()),
-  videos: z23.array(z23.unknown()),
-  forums: z23.array(z23.unknown()),
-  organicResults: z23.array(SerpIntelligenceOrganicResultSchema),
-  localPack: z23.array(z23.unknown()),
-  entityIds: z23.object({
-    entities: z23.array(z23.object({
-      name: z23.string(),
-      kgId: z23.string().nullable(),
-      cid: z23.string().nullable(),
-      gcid: z23.string().nullable()
+  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()
     }).strict()),
-    kgIds: z23.array(z23.string()),
-    cids: z23.array(z23.string()),
-    gcids: z23.array(z23.string())
+    kgIds: z24.array(z24.string()),
+    cids: z24.array(z24.string()),
+    gcids: z24.array(z24.string())
   }).strict(),
-  stats: z23.object({
-    seed: z23.string(),
-    totalQuestions: z23.number().int().min(0),
-    maxDepthReached: z23.number().int().min(0),
-    durationMs: z23.number().min(0),
-    errorCount: z23.number().int().min(0)
+  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)
   }).strict(),
-  diagnostics: z23.object({
-    completionStatus: z23.enum(["paa_found", "no_paa", "serp_only"]),
-    problem: z23.null(),
-    warnings: z23.array(z23.unknown()).optional(),
-    debug: z23.object({
+  diagnostics: z24.object({
+    completionStatus: z24.enum(["paa_found", "no_paa", "serp_only"]),
+    problem: z24.null(),
+    warnings: z24.array(z24.unknown()).optional(),
+    debug: z24.object({
       locationEvidence: SerpIntelligenceLocationEvidenceSchema.optional()
     }).passthrough().optional()
   }).passthrough(),
-  whatPeopleSaying: z23.array(z23.unknown())
+  whatPeopleSaying: z24.array(z24.unknown())
 }).strict();
-var SerpIntelligenceCaptureAttemptSchema = z23.object({
-  attemptNumber: z23.number().int().min(1),
-  outcome: z23.enum(SerpIntelligenceAttemptOutcomeValues),
-  startedAt: z23.string().optional(),
-  completedAt: z23.string().optional(),
-  durationMs: z23.number().min(0).optional(),
-  problemCode: z23.string().optional(),
-  message: z23.string().optional(),
-  kernelSessionId: z23.string().nullable().optional(),
-  cleanupSucceeded: z23.boolean().nullable().optional()
+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()
 }).strict();
-var SerpPageSnapshotCaptureSchema = z23.object({
+var SerpPageSnapshotCaptureSchema = z24.object({
   url: SerpIntelligencePublicHttpUrlSchema,
   requestedUrl: SerpIntelligencePublicHttpUrlSchema,
   finalUrl: SerpIntelligencePublicHttpUrlSchema.nullable(),
-  sourceKind: z23.enum(SerpPageSnapshotSourceKindValues),
-  sourcePosition: z23.number().int().min(1).nullable(),
-  status: z23.enum(SerpPageFetchStatusValues),
-  fetchedVia: z23.enum(SerpPageFetchedViaValues).nullable(),
-  httpStatus: z23.number().int().min(100).max(599).nullable(),
-  contentType: z23.string().nullable(),
-  title: z23.string().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(),
   canonicalUrl: SerpIntelligencePublicHttpUrlSchema.nullable(),
-  metaDescription: z23.string().nullable(),
-  headings: z23.array(z23.object({
-    level: z23.number().int().min(1).max(6),
-    text: z23.string()
+  metaDescription: z24.string().nullable(),
+  headings: z24.array(z24.object({
+    level: z24.number().int().min(1).max(6),
+    text: z24.string()
   }).strict()).default([]),
-  artifact: z23.object({
-    htmlBlobUrl: z23.string().url().nullable(),
-    textBlobUrl: z23.string().url().nullable(),
-    markdownBlobUrl: z23.string().url().nullable(),
-    screenshotBlobUrl: z23.string().url().nullable(),
-    contentSha256: z23.string().nullable(),
-    capturedAt: z23.string().nullable()
+  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()
   }).strict(),
-  error: z23.object({
-    code: z23.string(),
-    message: z23.string()
+  error: z24.object({
+    code: z24.string(),
+    message: z24.string()
   }).strict().nullable()
 }).strict();
-var SerpIntelligenceCaptureResponseSchema = z23.object({
+var SerpIntelligenceCaptureResponseSchema = z24.object({
   harvestResult: SerpIntelligenceHarvestResultSchema,
-  attempts: z23.array(SerpIntelligenceCaptureAttemptSchema),
+  attempts: z24.array(SerpIntelligenceCaptureAttemptSchema),
   locationEvidence: SerpIntelligenceLocationEvidenceSchema.nullable(),
-  pageSnapshotArtifacts: z23.array(SerpPageSnapshotCaptureSchema),
-  billing: z23.object({
-    creditsUsed: z23.number().min(0).optional(),
-    requestId: z23.string().optional(),
-    jobId: z23.string().optional()
+  pageSnapshotArtifacts: z24.array(SerpPageSnapshotCaptureSchema),
+  billing: z24.object({
+    creditsUsed: z24.number().min(0).optional(),
+    requestId: z24.string().optional(),
+    jobId: z24.string().optional()
   }).strict().optional()
 }).strict();
-var SerpIntelligencePageSnapshotsResponseSchema = z23.object({
-  pageSnapshotArtifacts: z23.array(SerpPageSnapshotCaptureSchema),
-  attempts: z23.array(SerpIntelligenceCaptureAttemptSchema).default([])
+var SerpIntelligencePageSnapshotsResponseSchema = z24.object({
+  pageSnapshotArtifacts: z24.array(SerpPageSnapshotCaptureSchema),
+  attempts: z24.array(SerpIntelligenceCaptureAttemptSchema).default([])
 }).strict();
 
 // src/serp-intelligence/serp-capture-service.ts
@@ -15421,7 +15624,7 @@ var SERP_INTELLIGENCE_RATE_LIMIT = 60;
 var SERP_INTELLIGENCE_RATE_WINDOW_SECONDS = 60;
 var POST_CAPTURE_ROUTE_LABEL = "POST /capture";
 var POST_PAGE_SNAPSHOTS_ROUTE_LABEL = "POST /page-snapshots";
-var serpIntelligenceApp = new Hono15();
+var serpIntelligenceApp = new Hono16();
 serpIntelligenceApp.use("*", createApiKeyAuth());
 function structuredError(input) {
   return {
@@ -15590,7 +15793,7 @@ serpIntelligenceApp.post("/page-snapshots", async (c) => {
 });
 
 // src/mcp/mcp-routes.ts
-import { Hono as Hono16 } from "hono";
+import { Hono as Hono17 } from "hono";
 import { WebStandardStreamableHTTPServerTransport } from "@modelcontextprotocol/sdk/server/webStandardStreamableHttp.js";
 
 // src/mcp/memory-inprocess-executor.ts
@@ -16172,7 +16375,7 @@ async function requireMcpCallerKey(c) {
   if (!user) return mcpAuthError();
   return { key: callerKey, user };
 }
-var mcpApp = new Hono16();
+var mcpApp = new Hono17();
 mcpApp.all("/", async (c) => {
   try {
     const keyOrError = await requireMcpCallerKey(c);
@@ -16198,11 +16401,11 @@ mcpApp.all("/", async (c) => {
 });
 
 // src/api/browser-agent-routes.ts
-import { randomUUID as randomUUID3 } from "crypto";
-import { Hono as Hono17 } from "hono";
+import { randomUUID as randomUUID4 } from "crypto";
+import { Hono as Hono18 } from "hono";
 
 // src/api/browser-agent-db.ts
-import { randomUUID as randomUUID2 } from "crypto";
+import { randomUUID as randomUUID3 } from "crypto";
 var _ready = false;
 async function migrateBrowserAgent() {
   if (_ready) return;
@@ -16306,7 +16509,7 @@ async function migrateBrowserAgent() {
 }
 async function createExtensionRow(input) {
   const db = getDb();
-  const id = `bext_${randomUUID2().replace(/-/g, "").slice(0, 20)}`;
+  const id = `bext_${randomUUID3().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 (?, ?, ?, ?, ?, ?, ?, ?)`,
@@ -16341,7 +16544,7 @@ async function deleteExtensionRow(userId, name) {
 }
 async function createAuthConnectionRow(input) {
   const db = getDb();
-  const connectionId = `authc_${randomUUID2().replace(/-/g, "").slice(0, 20)}`;
+  const connectionId = `authc_${randomUUID3().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', ?)`,
@@ -16375,7 +16578,7 @@ async function listAuthConnectionsByProfile(profile) {
 }
 async function createSessionRow(input) {
   const db = getDb();
-  const id = `bas_${randomUUID2().replace(/-/g, "").slice(0, 20)}`;
+  const id = `bas_${randomUUID3().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'))`,
@@ -16444,7 +16647,7 @@ async function recordAction(input) {
     sql: `INSERT INTO browser_agent_actions (id, session_id, type, params_json, ok, error)
           VALUES (?, ?, ?, ?, ?, ?)`,
     args: [
-      `baa_${randomUUID2().replace(/-/g, "").slice(0, 20)}`,
+      `baa_${randomUUID3().replace(/-/g, "").slice(0, 20)}`,
       input.sessionId,
       input.type,
       input.params == null ? null : JSON.stringify(input.params),
@@ -17674,7 +17877,7 @@ async function loadOpenSession(id, userId) {
   return row;
 }
 function buildBrowserAgentRoutes() {
-  const app2 = new Hono17();
+  const app2 = new Hono18();
   app2.use("*", async (c, next) => {
     await migrateBrowserAgent();
     return next();
@@ -18132,7 +18335,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}_${randomUUID3().replace(/-/g, "")}`;
+    const backendName = `u${user.id}_${randomUUID4().replace(/-/g, "")}`;
     try {
       const imported = await importExtensionFromStore(storeUrl, backendName);
       const row = await createExtensionRow({
@@ -18464,9 +18667,9 @@ if (state.key) { refreshSessions(); if (state.current) selectSession(state.curre
 
 // src/api/stripe-routes.ts
 import Stripe from "stripe";
-import { Hono as Hono18 } from "hono";
+import { Hono as Hono19 } from "hono";
 var stripe = new Stripe(process.env.STRIPE_SECRET_KEY, { apiVersion: "2026-02-25.clover" });
-var stripeApp = new Hono18();
+var stripeApp = new Hono19();
 stripeApp.post("/webhooks", async (c) => {
   const sig = c.req.header("stripe-signature");
   const body = await c.req.text();
@@ -18568,9 +18771,9 @@ async function resolveUser(customerId, emailFallback) {
 }
 
 // src/api/oauth-routes.ts
-import { Hono as Hono19 } from "hono";
+import { Hono as Hono20 } from "hono";
 import { getCookie, setCookie } from "hono/cookie";
-import { createHash as createHash3, randomBytes as randomBytes2, randomUUID as randomUUID4 } from "crypto";
+import { createHash as createHash4, randomBytes as randomBytes2, randomUUID as randomUUID5 } 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";
@@ -18603,7 +18806,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 = createHash3("sha256").update(JSON.stringify({ e: publicJwk.e, kty: publicJwk.kty, n: publicJwk.n })).digest("base64url").slice(0, 16);
+  const kid = createHash4("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";
@@ -18737,7 +18940,7 @@ function redirectWithError(redirectUri, state, error) {
   if (state) u.searchParams.set("state", state);
   return new Response(null, { status: 302, headers: { Location: u.toString() } });
 }
-var oauthApp = new Hono19();
+var oauthApp = new Hono20();
 oauthApp.use("*", async (c, next) => {
   c.header("Access-Control-Allow-Origin", "*");
   c.header("Access-Control-Allow-Methods", "GET, POST, OPTIONS");
@@ -18913,12 +19116,12 @@ oauthApp.post("/oauth/authorize", async (c) => {
 });
 function pkceMatches(verifier, challenge) {
   if (!verifier) return false;
-  const computed = createHash3("sha256").update(verifier).digest("base64url");
+  const computed = createHash4("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(randomUUID4()).setExpirationTime(`${ACCESS_TTL_SECONDS}s`).sign(privateKey);
+  return new SignJWT({ scope, plan }).setProtectedHeader({ alg: "RS256", kid }).setIssuer(ISSUER).setSubject(identity).setAudience(audience).setIssuedAt().setJti(randomUUID5()).setExpirationTime(`${ACCESS_TTL_SECONDS}s`).sign(privateKey);
 }
 function tokenErrorResponse(c, error, description, status) {
   return c.json({ error, error_description: description }, status);
@@ -18991,8 +19194,8 @@ oauthApp.post("/oauth/token", async (c) => {
 });
 
 // src/api/chat-routes.ts
-import { Hono as Hono20 } from "hono";
-var chatApp = new Hono20();
+import { Hono as Hono21 } from "hono";
+var chatApp = new Hono21();
 function tokenOk(token) {
   return !!token && token.startsWith("mk_") && token.length > 10;
 }
@@ -19662,8 +19865,8 @@ loadChannels();
 }
 
 // src/api/schedule-routes.ts
-import { Hono as Hono21 } from "hono";
-var scheduleApp = new Hono21();
+import { Hono as Hono22 } from "hono";
+var scheduleApp = new Hono22();
 function tokenOk2(token) {
   return !!token && token.startsWith("mk_") && token.length > 10;
 }
@@ -19854,8 +20057,15 @@ async function loadStatus() {
   const r = await get('/api/status');
   const text = document.getElementById('quota-text');
   const fill = document.getElementById('quota-fill');
-  if (!r.ok || !r.enabled) {
-    text.textContent = 'No active Scheduled Actions subscription.';
+  if (!r.ok) {
+    text.textContent = 'Scheduled Actions status is temporarily unavailable.';
+    text.classList.remove('warn');
+    fill.style.width = '0%';
+    fill.classList.remove('warn');
+    return;
+  }
+  if (r.billingMode === 'credits') {
+    text.textContent = (r.runBaseCredits || 75) + ' Credits per run + AI at ' + (r.llmCostMultiplier || 1.5) + '\xD7 actual OpenRouter cost';
     text.classList.remove('warn');
     fill.style.width = '0%';
     fill.classList.remove('warn');
@@ -19987,7 +20197,7 @@ loadActions();
 }
 
 // src/api/resend-inbound-routes.ts
-import { Hono as Hono22 } from "hono";
+import { Hono as Hono23 } from "hono";
 import { Resend } from "resend";
 var SUPPORT_ADDRESS = "support@mcpscraper.dev";
 var DMARC_ADDRESS = "dmarc@mcpscraper.dev";
@@ -20163,7 +20373,7 @@ async function forwardReceivedEmail(resend, email, destination, label) {
   if (sent.error) throw new Error(`forward failed: ${sent.error.message}`);
   return sent.data.id;
 }
-var resendInboundApp = new Hono22();
+var resendInboundApp = new Hono23();
 resendInboundApp.post("/webhooks", async (c) => {
   const apiKey = process.env.RESEND_API_KEY?.trim();
   const webhookSecret = process.env.RESEND_WEBHOOK_SECRET?.trim();
@@ -20257,13 +20467,13 @@ import { getCookie as getCookie2, setCookie as setCookie2, deleteCookie } from "
 import Stripe2 from "stripe";
 
 // src/api/page-diff.ts
-import { createHash as createHash4 } from "crypto";
+import { createHash as createHash5 } 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 createHash4("sha256").update(value).digest("hex");
+  return createHash5("sha256").update(value).digest("hex");
 }
 function truncateForStorage(value, maxChars = MAX_SNAPSHOT_CONTENT_CHARS) {
   if (value.length <= maxChars) return { value, truncated: false };
@@ -20370,7 +20580,7 @@ async function persistScrapeBody(user, opts) {
 }
 
 // src/api/connection-memory-import.ts
-import { createHash as createHash5 } from "crypto";
+import { createHash as createHash6 } 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;
@@ -20400,7 +20610,7 @@ function canonicalJson(value) {
   return JSON.stringify(value);
 }
 function sha2562(value) {
-  return createHash5("sha256").update(value).digest("hex");
+  return createHash6("sha256").update(value).digest("hex");
 }
 function sensitiveKey(key) {
   const normalized = key.toLowerCase().replace(/[^a-z0-9]/g, "");
@@ -20618,8 +20828,8 @@ async function importServiceConnectionToMemory(identity, input, dependencies) {
 
 // src/api/scrape-blob-cleanup.ts
 import { readdir, stat, unlink } from "fs/promises";
-import { homedir as homedir2 } from "os";
-import { join as join6 } from "path";
+import { homedir } from "os";
+import { join as join5 } from "path";
 async function cleanupVercel(token, cutoff) {
   const { list, del } = await import("@vercel/blob");
   let cursor;
@@ -20636,8 +20846,8 @@ async function cleanupVercel(token, cutoff) {
   return { deleted, store: "vercel-blob" };
 }
 async function cleanupLocal(cutoff) {
-  const baseDir = process.env.MCP_SCRAPER_OUTPUT_DIR?.trim() || join6(homedir2(), "Downloads", "mcp-scraper");
-  const dir = join6(baseDir, "blobs", SCRAPE_FALLBACK_PREFIX.replace(/\/$/, ""));
+  const baseDir = process.env.MCP_SCRAPER_OUTPUT_DIR?.trim() || join5(homedir(), "Downloads", "mcp-scraper");
+  const dir = join5(baseDir, "blobs", SCRAPE_FALLBACK_PREFIX.replace(/\/$/, ""));
   let deleted = 0;
   let entries;
   try {
@@ -20646,7 +20856,7 @@ async function cleanupLocal(cutoff) {
     return { deleted: 0, store: "local" };
   }
   for (const name of entries) {
-    const path5 = join6(dir, name);
+    const path5 = join5(dir, name);
     try {
       const s = await stat(path5);
       if (s.isFile() && s.mtimeMs < cutoff) {
@@ -20669,7 +20879,7 @@ async function cleanupExpiredScrapeBlobs(maxAgeMs = SCRAPE_BLOB_TTL_MS) {
 }
 
 // src/api/connected-data-export.ts
-import { randomUUID as randomUUID5 } from "crypto";
+import { randomUUID as randomUUID6 } from "crypto";
 var CONNECTED_DATA_INLINE_BUDGET_BYTES = Number(
   process.env.MCP_SCRAPER_CONNECTED_DATA_INLINE_BUDGET_BYTES ?? 5e4
 );
@@ -20794,7 +21004,7 @@ function finitePositive(value, fallback) {
   return Number.isFinite(value) && value > 0 ? value : fallback;
 }
 async function collectConnectedDataExport(args) {
-  const exportId = randomUUID5();
+  const exportId = randomUUID6();
   const now = args.now ?? Date.now;
   const startedAt = now();
   const budgetMs = finitePositive(CONNECTED_DATA_EXPORT_BUDGET_MS, 24e4);
@@ -21123,7 +21333,7 @@ async function dbUsage(identity, plan) {
 }
 
 // src/api/nango-control.ts
-import { createHash as createHash6 } from "crypto";
+import { createHash as createHash7 } from "crypto";
 var DEFAULT_NANGO_CONTROL_URL = "https://mcp-scraper-scheduler.vercel.app";
 var DISABLED_NANGO_TOOLS = {
   "google-mail": /* @__PURE__ */ new Set(["list-filters"]),
@@ -21722,7 +21932,7 @@ function canonicalJson2(value) {
   return JSON.stringify(value);
 }
 function projectedToolSchemaHash(tool) {
-  return createHash6("sha256").update(canonicalJson2(tool)).digest("hex");
+  return createHash7("sha256").update(canonicalJson2(tool)).digest("hex");
 }
 async function describeNangoTool(identity, connectionId, tool, fresh) {
   const body = await controlRequest("/api/internal/nango/connections/actions/describe", {
@@ -22219,7 +22429,7 @@ var auth2 = createMiddleware3(async (c, next) => {
   const user = await getUserByApiKey(key);
   if (!user) return c.json({ error: "Invalid or inactive API key" }, 401);
   const refreshed = await applyMonthlyFreeRefresh(user);
-  const balanceMc = await reconcileBalanceMc(refreshed.id);
+  const balanceMc = await reconcileBalanceMc(refreshed.id, refreshed.balance_mc);
   c.set("user", { ...refreshed, balance_mc: balanceMc });
   return next();
 });
@@ -22238,7 +22448,7 @@ var sessionAuth = createMiddleware3(async (c, next) => {
   const user = await getUserById(userId);
   if (!user) return c.json({ error: "User not found" }, 401);
   const refreshed = await applyMonthlyFreeRefresh(user);
-  const balanceMc = await reconcileBalanceMc(refreshed.id);
+  const balanceMc = await reconcileBalanceMc(refreshed.id, refreshed.balance_mc);
   c.set("sessionUser", { ...refreshed, balance_mc: balanceMc });
   return next();
 });
@@ -22253,7 +22463,7 @@ var requireIntegrationsTier = createMiddleware3(async (c, next) => {
   }
   return next();
 });
-var app = new Hono23();
+var app = new Hono24();
 var STRIPE_API_VERSION = "2026-02-25.clover";
 function requireStripeSecret() {
   const secret2 = process.env.STRIPE_SECRET_KEY?.trim();
@@ -22478,7 +22688,7 @@ app.get("/me", async (c) => {
   }
   const refreshed = await applyMonthlyFreeRefresh(foundUser);
   const [balanceMc, stats] = await Promise.all([
-    reconcileBalanceMc(refreshed.id),
+    reconcileBalanceMc(refreshed.id, refreshed.balance_mc),
     getUserStats(refreshed.id)
   ]);
   const user = { ...refreshed, balance_mc: balanceMc };
@@ -22754,41 +22964,13 @@ app.post("/memory/portal", auth2, async (c) => {
   }
 });
 app.post("/schedule-checkout", auth2, async (c) => {
-  try {
-    const user = c.get("user");
-    const body = await c.req.json().catch(() => ({}));
-    const priceId = body.priceId?.trim();
-    if (!priceId || !SCHEDULING_PLANS[priceId]) return c.json({ error: "Invalid priceId \u2014 must be a scheduling 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 });
-    let customerId = user.stripe_customer_id;
-    if (!customerId) {
-      const customer = await stripeClient.customers.create({ email: user.email });
-      customerId = customer.id;
-      await setStripeCustomerId(user.id, customerId);
-    }
-    const session = await stripeClient.checkout.sessions.create({
-      mode: "subscription",
-      customer: customerId,
-      line_items: [{ price: priceId, quantity: 1 }],
-      client_reference_id: String(user.id),
-      metadata: { product: "mcp-scheduling", userId: String(user.id) },
-      subscription_data: { metadata: { product: "mcp-scheduling", userId: String(user.id) } },
-      automatic_tax: { enabled: true },
-      billing_address_collection: "required",
-      customer_update: { address: "auto", name: "auto" },
-      tax_id_collection: { enabled: true },
-      success_url: `${appOrigin()}/memory?billing=success`,
-      cancel_url: `${appOrigin()}/memory?billing=cancel`
-    });
-    if (!session.url) return c.json({ error: "Stripe did not return a checkout URL." }, 502);
-    return c.json({ url: session.url });
-  } catch (err) {
-    const message = err instanceof Error ? err.message : "Unable to start scheduling checkout.";
-    console.error("[schedule-checkout]", message);
-    return c.json({ error: message }, 500);
-  }
+  return c.json({
+    error_code: "scheduled_actions_now_credit_metered",
+    error: "Scheduled Actions is included and no longer requires a separate subscription.",
+    billingMode: "credits",
+    runBaseCredits: SCHEDULED_RUN_BASE_CREDITS,
+    llmCostMultiplier: SCHEDULED_AGENT_LLM_MARKUP
+  }, 410);
 });
 function scheduleConnectionError(c, err, fallback) {
   if (err instanceof ScheduleConnectionValidationError) return c.json({ ok: false, error: err.message }, 400);
@@ -22902,7 +23084,14 @@ app.get("/schedule-status", auth2, async (c) => {
     const { key, error } = await getOrCreateUserMemoryKey(user);
     if (!key) return c.json({ error: error ?? "memory unavailable" }, 503);
     const r = await memoryCall("getScheduleStatusTool", {}, key);
-    return c.json(r);
+    return c.json({
+      ...r,
+      ok: true,
+      enabled: true,
+      billingMode: "credits",
+      runBaseCredits: SCHEDULED_RUN_BASE_CREDITS,
+      llmCostMultiplier: SCHEDULED_AGENT_LLM_MARKUP
+    });
   } catch (err) {
     const message = err instanceof Error ? err.message : "Unable to get schedule status.";
     console.error("[schedule-status]", message);
@@ -23902,7 +24091,8 @@ app.post("/extract-site", auth2, async (c) => {
   if (checked.error || !checked.parsed) return c.json({ error: checked.error ?? "Invalid URL" }, 400);
   const parsed = checked.parsed;
   const user = c.get("user");
-  if (body.background === true) {
+  const downloadImages = body.downloadImages === true;
+  if (body.background === true || downloadImages) {
     const affordablePages = Math.floor(user.balance_mc / MC_COSTS.page_scrape);
     if (affordablePages < 1) return c.json(insufficientBalanceResponse(user.balance_mc, MC_COSTS.page_scrape), 402);
     const maxPages = Math.min(Math.min(1e4, Math.max(1, body.maxPages ?? 1e4)), affordablePages);
@@ -23917,6 +24107,7 @@ app.post("/extract-site", auth2, async (c) => {
         concurrency: concurrencyLimitForUser(user),
         urlsPerBrowser: body.rotateProxyEvery ?? 10,
         formats: body.formats,
+        downloadImages,
         heldMc
       });
       jobCreated = true;
@@ -24225,7 +24416,7 @@ app.post("/billing/concurrency/cancel", requireAllowedOrigin, sessionAuth, async
 });
 app.get("/billing/balance", auth2, async (c) => {
   const user = c.get("user");
-  const balanceMc = await reconcileBalanceMc(user.id);
+  const balanceMc = user.balance_mc;
   const ledger = await getLedger(user.id, 20);
   const freeCredits = await getFreeCreditBreakdown(user.id);
   return c.json({
@@ -24237,7 +24428,7 @@ app.get("/billing/balance", auth2, async (c) => {
 });
 app.post("/billing/credits", auth2, async (c) => {
   const user = c.get("user");
-  const balanceMc = await reconcileBalanceMc(user.id);
+  const balanceMc = user.balance_mc;
   const body = await c.req.json().catch(() => ({}));
   const query = body.item?.trim().toLowerCase();
   const costs = CREDIT_COST_CATALOG.map(({ aliases, ...cost }) => cost);
@@ -24270,7 +24461,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-AM2DHUWG.js");
+  const { drainQueue } = await import("./worker-45WEWCMQ.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([
@@ -24298,15 +24489,15 @@ 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-NVSZH35Y.js");
-  const { assembleExtractArtifacts } = await import("./extract-bundle-U4D5LW5W.js");
+  const { getExtractJob: getExtractJob2, completeExtractJob: completeExtractJob2 } = await import("./site-extract-repository-YNPXEZCB.js");
+  const { assembleExtractArtifacts } = await import("./extract-bundle-HMCYUVBJ.js");
   const job = await getExtractJob2(jobId);
   if (!job) return c.json({ error: "job not found" }, 404);
   const stored = await assembleExtractArtifacts(job, {});
   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-NVSZH35Y.js");
+    const { settleExtractJob: settleExtractJob2, countSuccessfulPages: countSuccessfulPages2 } = await import("./site-extract-repository-YNPXEZCB.js");
     const heldMc = Number(job.options.heldMc ?? 0);
     const successful = await countSuccessfulPages2(jobId);
     const usedMc = Math.min(successful * MC_COSTS.page_scrape, heldMc);
@@ -24324,6 +24515,7 @@ app.post("/api/internal/extract-refinalize/:id", async (c) => {
 app.on(["GET", "POST", "PUT"], "/api/inngest", serveInngest({ client: inngest, functions: [siteAuditFn, siteExtractFn] }));
 app.route("/api/internal/site-architecture-auditor", siteAuditApp);
 app.route("/api/internal/memory", internalMemoryApp);
+app.route("/api/internal/billing", internalBillingApp);
 app.route("/youtube", youtubeApp);
 app.route("/screenshot", screenshotApp);
 app.route("/facebook", facebookAdApp);
@@ -24471,4 +24663,4 @@ app.get("/blog/:slug/", (c) => {
 export {
   app
 };
-//# sourceMappingURL=server-VWXDE64Y.js.map
+//# sourceMappingURL=server-PH3VJ74X.js.map