mcp-scraper 0.3.0 → 0.3.2

package/dist/{server-MOP7NIUK.js → server-N5LM3PEO.js}

@@ -16,7 +16,7 @@ import {
   harvestProblemResponse,
   insufficientBalanceResponse,
   serializeHarvestProblem
-} from "./chunk-SXTXMFEQ.js";
+} from "./chunk-AZ5PKU4F.js";
 import {
   SiteAuditJobRowSchema,
   advanceWorkflowRunStep,
@@ -85,7 +85,7 @@ import {
   deleteKernelProxyId,
   harvest,
   resolveKernelProxyId
-} from "./chunk-IPW4LFOT.js";
+} from "./chunk-UWSG3C5J.js";
 import {
   CaptureSerpPageSnapshotsInputSchema,
   CaptureSerpPageSnapshotsOutputSchema,
@@ -99,7 +99,7 @@ import {
   harvestTimeoutBudget,
   liveWebToolAnnotations,
   outputBaseDir
-} from "./chunk-SIXJ6EVS.js";
+} from "./chunk-KO223PSJ.js";
 import {
   CaptchaError,
   RECAPTCHA_INSTRUCTIONS,
@@ -135,7 +135,12 @@ import {
   RawMapsOverviewSchema,
   RawMapsReviewStatsSchema
 } from "./chunk-LFATOGDF.js";
-import "./chunk-PGWJ2EJ3.js";
+import {
+  defaultChromeExecutablePath,
+  loadImportedBrowserProfile,
+  localBrowserModeEnabled
+} from "./chunk-DUEW4EOO.js";
+import "./chunk-VB65G7PS.js";
 
 // src/api/outbound-sanitize.ts
 var KEY_RENAMES = {
@@ -4078,9 +4083,9 @@ async function extractBrandingFromPage(page) {
     colors: {
       primary: primary && !isTransparentOrWhite(primary) ? primary : null,
       accent: accent && !isTransparentOrWhite(accent) ? accent : null,
-      background: background && !isTransparentOrWhite(background) ? background : null,
-      text: text && text !== "#000000" ? text : null,
-      heading: heading && heading !== "#000000" ? heading : null
+      background: background ?? null,
+      text: text ?? null,
+      heading: heading ?? null
     },
     fonts: {
       body: firstFont(raw.bodyFont ?? ""),
@@ -4421,8 +4426,8 @@ async function downloadAsset(url, destDir, filename) {
   }
   const writer = createWriteStream(dest);
   await pipeline(Readable.fromWeb(res.body), writer);
-  const { statSync } = await import("fs");
-  const sizeBytes = statSync(dest).size;
+  const { statSync: statSync2 } = await import("fs");
+  const sizeBytes = statSync2(dest).size;
   return { savedPath: dest, sizeBytes, mimeType };
 }
 async function harvestPageMedia(html, pageUrl, options = {}) {
@@ -4899,7 +4904,7 @@ async function extractSite(opts) {
 }
 
 // src/api/server.ts
-import { Hono as Hono12 } from "hono";
+import { Hono as Hono13 } from "hono";
 import { serve as serveInngest } from "inngest/hono";
 
 // src/inngest/client.ts
@@ -9346,7 +9351,41 @@ async function extractFacebookOrganicVideoFromPage(page, sourceUrl, quality = "b
 }
 
 // src/api/facebook-ad-routes.ts
+import { fal as fal3 } from "@fal-ai/client";
+
+// src/services/media-transcription.ts
 import { fal as fal2 } from "@fal-ai/client";
+function transcriptMarkdown(title, text, chunks, durationMs) {
+  const fmtTs2 = (s) => `${Math.floor(s / 60)}:${String(Math.floor(s % 60)).padStart(2, "0")}`;
+  const lines = [title, "", `*Transcribed in ${(durationMs / 1e3).toFixed(1)}s*`, "", "## Full Text", "", text, ""];
+  if (chunks.length) {
+    lines.push("## Timestamped Segments", "");
+    for (const ch of chunks) {
+      lines.push(`**[${fmtTs2(ch.timestamp[0])} -> ${fmtTs2(ch.timestamp[1])}]** ${ch.text.trim()}`, "");
+    }
+  }
+  return lines.join("\n");
+}
+async function transcribeMediaUrl(mediaUrl, markdownTitle = "# Media Transcript") {
+  const startMs = Date.now();
+  const result = await fal2.subscribe("fal-ai/wizper", {
+    input: { audio_url: mediaUrl, task: "transcribe", language: "en" },
+    logs: false,
+    pollInterval: 3e3
+  });
+  const data = result.data;
+  const text = data.text ?? "";
+  const chunks = data.chunks ?? [];
+  const durationMs = Date.now() - startMs;
+  return {
+    text,
+    chunks,
+    durationMs,
+    markdown: transcriptMarkdown(markdownTitle, text, chunks, durationMs)
+  };
+}
+
+// src/api/facebook-ad-routes.ts
 var FacebookAdBodySchema = z13.object({
   url: z13.string().trim().optional(),
   libraryId: z13.string().trim().optional(),
@@ -9384,34 +9423,8 @@ function isAllowedFacebookOrganicUrl(url) {
   const hostname = url.hostname.toLowerCase().replace(/^www\./, "").replace(/^m\./, "");
   return hostname === "facebook.com" || hostname === "fb.watch";
 }
-function facebookTranscriptMarkdown(title, text, chunks, durationMs) {
-  const fmtTs2 = (s) => `${Math.floor(s / 60)}:${String(Math.floor(s % 60)).padStart(2, "0")}`;
-  const lines = [title, "", `*Transcribed in ${(durationMs / 1e3).toFixed(1)}s*`, "", "## Full Text", "", text, ""];
-  if (chunks.length) {
-    lines.push("## Timestamped Segments", "");
-    for (const ch of chunks) {
-      lines.push(`**[${fmtTs2(ch.timestamp[0])} -> ${fmtTs2(ch.timestamp[1])}]** ${ch.text.trim()}`, "");
-    }
-  }
-  return lines.join("\n");
-}
 async function transcribeFacebookVideoUrl(videoUrl, markdownTitle = "# Facebook Video Transcript") {
-  const startMs = Date.now();
-  const result = await fal2.subscribe("fal-ai/wizper", {
-    input: { audio_url: videoUrl, task: "transcribe", language: "en" },
-    logs: false,
-    pollInterval: 3e3
-  });
-  const data = result.data;
-  const text = data.text ?? "";
-  const chunks = data.chunks ?? [];
-  const durationMs = Date.now() - startMs;
-  return {
-    text,
-    chunks,
-    durationMs,
-    markdown: facebookTranscriptMarkdown(markdownTitle, text, chunks, durationMs)
-  };
+  return transcribeMediaUrl(videoUrl, markdownTitle);
 }
 async function detectSoftBlock(driver) {
   const page = driver.getPage();
@@ -9549,7 +9562,7 @@ facebookAdApp.post("/transcribe", createApiKeyAuth(), async (c) => {
     metadata: { videoUrl }
   });
   if (!gate.ok) return c.json(concurrencyLimitExceededResponse(gate), 429, { "Retry-After": String(gate.retryAfterSeconds) });
-  fal2.config({ credentials: process.env.FAL_KEY });
+  fal3.config({ credentials: process.env.FAL_KEY });
   let debited = false;
   try {
     const { ok, balance_mc } = await debitMc(fbUser.id, MC_COSTS.fb_transcribe, LedgerOperation.FB_TRANSCRIBE, videoUrl);
@@ -9588,7 +9601,7 @@ facebookAdApp.post("/video-transcribe", createApiKeyAuth(), async (c) => {
     metadata: { url: sourceUrl.href }
   });
   if (!gate.ok) return c.json(concurrencyLimitExceededResponse(gate), 429, { "Retry-After": String(gate.retryAfterSeconds) });
-  fal2.config({ credentials: process.env.FAL_KEY });
+  fal3.config({ credentials: process.env.FAL_KEY });
   const driver = new BrowserDriver();
   let debited = false;
   try {
@@ -9763,8 +9776,735 @@ facebookAdApp.post("/media", createApiKeyAuth(), async (c) => {
   });
 });
 
-// src/api/maps-routes.ts
+// src/api/instagram-routes.ts
 import { Hono as Hono5 } from "hono";
+import { z as z14 } from "zod";
+import { createWriteStream as createWriteStream2, existsSync, mkdirSync as mkdirSync2, statSync, writeFileSync } from "fs";
+import { homedir as homedir2 } from "os";
+import { basename as basename2, join as join4 } from "path";
+import { Readable as Readable2 } from "stream";
+import { pipeline as pipeline2 } from "stream/promises";
+import { spawn } from "child_process";
+
+// src/extractor/InstagramContentExtractor.ts
+var CONTENT_PATH_RE = /^\/(?:[^/]+\/)?(p|reel|tv)\/([A-Za-z0-9_-]+)\/?/i;
+var CDN_HOST_RE = /(^|\.)((cdninstagram\.com)|(scontent[^/]*\.cdninstagram\.com))$/i;
+function htmlDecode2(value) {
+  return value.replace(/&amp;/g, "&").replace(/&quot;/g, '"').replace(/&#039;/g, "'").replace(/&lt;/g, "<").replace(/&gt;/g, ">");
+}
+function decodeEscapedValue2(raw) {
+  let out = raw;
+  try {
+    out = JSON.parse(`"${raw.replace(/"/g, '\\"')}"`);
+  } catch {
+    out = raw.replace(/\\u0025/g, "%").replace(/\\u0026/g, "&").replace(/\\u003D/g, "=").replace(/\\u003d/g, "=").replace(/\\"/g, '"').replace(/\\\//g, "/");
+  }
+  return htmlDecode2(out);
+}
+function metadataContent2(html, key) {
+  const escaped = key.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+  const re = new RegExp(`<meta\\s+[^>]*(?:property|name)=["']${escaped}["'][^>]*content=["']([^"']+)["'][^>]*>`, "i");
+  const m = html.match(re);
+  return m ? htmlDecode2(m[1]).trim() : null;
+}
+function instagramContentTypeFromPath(rawPath) {
+  const match = rawPath.match(CONTENT_PATH_RE);
+  if (!match) return null;
+  const type = match[1].toLowerCase() === "p" ? "post" : match[1].toLowerCase();
+  return { type, shortcode: match[2] };
+}
+function normalizeInstagramProfileInput(input) {
+  const raw = input.trim();
+  if (!raw) throw new Error("Instagram handle or profile URL is required");
+  if (/^https?:\/\//i.test(raw) || /^www\.instagram\.com/i.test(raw) || /^instagram\.com/i.test(raw)) {
+    const parsed = new URL(/^https?:\/\//i.test(raw) ? raw : `https://${raw}`);
+    const host = parsed.hostname.toLowerCase().replace(/^www\./, "").replace(/^m\./, "");
+    if (host !== "instagram.com") throw new Error("Profile URL must be on instagram.com");
+    const first = parsed.pathname.split("/").filter(Boolean)[0];
+    if (!first || ["p", "reel", "tv", "stories", "explore"].includes(first.toLowerCase())) {
+      throw new Error("Profile URL must point to an Instagram profile, not a post, reel, story, or explore page");
+    }
+    return { handle: first, profileUrl: `https://www.instagram.com/${first}/` };
+  }
+  const handle = raw.replace(/^@/, "").replace(/^\/+|\/+$/g, "");
+  if (!/^[A-Za-z0-9._]{1,30}$/.test(handle)) throw new Error("Invalid Instagram handle");
+  return { handle, profileUrl: `https://www.instagram.com/${handle}/` };
+}
+function isAllowedInstagramPageUrl(url) {
+  const host = url.hostname.toLowerCase().replace(/^www\./, "").replace(/^m\./, "");
+  return host === "instagram.com";
+}
+function normalizeInstagramMediaUrl(raw) {
+  try {
+    const decoded = decodeEscapedValue2(raw);
+    const parsed = new URL(decoded);
+    if (!CDN_HOST_RE.test(parsed.hostname.toLowerCase())) return null;
+    parsed.searchParams.delete("bytestart");
+    parsed.searchParams.delete("byteend");
+    return parsed.href;
+  } catch {
+    return null;
+  }
+}
+function parseInstagramEfg(url) {
+  try {
+    const efg = new URL(url).searchParams.get("efg");
+    if (!efg) return null;
+    return JSON.parse(Buffer.from(efg, "base64").toString("utf8"));
+  } catch {
+    return null;
+  }
+}
+function trackFromUrl(url) {
+  const normalized = normalizeInstagramMediaUrl(url);
+  if (!normalized) return null;
+  const parsed = parseInstagramEfg(normalized);
+  const tag = typeof parsed?.vencode_tag === "string" ? parsed.vencode_tag : null;
+  const streamType = tag?.toLowerCase().includes("audio") ? "audio" : normalized.includes(".mp4") ? "video" : "unknown";
+  return {
+    url: normalized,
+    streamType,
+    bitrate: typeof parsed?.bitrate === "number" ? parsed.bitrate : null,
+    durationSec: typeof parsed?.duration_s === "number" ? parsed.duration_s : null,
+    vencodeTag: tag,
+    width: typeof parsed?.width === "number" ? parsed.width : null,
+    height: typeof parsed?.height === "number" ? parsed.height : null
+  };
+}
+function extractInstagramMp4UrlsFromText(text) {
+  const urls = [];
+  const seen = /* @__PURE__ */ new Set();
+  const patterns = [
+    /https?:\\?\/\\?\/[^"'<>\s]+?\.mp4(?:\?[^"'<>\s]+)?/g,
+    /https?:%5C?\/%5C?\/[^"'<>\s]+?\.mp4(?:\?[^"'<>\s]+)?/g
+  ];
+  for (const pattern of patterns) {
+    let match;
+    while ((match = pattern.exec(text)) !== null) {
+      const normalized = normalizeInstagramMediaUrl(match[0].replace(/%5C/gi, "\\"));
+      if (!normalized || seen.has(normalized)) continue;
+      seen.add(normalized);
+      urls.push(normalized);
+    }
+  }
+  return urls;
+}
+function instagramTracksFromUrls(urls) {
+  const seen = /* @__PURE__ */ new Set();
+  const tracks = [];
+  for (const raw of urls) {
+    const track = trackFromUrl(raw);
+    if (!track || seen.has(track.url)) continue;
+    seen.add(track.url);
+    tracks.push(track);
+  }
+  return tracks;
+}
+function selectInstagramTracks(tracks) {
+  const selectedVideoTrack = tracks.filter((track) => track.streamType === "video").sort((a, b) => {
+    const aPixels = (a.width ?? 0) * (a.height ?? 0);
+    const bPixels = (b.width ?? 0) * (b.height ?? 0);
+    if (aPixels !== bPixels) return bPixels - aPixels;
+    return (b.bitrate ?? 0) - (a.bitrate ?? 0);
+  })[0] ?? null;
+  const selectedAudioTrack = tracks.filter((track) => track.streamType === "audio").sort((a, b) => (b.bitrate ?? 0) - (a.bitrate ?? 0))[0] ?? null;
+  return { selectedVideoTrack, selectedAudioTrack };
+}
+function parseCount(text) {
+  if (!text) return null;
+  const match = text.match(/([\d,.]+)\s*posts?/i);
+  if (!match) return null;
+  const value = Number(match[1].replace(/[,.]/g, ""));
+  return Number.isFinite(value) ? value : null;
+}
+function captionFromMetadata(metadata) {
+  const raw = metadata.ogDescription ?? metadata.description;
+  if (!raw) return null;
+  const quoted = raw.match(/:\s*"([\s\S]+)"\.?\s*$/);
+  if (quoted?.[1]) return quoted[1].trim();
+  return raw.trim();
+}
+function ownerFromMetadata(metadata) {
+  const title = metadata.ogTitle ?? metadata.twitterTitle ?? metadata.title;
+  if (!title) return null;
+  const match = title.match(/^(.+?)\s+on Instagram:/i) ?? title.match(/^(.+?)\s+\(@[^)]+\)\s+•\s+Instagram/i);
+  return match?.[1]?.trim() || null;
+}
+async function collectInstagramProfileContentFromPage(page, opts) {
+  const maxItems = Math.min(500, Math.max(1, opts.maxItems ?? 50));
+  const maxScrolls = Math.min(100, Math.max(0, opts.maxScrolls ?? 10));
+  const scrollDelayMs = Math.min(5e3, Math.max(250, opts.scrollDelayMs ?? 1200));
+  const stableScrollLimit = Math.min(10, Math.max(1, opts.stableScrollLimit ?? 4));
+  const seen = /* @__PURE__ */ new Set();
+  const items = [];
+  const stages = [];
+  let attemptedScrolls = 0;
+  let stableScrolls = 0;
+  let stoppedReason = null;
+  const collect = async (stage) => {
+    const before = items.length;
+    const links = await page.evaluate(() => Array.from(document.querySelectorAll("a[href]")).map((a) => ({
+      href: a.href,
+      text: (a.textContent ?? "").replace(/\s+/g, " ").trim()
+    })));
+    for (const link of links) {
+      let parsed;
+      try {
+        parsed = new URL(link.href);
+      } catch {
+        continue;
+      }
+      const found = instagramContentTypeFromPath(parsed.pathname);
+      if (!found) continue;
+      const normalized = `https://www.instagram.com/${found.type === "post" ? "p" : found.type}/${found.shortcode}/`;
+      if (seen.has(normalized)) continue;
+      seen.add(normalized);
+      items.push({
+        url: normalized,
+        type: found.type,
+        shortcode: found.shortcode,
+        anchorText: link.text || null,
+        firstSeenStage: stage
+      });
+      if (items.length >= maxItems) return items.length - before;
+    }
+    return items.length - before;
+  };
+  const readBodyText = async () => page.evaluate(() => document.body?.innerText ?? "").catch(() => "");
+  const profileLines = (text) => text.split("\n").map((line) => line.trim()).filter(Boolean);
+  const profilePostCountText = (text) => profileLines(text).find((line) => /\bposts?\b/i.test(line) && /[\d,.]/.test(line)) ?? null;
+  const scrollMetrics = async () => page.evaluate(() => ({
+    scrollY: typeof window.scrollY === "number" ? window.scrollY : null,
+    scrollHeight: Math.max(
+      document.body?.scrollHeight ?? 0,
+      document.documentElement?.scrollHeight ?? 0
+    ) || null
+  })).catch(() => ({ scrollY: null, scrollHeight: null }));
+  const recordStage = async (stage, addedCount) => {
+    const metrics = await scrollMetrics();
+    stages.push({
+      stage,
+      itemCount: items.length,
+      addedCount,
+      scrollY: metrics.scrollY,
+      scrollHeight: metrics.scrollHeight
+    });
+  };
+  const advancePagination = async () => page.evaluate(() => {
+    const contentLinks = Array.from(document.querySelectorAll('a[href*="/p/"], a[href*="/reel/"], a[href*="/tv/"]'));
+    const last = contentLinks[contentLinks.length - 1];
+    if (last) last.scrollIntoView({ block: "end", inline: "nearest" });
+    const distance = Math.max(window.innerHeight * 0.9, 700);
+    window.scrollBy(0, distance);
+    return {
+      scrollY: typeof window.scrollY === "number" ? window.scrollY : null,
+      scrollHeight: Math.max(
+        document.body?.scrollHeight ?? 0,
+        document.documentElement?.scrollHeight ?? 0
+      ) || null
+    };
+  }).catch(() => ({ scrollY: null, scrollHeight: null }));
+  await page.waitForLoadState("domcontentloaded", { timeout: 15e3 }).catch(() => {
+  });
+  await page.waitForTimeout(1500);
+  await recordStage("initial", await collect("initial"));
+  const initialReportedPostCount = parseCount(profilePostCountText(await readBodyText()));
+  for (let i = 0; i < maxScrolls && items.length < maxItems && stableScrolls < stableScrollLimit; i++) {
+    const before = items.length;
+    const beforeMetrics = await scrollMetrics();
+    attemptedScrolls = i + 1;
+    await advancePagination();
+    await page.keyboard.press("PageDown").catch(() => {
+    });
+    await page.waitForLoadState("networkidle", { timeout: 2500 }).catch(() => {
+    });
+    await page.waitForTimeout(scrollDelayMs);
+    const added = await collect(`scroll_${i + 1}`);
+    await recordStage(`scroll_${i + 1}`, added);
+    const afterMetrics = await scrollMetrics();
+    const advanced = (afterMetrics.scrollHeight ?? 0) > (beforeMetrics.scrollHeight ?? 0) || (afterMetrics.scrollY ?? 0) > (beforeMetrics.scrollY ?? 0);
+    stableScrolls = items.length === before && !advanced ? stableScrolls + 1 : 0;
+    if (initialReportedPostCount != null && items.length >= initialReportedPostCount) {
+      stoppedReason = "reported_post_count";
+      break;
+    }
+    if (items.length >= maxItems) {
+      stoppedReason = "max_items";
+      break;
+    }
+    if (stableScrolls >= stableScrollLimit) {
+      stoppedReason = "stable_scrolls";
+      break;
+    }
+  }
+  const bodyText = await readBodyText();
+  const lines = profileLines(bodyText);
+  const reportedPostCountText = lines.find((line) => /\bposts?\b/i.test(line) && /[\d,.]/.test(line)) ?? null;
+  const followerCountText = lines.find((line) => /\bfollowers?\b/i.test(line)) ?? null;
+  const followingCountText = lines.find((line) => /\bfollowing\b/i.test(line)) ?? null;
+  const profileName = lines.find((line) => line && line.toLowerCase() !== opts.handle.toLowerCase()) ?? null;
+  const typeCounts = {
+    post: items.filter((item) => item.type === "post").length,
+    reel: items.filter((item) => item.type === "reel").length,
+    tv: items.filter((item) => item.type === "tv").length
+  };
+  const reportedPostCount = parseCount(reportedPostCountText);
+  const reachedMaxItems = items.length >= maxItems;
+  const reachedReportedPostCount = reportedPostCount != null && items.length >= reportedPostCount;
+  if (!stoppedReason) {
+    stoppedReason = reachedMaxItems ? "max_items" : reachedReportedPostCount ? "reported_post_count" : maxScrolls === 0 ? "no_scrolls" : attemptedScrolls >= maxScrolls ? "max_scrolls" : "stable_scrolls";
+  }
+  const finalMetrics = await scrollMetrics();
+  const pagination = {
+    maxItems,
+    maxScrolls,
+    attemptedScrolls,
+    stableScrolls,
+    stableScrollLimit,
+    scrollDelayMs,
+    reachedMaxItems,
+    reachedReportedPostCount,
+    finalScrollHeight: finalMetrics.scrollHeight,
+    stoppedReason,
+    stages
+  };
+  const limitations = [];
+  if (/log in|sign up/i.test(bodyText)) limitations.push("Login or sign-up prompts were visible during extraction.");
+  if (reachedMaxItems && !reachedReportedPostCount) limitations.push("Collection stopped at maxItems before the full profile history was proven.");
+  if (reportedPostCount != null && items.length < reportedPostCount && !reachedMaxItems) limitations.push("Collected item count is lower than the profile-reported post count.");
+  if (stoppedReason === "stable_scrolls" && !reachedReportedPostCount) limitations.push("Pagination stopped after repeated stable scrolls without new content.");
+  if (stoppedReason === "max_scrolls" && !reachedReportedPostCount) limitations.push("Pagination reached maxScrolls before the full profile history was proven.");
+  return {
+    handle: opts.handle,
+    profileUrl: opts.profileUrl,
+    pageUrl: page.url(),
+    profileName,
+    bio: null,
+    reportedPostCount,
+    reportedPostCountText,
+    followerCountText,
+    followingCountText,
+    collectedContentCount: items.length,
+    typeCounts,
+    pagination,
+    items,
+    limited: limitations.length > 0,
+    limitations,
+    extractedAt: (/* @__PURE__ */ new Date()).toISOString()
+  };
+}
+async function extractInstagramMediaFromPage(page, sourceUrl, capturedMediaUrls = []) {
+  await page.waitForLoadState("domcontentloaded", { timeout: 15e3 }).catch(() => {
+  });
+  await page.waitForTimeout(2500);
+  const html = await page.content();
+  const bodyText = await page.evaluate(() => document.body?.innerText ?? "").catch(() => "");
+  const metadata = {
+    title: await page.title().catch(() => null),
+    description: metadataContent2(html, "description"),
+    ogTitle: metadataContent2(html, "og:title"),
+    ogDescription: metadataContent2(html, "og:description"),
+    ogImage: metadataContent2(html, "og:image"),
+    ogUrl: metadataContent2(html, "og:url"),
+    twitterImage: metadataContent2(html, "twitter:image"),
+    twitterTitle: metadataContent2(html, "twitter:title")
+  };
+  const parsedPath = (() => {
+    try {
+      return instagramContentTypeFromPath(new URL(page.url()).pathname) ?? instagramContentTypeFromPath(new URL(sourceUrl).pathname);
+    } catch {
+      return null;
+    }
+  })();
+  const htmlUrls = extractInstagramMp4UrlsFromText(html);
+  const tracks = instagramTracksFromUrls([...capturedMediaUrls, ...htmlUrls]);
+  const selected = selectInstagramTracks(tracks);
+  const imageUrl = metadata.ogImage ?? metadata.twitterImage;
+  const limitations = [];
+  if (/log in|sign up/i.test(bodyText)) limitations.push("Login or sign-up prompts were visible during extraction.");
+  if (parsedPath?.type === "reel" && tracks.length === 0) limitations.push("No Instagram MP4 tracks were captured; retry with a logged-in browser profile or longer wait.");
+  return {
+    sourceUrl,
+    pageUrl: page.url(),
+    type: parsedPath?.type ?? null,
+    shortcode: parsedPath?.shortcode ?? null,
+    ownerName: ownerFromMetadata(metadata),
+    caption: captionFromMetadata(metadata),
+    bodyText,
+    metadata,
+    imageUrl,
+    tracks,
+    selectedVideoTrack: selected.selectedVideoTrack,
+    selectedAudioTrack: selected.selectedAudioTrack,
+    limitations,
+    extractedAt: (/* @__PURE__ */ new Date()).toISOString()
+  };
+}
+
+// src/api/instagram-routes.ts
+var InstagramBrowserModeSchema = z14.enum(["auto", "hosted", "local"]);
+var InstagramBrowserOptionsSchema = {
+  browserMode: InstagramBrowserModeSchema.default("auto"),
+  browserProfile: z14.string().trim().min(1).optional()
+};
+var InstagramProfileContentBodySchema = z14.object({
+  handle: z14.string().trim().optional(),
+  url: z14.string().trim().optional(),
+  maxItems: z14.number().int().min(1).max(500).default(50),
+  maxScrolls: z14.number().int().min(0).max(100).default(10),
+  scrollDelayMs: z14.number().int().min(250).max(5e3).default(1200),
+  stableScrollLimit: z14.number().int().min(1).max(10).default(4),
+  ...InstagramBrowserOptionsSchema
+}).refine((d) => !!d.handle || !!d.url, {
+  message: "handle or url is required"
+});
+var InstagramMediaTypeSchema = z14.enum(["image", "video", "audio"]);
+var InstagramMediaDownloadBodySchema = z14.object({
+  url: z14.string().trim().min(1, "url is required"),
+  mediaTypes: z14.array(InstagramMediaTypeSchema).default(["image", "video", "audio"]),
+  downloadMedia: z14.boolean().default(true),
+  downloadAllTracks: z14.boolean().default(false),
+  includeTranscript: z14.boolean().default(false),
+  mux: z14.boolean().default(true),
+  ...InstagramBrowserOptionsSchema
+});
+var instagramApp = new Hono5();
+function invalidRequest2(message) {
+  return { error_code: "invalid_request", message };
+}
+function directProfileDir() {
+  return process.env.MCP_SCRAPER_BROWSER_PROFILE_DIR?.trim() || void 0;
+}
+function configuredProfileName(profile) {
+  const directDir = directProfileDir();
+  return profile?.trim() || process.env.MCP_SCRAPER_BROWSER_PROFILE?.trim() || (directDir ? basename2(directDir) : "default");
+}
+function launchExecutablePath(manifestExecutablePath) {
+  const configured = process.env.MCP_SCRAPER_BROWSER_EXECUTABLE?.trim() || manifestExecutablePath || defaultChromeExecutablePath();
+  return configured && existsSync(configured) ? configured : void 0;
+}
+function ignoreDefaultArgsFor(executablePath) {
+  if (!executablePath) return void 0;
+  if (process.platform !== "darwin") return void 0;
+  if (!/Google Chrome\.app\/Contents\/MacOS\/Google Chrome$/.test(executablePath)) return void 0;
+  return ["--password-store=basic", "--use-mock-keychain"];
+}
+async function kernelLaunchOptsResidential2() {
+  let proxyId = browserServiceProxyId();
+  try {
+    const resolution = await resolveKernelProxyId({
+      kernelApiKey: browserServiceApiKey(),
+      proxyMode: DEFAULT_PROXY_MODE,
+      configuredKernelProxyId: browserServiceProxyId(),
+      gl: "us"
+    });
+    if (resolution.kernelProxyId) proxyId = resolution.kernelProxyId;
+  } catch {
+    proxyId = browserServiceProxyId();
+  }
+  return {
+    headless: true,
+    kernelApiKey: browserServiceApiKey(),
+    kernelProxyId: proxyId,
+    viewport: { width: 1280, height: 900 },
+    locale: "en-US"
+  };
+}
+async function resolveInstagramLaunch(input) {
+  const requestedMode = input.browserMode ?? "auto";
+  const directDir = directProfileDir();
+  const useLocal = requestedMode === "local" || requestedMode === "auto" && (Boolean(input.browserProfile) || Boolean(directDir) || localBrowserModeEnabled());
+  if (!useLocal) {
+    return {
+      config: await kernelLaunchOptsResidential2(),
+      browser: {
+        mode: "hosted",
+        requestedMode,
+        profileName: null,
+        profileSource: "hosted",
+        profileDirConfigured: false,
+        executablePathConfigured: false
+      }
+    };
+  }
+  const requestedName = configuredProfileName(input.browserProfile);
+  if (directDir && (!input.browserProfile || requestedName === process.env.MCP_SCRAPER_BROWSER_PROFILE?.trim())) {
+    const executablePath2 = launchExecutablePath(null);
+    return {
+      config: {
+        headless: false,
+        profileDir: directDir,
+        browserExecutablePath: executablePath2,
+        ignoreDefaultArgs: ignoreDefaultArgsFor(executablePath2),
+        viewport: { width: 1280, height: 900 },
+        locale: "en-US"
+      },
+      browser: {
+        mode: "local",
+        requestedMode,
+        profileName: requestedName,
+        profileSource: "direct_profile_dir",
+        profileDirConfigured: true,
+        executablePathConfigured: Boolean(executablePath2)
+      }
+    };
+  }
+  const manifest = await loadImportedBrowserProfile(requestedName);
+  const executablePath = launchExecutablePath(manifest.browserExecutablePath);
+  return {
+    config: {
+      headless: false,
+      profileDir: manifest.userDataDir,
+      browserExecutablePath: executablePath,
+      ignoreDefaultArgs: ignoreDefaultArgsFor(executablePath),
+      viewport: { width: 1280, height: 900 },
+      locale: "en-US"
+    },
+    browser: {
+      mode: "local",
+      requestedMode,
+      profileName: manifest.name,
+      profileSource: "managed_profile",
+      profileDirConfigured: true,
+      executablePathConfigured: Boolean(executablePath)
+    }
+  };
+}
+function outputBaseDir2() {
+  return process.env.MCP_SCRAPER_OUTPUT_DIR?.trim() || join4(homedir2(), "Downloads", "mcp-scraper");
+}
+function safeFilePart(input) {
+  return input.replace(/^https?:\/\//, "").replace(/[^a-z0-9._-]+/gi, "-").replace(/^-+|-+$/g, "").slice(0, 80) || "instagram";
+}
+function mediaOutputDir(shortcode, sourceUrl) {
+  const stamp = (/* @__PURE__ */ new Date()).toISOString().replace(/[:.]/g, "-").slice(0, 19);
+  const slug = shortcode ? `instagram-${shortcode}` : safeFilePart(sourceUrl);
+  const dir = join4(outputBaseDir2(), "instagram", `${stamp}-${slug}`);
+  mkdirSync2(dir, { recursive: true });
+  return dir;
+}
+async function downloadToFile(url, destPath, referer) {
+  const res = await fetch(url, {
+    headers: {
+      "User-Agent": "Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/124.0.0.0 Safari/537.36",
+      "Referer": referer
+    },
+    signal: AbortSignal.timeout(9e4)
+  });
+  if (!res.ok) throw new Error(`HTTP ${res.status}`);
+  if (!res.body) throw new Error("Empty response body");
+  await pipeline2(Readable2.fromWeb(res.body), createWriteStream2(destPath));
+  return {
+    savedPath: destPath,
+    sizeBytes: statSync(destPath).size,
+    mimeType: res.headers.get("content-type")?.split(";")[0]?.trim() ?? null
+  };
+}
+function extFromMime(mimeType, fallback) {
+  const map = {
+    "image/jpeg": "jpg",
+    "image/png": "png",
+    "image/webp": "webp",
+    "image/gif": "gif",
+    "video/mp4": "mp4",
+    "audio/mp4": "mp4",
+    "audio/aac": "aac"
+  };
+  return mimeType ? map[mimeType] ?? fallback : fallback;
+}
+function runFfmpegMux(videoPath, audioPath, outPath) {
+  return new Promise((resolve) => {
+    const child = spawn("ffmpeg", ["-y", "-i", videoPath, "-i", audioPath, "-c", "copy", "-shortest", outPath], {
+      stdio: ["ignore", "ignore", "pipe"]
+    });
+    let stderr = "";
+    child.stderr.on("data", (chunk) => {
+      stderr += String(chunk);
+    });
+    child.on("error", (err) => resolve({ ok: false, error: err.message }));
+    child.on("close", (code) => resolve({ ok: code === 0, error: code === 0 ? null : stderr.trim() || `ffmpeg exited ${code}` }));
+  });
+}
+function trackFilename(track, index, shortcode) {
+  const label = shortcode ?? "instagram";
+  const type = track.streamType === "audio" ? "audio" : track.streamType === "video" ? "video" : "track";
+  const bitrate = track.bitrate ? `-${track.bitrate}` : "";
+  return `${label}-${type}-${index}${bitrate}.mp4`;
+}
+instagramApp.post("/profile-content", createApiKeyAuth(), async (c) => {
+  const raw = await c.req.json().catch(() => ({}));
+  const parsed = InstagramProfileContentBodySchema.safeParse(raw);
+  if (!parsed.success) return c.json(invalidRequest2(parsed.error.issues[0]?.message ?? "Invalid request"), 400);
+  const body = parsed.data;
+  let target;
+  try {
+    target = normalizeInstagramProfileInput(body.url ?? body.handle ?? "");
+  } catch (err) {
+    return c.json(invalidRequest2(err instanceof Error ? err.message : String(err)), 400);
+  }
+  const user = c.get("user");
+  const gate = await acquireConcurrencyGate(user, "instagram_profile_content", {
+    reuseLockId: c.req.header("x-mcp-scraper-concurrency-lock"),
+    metadata: { handle: target.handle }
+  });
+  if (!gate.ok) return c.json(concurrencyLimitExceededResponse(gate), 429, { "Retry-After": String(gate.retryAfterSeconds) });
+  const driver = new BrowserDriver();
+  let debited = false;
+  try {
+    const { ok, balance_mc } = await debitMc(user.id, MC_COSTS.instagram_profile, LedgerOperation.INSTAGRAM_PROFILE, target.profileUrl);
+    if (!ok) return c.json(insufficientBalanceResponse(balance_mc, MC_COSTS.instagram_profile), 402);
+    debited = true;
+    const launch = await resolveInstagramLaunch(body);
+    await driver.launch(launch.config);
+    await driver.navigateTo(target.profileUrl);
+    const page = driver.getPage();
+    const result = await collectInstagramProfileContentFromPage(page, {
+      ...target,
+      maxItems: body.maxItems,
+      maxScrolls: body.maxScrolls,
+      scrollDelayMs: body.scrollDelayMs,
+      stableScrollLimit: body.stableScrollLimit
+    });
+    const response = { ...result, browser: launch.browser };
+    await logRequestEvent({ userId: user.id, source: "instagram_profile_content", status: "done", query: target.profileUrl, resultCount: result.items.length, result: response });
+    return c.json(response);
+  } catch (err) {
+    const msg = err instanceof Error ? err.message : String(err);
+    if (debited) await creditMc(user.id, MC_COSTS.instagram_profile, LedgerOperation.INSTAGRAM_PROFILE_REFUND, "failed call");
+    await logRequestEvent({ userId: user.id, source: "instagram_profile_content", status: "failed", query: target.profileUrl, error: msg });
+    if (msg.toLowerCase().includes("blocked") || msg.toLowerCase().includes("captcha")) return c.json({ error: msg }, 503);
+    return c.json({ error: msg }, 500);
+  } finally {
+    await driver.close();
+    await releaseConcurrencyGate(gate.lockId);
+  }
+});
+instagramApp.post("/media-download", createApiKeyAuth(), async (c) => {
+  const raw = await c.req.json().catch(() => ({}));
+  const parsed = InstagramMediaDownloadBodySchema.safeParse(raw);
+  if (!parsed.success) return c.json(invalidRequest2(parsed.error.issues[0]?.message ?? "Invalid request"), 400);
+  const body = parsed.data;
+  const urlCheck = await validatePublicHttpUrl(body.url, { field: "url", requireHttps: false });
+  if (urlCheck.error) return c.json(invalidRequest2(urlCheck.error), 400);
+  const sourceUrl = urlCheck.parsed;
+  if (!isAllowedInstagramPageUrl(sourceUrl)) return c.json(invalidRequest2("url must be an Instagram post, reel, or tv URL"), 400);
+  const user = c.get("user");
+  const gate = await acquireConcurrencyGate(user, "instagram_media_download", {
+    reuseLockId: c.req.header("x-mcp-scraper-concurrency-lock"),
+    metadata: { url: sourceUrl.href }
+  });
+  if (!gate.ok) return c.json(concurrencyLimitExceededResponse(gate), 429, { "Retry-After": String(gate.retryAfterSeconds) });
+  const driver = new BrowserDriver();
+  let mediaDebited = false;
+  let transcriptDebited = false;
+  try {
+    const { ok, balance_mc } = await debitMc(user.id, MC_COSTS.instagram_media, LedgerOperation.INSTAGRAM_MEDIA, sourceUrl.href);
+    if (!ok) return c.json(insufficientBalanceResponse(balance_mc, MC_COSTS.instagram_media), 402);
+    mediaDebited = true;
+    const launch = await resolveInstagramLaunch(body);
+    await driver.launch(launch.config);
+    const page = driver.getPage();
+    const capturedMediaUrls = [];
+    page.on("response", (response) => {
+      const url = normalizeInstagramMediaUrl(response.url());
+      if (!url) return;
+      const headers = response.headers();
+      const contentType = headers["content-type"] ?? "";
+      if (contentType.includes("video/mp4") || url.includes(".mp4")) capturedMediaUrls.push(url);
+    });
+    await driver.navigateTo(sourceUrl.href);
+    const extraction = await extractInstagramMediaFromPage(page, sourceUrl.href, capturedMediaUrls);
+    const mediaTypes = new Set(body.mediaTypes);
+    const downloads = [];
+    const warnings = [];
+    let outputDir = null;
+    if (body.downloadMedia) {
+      outputDir = mediaOutputDir(extraction.shortcode, sourceUrl.href);
+      const textPath = join4(outputDir, `${extraction.shortcode ?? "instagram"}-text.txt`);
+      writeFileSync(textPath, [
+        `URL: ${extraction.pageUrl}`,
+        extraction.caption ? `Caption: ${extraction.caption}` : "",
+        "",
+        extraction.bodyText
+      ].filter(Boolean).join("\n"), "utf8");
+      downloads.push({ kind: "text", url: null, savedPath: textPath, sizeBytes: statSync(textPath).size, mimeType: "text/plain", error: null });
+      if (mediaTypes.has("image") && extraction.imageUrl) {
+        const imagePathBase = join4(outputDir, `${extraction.shortcode ?? "instagram"}-image`);
+        try {
+          const downloaded = await downloadToFile(extraction.imageUrl, imagePathBase, extraction.pageUrl);
+          const ext = extFromMime(downloaded.mimeType, "jpg");
+          const finalPath = downloaded.savedPath.endsWith(`.${ext}`) ? downloaded.savedPath : `${downloaded.savedPath}.${ext}`;
+          if (finalPath !== downloaded.savedPath) {
+            const { renameSync } = await import("fs");
+            renameSync(downloaded.savedPath, finalPath);
+          }
+          downloads.push({ kind: "image", url: extraction.imageUrl, savedPath: finalPath, sizeBytes: statSync(finalPath).size, mimeType: downloaded.mimeType, error: null });
+        } catch (err) {
+          downloads.push({ kind: "image", url: extraction.imageUrl, savedPath: null, sizeBytes: null, mimeType: null, error: err instanceof Error ? err.message : String(err) });
+        }
+      }
+      const tracksToDownload = body.downloadAllTracks ? extraction.tracks : [extraction.selectedVideoTrack, extraction.selectedAudioTrack].filter((track) => Boolean(track));
+      const savedByUrl = /* @__PURE__ */ new Map();
+      for (const [index, track] of tracksToDownload.entries()) {
+        if (track.streamType === "video" && !mediaTypes.has("video")) continue;
+        if (track.streamType === "audio" && !mediaTypes.has("audio")) continue;
+        const kind = track.streamType === "audio" ? "audio" : "video";
+        const target = join4(outputDir, trackFilename(track, index, extraction.shortcode));
+        try {
+          const downloaded = await downloadToFile(track.url, target, extraction.pageUrl);
+          downloads.push({ kind, url: track.url, savedPath: downloaded.savedPath, sizeBytes: downloaded.sizeBytes, mimeType: downloaded.mimeType, error: null });
+          savedByUrl.set(track.url, downloaded.savedPath);
+        } catch (err) {
+          downloads.push({ kind, url: track.url, savedPath: null, sizeBytes: null, mimeType: null, error: err instanceof Error ? err.message : String(err) });
+        }
+      }
+      if (body.mux && mediaTypes.has("video") && mediaTypes.has("audio") && extraction.selectedVideoTrack && extraction.selectedAudioTrack && savedByUrl.has(extraction.selectedVideoTrack.url) && savedByUrl.has(extraction.selectedAudioTrack.url)) {
+        const outPath = join4(outputDir, `${extraction.shortcode ?? "instagram"}-muxed.mp4`);
+        const muxed = await runFfmpegMux(savedByUrl.get(extraction.selectedVideoTrack.url), savedByUrl.get(extraction.selectedAudioTrack.url), outPath);
+        if (muxed.ok) {
+          downloads.push({ kind: "muxed_video", url: null, savedPath: outPath, sizeBytes: statSync(outPath).size, mimeType: "video/mp4", error: null });
+        } else {
+          warnings.push(`Mux skipped/failed: ${muxed.error}`);
+        }
+      }
+    }
+    let transcript = null;
+    if (body.includeTranscript) {
+      const audioUrl = extraction.selectedAudioTrack?.url ?? extraction.selectedVideoTrack?.url;
+      if (!audioUrl) {
+        warnings.push("Transcript requested, but no audio/video track was available.");
+      } else {
+        const tx = await debitMc(user.id, MC_COSTS.instagram_transcribe, LedgerOperation.INSTAGRAM_TRANSCRIBE, sourceUrl.href);
+        if (!tx.ok) return c.json(insufficientBalanceResponse(tx.balance_mc, MC_COSTS.instagram_transcribe), 402);
+        transcriptDebited = true;
+        transcript = await transcribeMediaUrl(audioUrl, "# Instagram Media Transcript");
+      }
+    }
+    const result = {
+      ...extraction,
+      browser: launch.browser,
+      outputDir,
+      downloads,
+      warnings,
+      transcript
+    };
+    await logRequestEvent({ userId: user.id, source: "instagram_media_download", status: "done", query: sourceUrl.href, resultCount: downloads.length, result });
+    return c.json(result);
+  } catch (err) {
+    const msg = err instanceof Error ? err.message : String(err);
+    if (transcriptDebited) await creditMc(user.id, MC_COSTS.instagram_transcribe, LedgerOperation.INSTAGRAM_TRANSCRIBE_REFUND, "failed call");
+    if (mediaDebited) await creditMc(user.id, MC_COSTS.instagram_media, LedgerOperation.INSTAGRAM_MEDIA_REFUND, "failed call");
+    await logRequestEvent({ userId: user.id, source: "instagram_media_download", status: "failed", query: sourceUrl.href, error: msg });
+    if (msg.toLowerCase().includes("blocked") || msg.toLowerCase().includes("captcha")) return c.json({ error: msg }, 503);
+    return c.json({ error: msg }, 500);
+  } finally {
+    await driver.close();
+    await releaseConcurrencyGate(gate.lockId);
+  }
+});
+
+// src/api/maps-routes.ts
+import { Hono as Hono6 } from "hono";
 
 // src/extractor/MapsNavigator.ts
 var MapsNavigator = class {
@@ -9939,7 +10679,7 @@ var MapsReviewCollector = class {
 };
 
 // src/extractor/MapsExtractor.ts
-import { z as z14 } from "zod";
+import { z as z15 } from "zod";
 var MapsExtractor = class {
   constructor(driver) {
     this.driver = driver;
@@ -10125,7 +10865,7 @@ var MapsExtractor = class {
       });
       return rows;
     }, { hoursTable: MapsSelectors.hoursTable, hoursTableAlt: MapsSelectors.hoursTableAlt });
-    const result = z14.array(RawMapsHoursRowSchema).safeParse(raw);
+    const result = z15.array(RawMapsHoursRowSchema).safeParse(raw);
     if (!result.success) {
       console.warn("[MapsExtractor] hours parse failed", result.error.flatten());
       return [];
@@ -10189,7 +10929,7 @@ var MapsExtractor = class {
       });
       return results;
     });
-    const result = z14.array(RawMapsAboutAttributeSchema).safeParse(raw);
+    const result = z15.array(RawMapsAboutAttributeSchema).safeParse(raw);
     if (!result.success) {
       console.warn("[MapsExtractor] about parse failed", result.error.flatten());
       return [];
@@ -10562,7 +11302,7 @@ function mapsErrorResponse(c, err, errorCode) {
     attempts: rotationError?.attempts ?? void 0
   }, retryable ? 503 : 500);
 }
-var mapsApp = new Hono5();
+var mapsApp = new Hono6();
 mapsApp.post("/search", createApiKeyAuth(), async (c) => {
   const user = c.get("user");
   const body = await c.req.json().catch(() => ({}));
@@ -10700,12 +11440,12 @@ mapsApp.post("/place", createApiKeyAuth(), async (c) => {
 });
 
 // src/api/directory-routes.ts
-import { Hono as Hono6 } from "hono";
+import { Hono as Hono7 } from "hono";
 
 // src/directory/directory-workflow.ts
 import { mkdir as mkdir2, writeFile } from "fs/promises";
-import { join as join4 } from "path";
-import { z as z15 } from "zod";
+import { join as join5 } from "path";
+import { z as z16 } from "zod";
 
 // src/directory/location-db.ts
 import { access, readFile } from "fs/promises";
@@ -10866,24 +11606,24 @@ async function resolveDirectoryMarkets(options) {
 }
 
 // src/directory/directory-workflow.ts
-var DirectoryWorkflowOptionsSchema = z15.object({
-  query: z15.string().min(1),
-  state: z15.string().min(2).default("TN"),
-  minPopulation: z15.number().int().min(0).default(1e5),
-  populationYear: z15.union(POPULATION_YEARS.map((year) => z15.literal(year))).default(2025),
-  maxCities: z15.number().int().min(1).max(100).default(25),
-  maxResultsPerCity: z15.number().int().min(1).max(50).default(50),
-  concurrency: z15.number().int().min(1).max(5).default(5),
-  includeZipGroups: z15.boolean().default(true),
-  usZipsCsvPath: z15.string().optional(),
-  saveCsv: z15.boolean().default(true),
-  gl: z15.string().length(2).default("us"),
-  hl: z15.string().length(2).default("en"),
-  proxyMode: z15.enum(["location", "configured", "none"]).default(DEFAULT_MAPS_PROXY_MODE),
-  proxyZip: z15.string().regex(/^\d{5}$/).optional(),
-  debug: z15.boolean().default(false),
-  headless: z15.boolean().default(true),
-  kernelApiKey: z15.string().optional()
+var DirectoryWorkflowOptionsSchema = z16.object({
+  query: z16.string().min(1),
+  state: z16.string().min(2).default("TN"),
+  minPopulation: z16.number().int().min(0).default(1e5),
+  populationYear: z16.union(POPULATION_YEARS.map((year) => z16.literal(year))).default(2025),
+  maxCities: z16.number().int().min(1).max(100).default(25),
+  maxResultsPerCity: z16.number().int().min(1).max(50).default(50),
+  concurrency: z16.number().int().min(1).max(5).default(5),
+  includeZipGroups: z16.boolean().default(true),
+  usZipsCsvPath: z16.string().optional(),
+  saveCsv: z16.boolean().default(true),
+  gl: z16.string().length(2).default("us"),
+  hl: z16.string().length(2).default("en"),
+  proxyMode: z16.enum(["location", "configured", "none"]).default(DEFAULT_MAPS_PROXY_MODE),
+  proxyZip: z16.string().regex(/^\d{5}$/).optional(),
+  debug: z16.boolean().default(false),
+  headless: z16.boolean().default(true),
+  kernelApiKey: z16.string().optional()
 });
 function errorMessage(err) {
   return err instanceof Error ? err.message : String(err);
@@ -11040,11 +11780,11 @@ function csvRowsFor(result) {
   return rows;
 }
 async function saveDirectoryCsv(result) {
-  const outDir = join4(outputBaseDir(), "directory-workflows");
+  const outDir = join5(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 = join4(outDir, `${stamp}-${slug}-directory-workflow.csv`);
+  const path5 = join5(outDir, `${stamp}-${slug}-directory-workflow.csv`);
   const headers = [
     "source_query",
     "source_location",
@@ -11104,7 +11844,7 @@ async function runDirectoryWorkflowFromPlan(options, plan) {
 }
 
 // src/api/directory-routes.ts
-var directoryApp = new Hono6();
+var directoryApp = new Hono7();
 directoryApp.post("/run", createApiKeyAuth(), async (c) => {
   const user = c.get("user");
   const body = await c.req.json().catch(() => ({}));
@@ -11177,35 +11917,35 @@ directoryApp.post("/run", createApiKeyAuth(), async (c) => {
 // src/api/workflow-routes.ts
 import { createHmac } from "crypto";
 import { readFile as readFile2 } from "fs/promises";
-import { Hono as Hono7 } from "hono";
-import { z as z16 } from "zod";
-var workflowApp = new Hono7();
-var WorkflowInputSchema = z16.record(z16.unknown()).default({});
-var WorkflowIdSchema = z16.string().min(1);
-var CadenceSchema = z16.enum(["daily", "weekly", "monthly"]);
-var ScheduleStatusSchema = z16.enum(["active", "paused"]);
-var RunBodySchema = z16.object({
+import { Hono as Hono8 } from "hono";
+import { z as z17 } from "zod";
+var workflowApp = new Hono8();
+var WorkflowInputSchema = z17.record(z17.unknown()).default({});
+var WorkflowIdSchema = z17.string().min(1);
+var CadenceSchema = z17.enum(["daily", "weekly", "monthly"]);
+var ScheduleStatusSchema = z17.enum(["active", "paused"]);
+var RunBodySchema = z17.object({
   workflowId: WorkflowIdSchema,
   input: WorkflowInputSchema,
-  webhookUrl: z16.string().url().optional()
+  webhookUrl: z17.string().url().optional()
 });
-var ScheduleCreateSchema = z16.object({
+var ScheduleCreateSchema = z17.object({
   workflowId: WorkflowIdSchema,
-  name: z16.string().min(1).max(120).optional(),
+  name: z17.string().min(1).max(120).optional(),
   input: WorkflowInputSchema,
   cadence: CadenceSchema.default("weekly"),
-  timezone: z16.string().min(1).max(64).default("UTC"),
-  webhookUrl: z16.string().url().optional(),
-  nextRunAt: z16.string().datetime().optional()
+  timezone: z17.string().min(1).max(64).default("UTC"),
+  webhookUrl: z17.string().url().optional(),
+  nextRunAt: z17.string().datetime().optional()
 });
-var SchedulePatchSchema = z16.object({
-  name: z16.string().min(1).max(120).optional(),
+var SchedulePatchSchema = z17.object({
+  name: z17.string().min(1).max(120).optional(),
   status: ScheduleStatusSchema.optional(),
   input: WorkflowInputSchema.optional(),
   cadence: CadenceSchema.optional(),
-  timezone: z16.string().min(1).max(64).optional(),
-  webhookUrl: z16.string().url().nullable().optional(),
-  nextRunAt: z16.string().datetime().nullable().optional()
+  timezone: z17.string().min(1).max(64).optional(),
+  webhookUrl: z17.string().url().nullable().optional(),
+  nextRunAt: z17.string().datetime().nullable().optional()
 });
 function hostedWorkflowOutputDir() {
   return workflowOutputBaseDir(process.env.MCP_SCRAPER_WORKFLOW_OUTPUT_DIR?.trim() || "/tmp/mcp-scraper-workflows");
@@ -11709,7 +12449,7 @@ workflowApp.post("/cron/dispatch", async (c) => {
 });
 
 // src/api/serp-intelligence-routes.ts
-import { Hono as Hono8 } from "hono";
+import { Hono as Hono9 } from "hono";
 
 // src/serp-intelligence/page-snapshot-extractor.ts
 import { createHash } from "crypto";
@@ -12021,7 +12761,7 @@ async function capturePageSnapshots(targets, options = {}) {
 }
 
 // src/serp-intelligence/schemas.ts
-import { z as z17 } from "zod";
+import { z as z18 } from "zod";
 var SerpIntelligenceDeviceValues = ["desktop", "mobile"];
 var SerpIntelligenceProxyModeValues = ["location", "configured", "none"];
 var SerpIntelligenceAttemptOutcomeValues = [
@@ -12083,171 +12823,171 @@ function isPublicHttpUrl(value) {
     return false;
   }
 }
-var SerpIntelligencePublicHttpUrlSchema = z17.string().url().refine(isPublicHttpUrl, "url must be a public HTTP or HTTPS URL");
-var SerpIntelligenceCaptureBodySchema = z17.object({
-  query: z17.string().trim().min(1, "query is required"),
-  location: z17.string().trim().min(1).optional(),
-  gl: z17.string().trim().length(2).default("us"),
-  hl: z17.string().trim().length(2).default("en"),
-  device: z17.enum(SerpIntelligenceDeviceValues).default("desktop"),
-  proxyMode: z17.enum(SerpIntelligenceProxyModeValues).default(DEFAULT_PROXY_MODE),
-  proxyZip: z17.string().regex(/^\d{5}$/).optional(),
-  pages: z17.number().int().min(1).max(2).default(1),
-  debug: z17.boolean().default(false),
-  includePageSnapshots: z17.boolean().default(false),
-  pageSnapshotLimit: z17.number().int().min(0).max(10).default(0)
+var SerpIntelligencePublicHttpUrlSchema = z18.string().url().refine(isPublicHttpUrl, "url must be a public HTTP or HTTPS URL");
+var SerpIntelligenceCaptureBodySchema = z18.object({
+  query: z18.string().trim().min(1, "query is required"),
+  location: z18.string().trim().min(1).optional(),
+  gl: z18.string().trim().length(2).default("us"),
+  hl: z18.string().trim().length(2).default("en"),
+  device: z18.enum(SerpIntelligenceDeviceValues).default("desktop"),
+  proxyMode: z18.enum(SerpIntelligenceProxyModeValues).default(DEFAULT_PROXY_MODE),
+  proxyZip: z18.string().regex(/^\d{5}$/).optional(),
+  pages: z18.number().int().min(1).max(2).default(1),
+  debug: z18.boolean().default(false),
+  includePageSnapshots: z18.boolean().default(false),
+  pageSnapshotLimit: z18.number().int().min(0).max(10).default(0)
 }).strict();
-var SerpIntelligencePageSnapshotRequestSchema = z17.object({
+var SerpIntelligencePageSnapshotRequestSchema = z18.object({
   url: SerpIntelligencePublicHttpUrlSchema,
-  sourceKind: z17.enum(SerpPageSnapshotSourceKindValues).default("configured_target"),
-  sourcePosition: z17.number().int().min(1).optional()
+  sourceKind: z18.enum(SerpPageSnapshotSourceKindValues).default("configured_target"),
+  sourcePosition: z18.number().int().min(1).optional()
 }).strict();
-var SerpIntelligencePageSnapshotsBodySchema = z17.object({
-  urls: z17.array(SerpIntelligencePublicHttpUrlSchema).min(1).max(25),
-  targets: z17.array(SerpIntelligencePageSnapshotRequestSchema).min(1).max(25).optional(),
-  maxConcurrency: z17.number().int().min(1).max(5).default(2),
-  timeoutMs: z17.number().int().min(1e3).max(6e4).default(15e3),
-  debug: z17.boolean().default(false)
+var SerpIntelligencePageSnapshotsBodySchema = z18.object({
+  urls: z18.array(SerpIntelligencePublicHttpUrlSchema).min(1).max(25),
+  targets: z18.array(SerpIntelligencePageSnapshotRequestSchema).min(1).max(25).optional(),
+  maxConcurrency: z18.number().int().min(1).max(5).default(2),
+  timeoutMs: z18.number().int().min(1e3).max(6e4).default(15e3),
+  debug: z18.boolean().default(false)
 }).strict();
-var SerpIntelligenceAICitationSchema = z17.object({
-  text: z17.string(),
-  href: z17.string()
+var SerpIntelligenceAICitationSchema = z18.object({
+  text: z18.string(),
+  href: z18.string()
 }).strict();
-var SerpIntelligenceOrganicResultSchema = z17.object({
-  position: z17.number().int().min(1),
-  title: z17.string(),
-  url: z17.string(),
-  domain: z17.string(),
-  cite: z17.string().nullable(),
-  snippet: z17.string().nullable(),
-  isRedditStyle: z17.boolean(),
-  inlineRating: z17.object({
-    value: z17.string(),
-    count: z17.string()
+var SerpIntelligenceOrganicResultSchema = z18.object({
+  position: z18.number().int().min(1),
+  title: z18.string(),
+  url: z18.string(),
+  domain: z18.string(),
+  cite: z18.string().nullable(),
+  snippet: z18.string().nullable(),
+  isRedditStyle: z18.boolean(),
+  inlineRating: z18.object({
+    value: z18.string(),
+    count: z18.string()
   }).strict().nullable()
 }).strict();
-var SerpIntelligenceLocationEvidenceSchema = z17.object({
-  status: z17.enum(SerpIntelligenceLocalizationStatusValues),
-  expected: z17.object({
-    city: z17.string(),
-    regionCode: z17.string().nullable(),
-    canonicalLocation: z17.string()
+var SerpIntelligenceLocationEvidenceSchema = z18.object({
+  status: z18.enum(SerpIntelligenceLocalizationStatusValues),
+  expected: z18.object({
+    city: z18.string(),
+    regionCode: z18.string().nullable(),
+    canonicalLocation: z18.string()
   }).strict().nullable(),
-  candidates: z17.array(z17.object({
-    city: z17.string(),
-    regionCode: z17.string(),
-    count: z17.number().int().min(0),
-    examples: z17.array(z17.string())
+  candidates: z18.array(z18.object({
+    city: z18.string(),
+    regionCode: z18.string(),
+    count: z18.number().int().min(0),
+    examples: z18.array(z18.string())
   }).strict())
 }).strict();
-var SerpIntelligenceHarvestResultSchema = z17.object({
-  seed: z17.string(),
-  location: z17.string().nullable(),
-  extractedAt: z17.string(),
-  totalQuestions: z17.number().int().min(0),
-  surface: z17.enum(["web", "aim", "unknown"]),
-  aiOverview: z17.object({
-    detected: z17.boolean(),
-    text: z17.string().nullable(),
-    citations: z17.array(SerpIntelligenceAICitationSchema),
-    expanded: z17.boolean().optional(),
-    fullyExpanded: z17.boolean().optional(),
-    sections: z17.array(z17.string()).optional()
+var SerpIntelligenceHarvestResultSchema = z18.object({
+  seed: z18.string(),
+  location: z18.string().nullable(),
+  extractedAt: z18.string(),
+  totalQuestions: z18.number().int().min(0),
+  surface: z18.enum(["web", "aim", "unknown"]),
+  aiOverview: z18.object({
+    detected: z18.boolean(),
+    text: z18.string().nullable(),
+    citations: z18.array(SerpIntelligenceAICitationSchema),
+    expanded: z18.boolean().optional(),
+    fullyExpanded: z18.boolean().optional(),
+    sections: z18.array(z18.string()).optional()
   }).strict(),
-  aiMode: z17.object({
-    detected: z17.boolean(),
-    text: z17.string().nullable(),
-    citations: z17.array(SerpIntelligenceAICitationSchema)
+  aiMode: z18.object({
+    detected: z18.boolean(),
+    text: z18.string().nullable(),
+    citations: z18.array(SerpIntelligenceAICitationSchema)
   }).strict(),
-  tree: z17.array(z17.unknown()),
-  flat: z17.array(z17.unknown()),
-  videos: z17.array(z17.unknown()),
-  forums: z17.array(z17.unknown()),
-  organicResults: z17.array(SerpIntelligenceOrganicResultSchema),
-  localPack: z17.array(z17.unknown()),
-  entityIds: z17.object({
-    entities: z17.array(z17.object({
-      name: z17.string(),
-      kgId: z17.string().nullable(),
-      cid: z17.string().nullable(),
-      gcid: z17.string().nullable()
+  tree: z18.array(z18.unknown()),
+  flat: z18.array(z18.unknown()),
+  videos: z18.array(z18.unknown()),
+  forums: z18.array(z18.unknown()),
+  organicResults: z18.array(SerpIntelligenceOrganicResultSchema),
+  localPack: z18.array(z18.unknown()),
+  entityIds: z18.object({
+    entities: z18.array(z18.object({
+      name: z18.string(),
+      kgId: z18.string().nullable(),
+      cid: z18.string().nullable(),
+      gcid: z18.string().nullable()
     }).strict()),
-    kgIds: z17.array(z17.string()),
-    cids: z17.array(z17.string()),
-    gcids: z17.array(z17.string())
+    kgIds: z18.array(z18.string()),
+    cids: z18.array(z18.string()),
+    gcids: z18.array(z18.string())
   }).strict(),
-  stats: z17.object({
-    seed: z17.string(),
-    totalQuestions: z17.number().int().min(0),
-    maxDepthReached: z17.number().int().min(0),
-    durationMs: z17.number().min(0),
-    errorCount: z17.number().int().min(0)
+  stats: z18.object({
+    seed: z18.string(),
+    totalQuestions: z18.number().int().min(0),
+    maxDepthReached: z18.number().int().min(0),
+    durationMs: z18.number().min(0),
+    errorCount: z18.number().int().min(0)
   }).strict(),
-  diagnostics: z17.object({
-    completionStatus: z17.enum(["paa_found", "no_paa", "serp_only"]),
-    problem: z17.null(),
-    warnings: z17.array(z17.unknown()).optional(),
-    debug: z17.object({
+  diagnostics: z18.object({
+    completionStatus: z18.enum(["paa_found", "no_paa", "serp_only"]),
+    problem: z18.null(),
+    warnings: z18.array(z18.unknown()).optional(),
+    debug: z18.object({
       locationEvidence: SerpIntelligenceLocationEvidenceSchema.optional()
     }).passthrough().optional()
   }).passthrough(),
-  whatPeopleSaying: z17.array(z17.unknown())
+  whatPeopleSaying: z18.array(z18.unknown())
 }).strict();
-var SerpIntelligenceCaptureAttemptSchema = z17.object({
-  attemptNumber: z17.number().int().min(1),
-  outcome: z17.enum(SerpIntelligenceAttemptOutcomeValues),
-  startedAt: z17.string().optional(),
-  completedAt: z17.string().optional(),
-  durationMs: z17.number().min(0).optional(),
-  problemCode: z17.string().optional(),
-  message: z17.string().optional(),
-  kernelSessionId: z17.string().nullable().optional(),
-  cleanupSucceeded: z17.boolean().nullable().optional()
+var SerpIntelligenceCaptureAttemptSchema = z18.object({
+  attemptNumber: z18.number().int().min(1),
+  outcome: z18.enum(SerpIntelligenceAttemptOutcomeValues),
+  startedAt: z18.string().optional(),
+  completedAt: z18.string().optional(),
+  durationMs: z18.number().min(0).optional(),
+  problemCode: z18.string().optional(),
+  message: z18.string().optional(),
+  kernelSessionId: z18.string().nullable().optional(),
+  cleanupSucceeded: z18.boolean().nullable().optional()
 }).strict();
-var SerpPageSnapshotCaptureSchema = z17.object({
+var SerpPageSnapshotCaptureSchema = z18.object({
   url: SerpIntelligencePublicHttpUrlSchema,
   requestedUrl: SerpIntelligencePublicHttpUrlSchema,
   finalUrl: SerpIntelligencePublicHttpUrlSchema.nullable(),
-  sourceKind: z17.enum(SerpPageSnapshotSourceKindValues),
-  sourcePosition: z17.number().int().min(1).nullable(),
-  status: z17.enum(SerpPageFetchStatusValues),
-  fetchedVia: z17.enum(SerpPageFetchedViaValues).nullable(),
-  httpStatus: z17.number().int().min(100).max(599).nullable(),
-  contentType: z17.string().nullable(),
-  title: z17.string().nullable(),
+  sourceKind: z18.enum(SerpPageSnapshotSourceKindValues),
+  sourcePosition: z18.number().int().min(1).nullable(),
+  status: z18.enum(SerpPageFetchStatusValues),
+  fetchedVia: z18.enum(SerpPageFetchedViaValues).nullable(),
+  httpStatus: z18.number().int().min(100).max(599).nullable(),
+  contentType: z18.string().nullable(),
+  title: z18.string().nullable(),
   canonicalUrl: SerpIntelligencePublicHttpUrlSchema.nullable(),
-  metaDescription: z17.string().nullable(),
-  headings: z17.array(z17.object({
-    level: z17.number().int().min(1).max(6),
-    text: z17.string()
+  metaDescription: z18.string().nullable(),
+  headings: z18.array(z18.object({
+    level: z18.number().int().min(1).max(6),
+    text: z18.string()
   }).strict()).default([]),
-  artifact: z17.object({
-    htmlBlobUrl: z17.string().url().nullable(),
-    textBlobUrl: z17.string().url().nullable(),
-    markdownBlobUrl: z17.string().url().nullable(),
-    screenshotBlobUrl: z17.string().url().nullable(),
-    contentSha256: z17.string().nullable(),
-    capturedAt: z17.string().nullable()
+  artifact: z18.object({
+    htmlBlobUrl: z18.string().url().nullable(),
+    textBlobUrl: z18.string().url().nullable(),
+    markdownBlobUrl: z18.string().url().nullable(),
+    screenshotBlobUrl: z18.string().url().nullable(),
+    contentSha256: z18.string().nullable(),
+    capturedAt: z18.string().nullable()
   }).strict(),
-  error: z17.object({
-    code: z17.string(),
-    message: z17.string()
+  error: z18.object({
+    code: z18.string(),
+    message: z18.string()
   }).strict().nullable()
 }).strict();
-var SerpIntelligenceCaptureResponseSchema = z17.object({
+var SerpIntelligenceCaptureResponseSchema = z18.object({
   harvestResult: SerpIntelligenceHarvestResultSchema,
-  attempts: z17.array(SerpIntelligenceCaptureAttemptSchema),
+  attempts: z18.array(SerpIntelligenceCaptureAttemptSchema),
   locationEvidence: SerpIntelligenceLocationEvidenceSchema.nullable(),
-  pageSnapshotArtifacts: z17.array(SerpPageSnapshotCaptureSchema),
-  billing: z17.object({
-    creditsUsed: z17.number().min(0).optional(),
-    requestId: z17.string().optional(),
-    jobId: z17.string().optional()
+  pageSnapshotArtifacts: z18.array(SerpPageSnapshotCaptureSchema),
+  billing: z18.object({
+    creditsUsed: z18.number().min(0).optional(),
+    requestId: z18.string().optional(),
+    jobId: z18.string().optional()
   }).strict().optional()
 }).strict();
-var SerpIntelligencePageSnapshotsResponseSchema = z17.object({
-  pageSnapshotArtifacts: z17.array(SerpPageSnapshotCaptureSchema),
-  attempts: z17.array(SerpIntelligenceCaptureAttemptSchema).default([])
+var SerpIntelligencePageSnapshotsResponseSchema = z18.object({
+  pageSnapshotArtifacts: z18.array(SerpPageSnapshotCaptureSchema),
+  attempts: z18.array(SerpIntelligenceCaptureAttemptSchema).default([])
 }).strict();
 
 // src/serp-intelligence/serp-capture-service.ts
@@ -12419,7 +13159,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 Hono8();
+var serpIntelligenceApp = new Hono9();
 serpIntelligenceApp.use("*", createApiKeyAuth());
 function structuredError(input) {
   return {
@@ -12588,7 +13328,7 @@ serpIntelligenceApp.post("/page-snapshots", async (c) => {
 });
 
 // src/mcp/mcp-routes.ts
-import { Hono as Hono9 } from "hono";
+import { Hono as Hono10 } from "hono";
 import { WebStandardStreamableHTTPServerTransport } from "@modelcontextprotocol/sdk/server/webStandardStreamableHttp.js";
 configureReportSaving(false);
 function mcpAuthError() {
@@ -12618,7 +13358,7 @@ async function requireMcpCallerKey(c) {
   if (!user) return mcpAuthError();
   return callerKey;
 }
-var mcpApp = new Hono9();
+var mcpApp = new Hono10();
 function registerSerpIntelligenceCaptureTools(server, executor) {
   server.registerTool("capture_serp_snapshot", {
     title: "SERP Intelligence Snapshot",
@@ -12656,7 +13396,7 @@ mcpApp.all("/", async (c) => {
 });
 
 // src/api/browser-agent-routes.ts
-import { Hono as Hono10 } from "hono";
+import { Hono as Hono11 } from "hono";
 
 // src/api/browser-agent-db.ts
 import { randomUUID as randomUUID2 } from "crypto";
@@ -13224,7 +13964,7 @@ async function loadOpenSession(id, userId) {
   return row;
 }
 function buildBrowserAgentRoutes() {
-  const app2 = new Hono10();
+  const app2 = new Hono11();
   app2.use("*", async (c, next) => {
     await migrateBrowserAgent();
     return next();
@@ -13781,9 +14521,9 @@ if (state.key) { refreshSessions(); if (state.current) selectSession(state.curre
 
 // src/api/stripe-routes.ts
 import Stripe from "stripe";
-import { Hono as Hono11 } from "hono";
+import { Hono as Hono12 } from "hono";
 var stripe = new Stripe(process.env.STRIPE_SECRET_KEY, { apiVersion: "2026-02-25.clover" });
-var stripeApp = new Hono11();
+var stripeApp = new Hono12();
 stripeApp.post("/webhooks", async (c) => {
   const sig = c.req.header("stripe-signature");
   const body = await c.req.text();
@@ -13878,27 +14618,27 @@ import { getCookie, setCookie, deleteCookie } from "hono/cookie";
 import Stripe2 from "stripe";
 
 // src/api/billing-schemas.ts
-import { z as z18 } from "zod";
-var BillingCheckoutBodySchema = z18.object({
-  priceId: z18.string().min(1)
-});
-var FreeCreditBreakdownSchema = z18.object({
-  signup_grant_mc: z18.number().int().nonnegative(),
-  monthly_refresh_mc: z18.number().int().nonnegative(),
-  total_free_mc: z18.number().int().nonnegative(),
-  signup_grant_credits: z18.number().nonnegative(),
-  monthly_refresh_credits: z18.number().nonnegative(),
-  total_free_credits: z18.number().nonnegative()
-});
-var BillingBalanceResponseSchema = z18.object({
-  balance_mc: z18.number().int().nonnegative(),
-  balance_credits: z18.number().nonnegative(),
+import { z as z19 } from "zod";
+var BillingCheckoutBodySchema = z19.object({
+  priceId: z19.string().min(1)
+});
+var FreeCreditBreakdownSchema = z19.object({
+  signup_grant_mc: z19.number().int().nonnegative(),
+  monthly_refresh_mc: z19.number().int().nonnegative(),
+  total_free_mc: z19.number().int().nonnegative(),
+  signup_grant_credits: z19.number().nonnegative(),
+  monthly_refresh_credits: z19.number().nonnegative(),
+  total_free_credits: z19.number().nonnegative()
+});
+var BillingBalanceResponseSchema = z19.object({
+  balance_mc: z19.number().int().nonnegative(),
+  balance_credits: z19.number().nonnegative(),
   free_credits: FreeCreditBreakdownSchema,
-  ledger: z18.array(z18.any())
+  ledger: z19.array(z19.any())
 });
-var MonthlyRefreshSweepResultSchema = z18.object({
-  usersRefreshed: z18.number().int().nonnegative(),
-  totalMcGranted: z18.number().int().nonnegative()
+var MonthlyRefreshSweepResultSchema = z19.object({
+  usersRefreshed: z19.number().int().nonnegative(),
+  totalMcGranted: z19.number().int().nonnegative()
 });
 
 // src/api/credit-operations.ts
@@ -14109,7 +14849,7 @@ var sessionAuth = createMiddleware3(async (c, next) => {
   c.set("sessionUser", { ...refreshed, balance_mc: balanceMc });
   return next();
 });
-var app = new Hono12();
+var app = new Hono13();
 var STRIPE_API_VERSION = "2026-02-25.clover";
 function requireStripeSecret() {
   const secret2 = process.env.STRIPE_SECRET_KEY?.trim();
@@ -14547,7 +15287,10 @@ app.post("/extract-url", auth2, async (c) => {
     const device = screenshotDevice === "mobile" ? "mobile" : "desktop";
     const [result, pageData] = await Promise.all([
       extractKpo({ url: canonicalUrl, kernelApiKey }),
-      screenshot2 || extractBranding ? capturePageData(canonicalUrl, { kernelApiKey, device, screenshot: !!screenshot2, branding: !!extractBranding }).catch(() => null) : null
+      screenshot2 || extractBranding ? capturePageData(canonicalUrl, { kernelApiKey, device, screenshot: !!screenshot2, branding: !!extractBranding }).catch((err) => {
+        console.error("[extract-url] capturePageData failed:", err instanceof Error ? err.message : err);
+        return null;
+      }) : null
     ]);
     const screenshotBuf = pageData?.screenshot ?? null;
     const brandingData = pageData?.branding ?? null;
@@ -14555,7 +15298,7 @@ app.post("/extract-url", auth2, async (c) => {
     if (screenshotBuf) {
       screenshotMeta = { base64: screenshotBuf.toString("base64"), sizeBytes: screenshotBuf.length, device };
     }
-    const mediaMeta = downloadMedia ? await harvestPageMedia(result.bodyHtml, canonicalUrl, { types: mediaTypes ?? ["image", "video", "audio"] }) : null;
+    const mediaMeta = downloadMedia ? await harvestPageMedia(result.bodyHtml, canonicalUrl, { types: mediaTypes ?? ["image", "video", "audio"], outputDir: null }) : null;
     await logRequestEvent({ userId: user.id, source: "extract_url", status: "done", query: canonicalUrl, resultCount: result.headings.length, result });
     return c.json({ ...result, screenshot: screenshotMeta, branding: brandingData, media: mediaMeta });
   } catch (err) {
@@ -14849,7 +15592,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-SLQ375UG.js");
+  const { drainQueue } = await import("./worker-56IXWOQU.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] = await Promise.all([
@@ -14863,6 +15606,7 @@ app.route("/api/internal/site-architecture-auditor", siteAuditApp);
 app.route("/youtube", youtubeApp);
 app.route("/screenshot", screenshotApp);
 app.route("/facebook", facebookAdApp);
+app.route("/instagram", instagramApp);
 app.route("/maps", mapsApp);
 app.route("/directory", directoryApp);
 app.route("/workflows", workflowApp);
@@ -14978,4 +15722,4 @@ app.get("/blog/:slug/", (c) => {
 export {
   app
 };
-//# sourceMappingURL=server-MOP7NIUK.js.map
+//# sourceMappingURL=server-N5LM3PEO.js.map