mcp-scraper 0.2.0 → 0.2.1

package/dist/{server-ASCMKUQ5.js → server-CJMX2QUM.js}

@@ -5,9 +5,10 @@ import {
   buildPaaExtractorMcpServer,
   configureReportSaving,
   harvestTimeoutBudget,
-  liveWebToolAnnotations
-} from "./chunk-BMVQB3WN.js";
-import "./chunk-2BS7BUEE.js";
+  liveWebToolAnnotations,
+  outputBaseDir
+} from "./chunk-OR7DLLH2.js";
+import "./chunk-XR65SANX.js";
 import {
   BALANCE_PACK_LABELS,
   BALANCE_PRICE_IDS,
@@ -25,7 +26,7 @@ import {
   harvestProblemResponse,
   insufficientBalanceResponse,
   serializeHarvestProblem
-} from "./chunk-GXBT5CDU.js";
+} from "./chunk-IQOCZGJJ.js";
 import {
   BrowserDriver,
   MapsPlaceOptionsSchema,
@@ -38,14 +39,15 @@ import {
   browserServiceApiKey,
   browserServiceProxyId,
   buildYouTubeChannelVideosUrl,
+  deleteKernelProxyId,
   harvest,
   resolveKernelProxyId
-} from "./chunk-TM22BLWP.js";
+} from "./chunk-MY3S7EX7.js";
 import {
   CaptchaError,
   RECAPTCHA_INSTRUCTIONS,
   sanitizeVendorName
-} from "./chunk-ZMOWIBMK.js";
+} from "./chunk-M2S27J6Z.js";
 import {
   SiteAuditJobRowSchema,
   cancelJob,
@@ -4846,7 +4848,7 @@ async function extractSite(opts) {
 }
 
 // src/api/server.ts
-import { Hono as Hono10 } from "hono";
+import { Hono as Hono11 } from "hono";
 import { serve as serveInngest } from "inngest/hono";
 
 // src/inngest/client.ts
@@ -9744,8 +9746,11 @@ var MapsSearchExtractor = class {
       headless: options.headless,
       kernelApiKey: options.kernelApiKey,
       kernelProxyId: options.kernelProxyId,
+      kernelProxyResolution: options.kernelProxyResolution,
+      proxyMode: options.proxyMode,
       viewport: { width: 1280, height: 900 },
-      locale: `${options.hl}-${options.gl.toUpperCase()}`
+      locale: `${options.hl}-${options.gl.toUpperCase()}`,
+      debug: options.debug
     };
     try {
       await this.driver.launch(config);
@@ -9836,6 +9841,9 @@ var MapsSearchExtractor = class {
         const value = parts.find((part) => pattern.test(part));
         return value ?? null;
       }
+      function normalizedSet(values) {
+        return new Set(values.filter(Boolean).map((value) => value.toLowerCase()));
+      }
       const out = [];
       const seen = /* @__PURE__ */ new Set();
       const anchors = Array.from(document.querySelectorAll('a[href*="/maps/place/"]'));
@@ -9851,11 +9859,17 @@ var MapsSearchExtractor = class {
         const name = aria ?? heading ?? parts[0] ?? stableUrl;
         const links = Array.from(card?.querySelectorAll("a[href]") ?? []);
         const websiteUrl = links.find((link) => link.href.startsWith("http") && !link.href.includes("google."))?.href ?? null;
-        const directionsUrl = links.find((link) => /google\.[^/]+\/maps\/dir|\/dir\//i.test(link.href))?.href ?? null;
         const rating = firstMatching(parts, /^\d(?:\.\d)?$/);
-        const reviewCountRaw = firstMatching(parts, /^\(?[\d,]+\)?$/);
-        const category = parts.find((part) => !/^\d(?:\.\d)?$|^\(?[\d,]+\)?$|open|closed|directions|website/i.test(part)) ?? null;
+        const reviewCountRaw = firstMatching(parts, /^\(?[\d,]+\)?(?:\s+reviews?)?$/i);
+        const phone = firstMatching(parts, /(?:\+?1[\s.-]?)?\(?\d{3}\)?[\s.-]\d{3}[\s.-]\d{4}/);
+        const hoursStatus = parts.find((part) => /^(open|closed|closes|opens)\b|^·\s*(opens|closes)\b/i.test(part)) ?? null;
         const address = parts.find((part) => /\b[A-Z]{2}\s+\d{5}\b|\b(?:St|Street|Ave|Avenue|Rd|Road|Blvd|Drive|Dr)\b/i.test(part)) ?? null;
+        const directionsUrl = links.find((link) => /google\.[^/]+\/maps\/dir|\/dir\//i.test(link.href))?.href ?? `https://www.google.com/maps/dir/?api=1&destination=${encodeURIComponent([name, address].filter(Boolean).join(", ") || name)}`;
+        const excluded = normalizedSet([name, rating, reviewCountRaw, phone, hoursStatus, address, "Website", "Directions"]);
+        const category = parts.find((part) => {
+          const normalized = part.toLowerCase();
+          return !excluded.has(normalized) && !/^\d(?:\.\d)?$|^\(?[\d,]+\)?(?:\s+reviews?)?$/i.test(part) && !/(?:\+?1[\s.-]?)?\(?\d{3}\)?[\s.-]\d{3}[\s.-]\d{4}/.test(part) && !/\b[A-Z]{2}\s+\d{5}\b|\b(?:St|Street|Ave|Avenue|Rd|Road|Blvd|Drive|Dr)\b/i.test(part) && !/^(open|closed|closes|opens)\b|^·\s*(opens|closes)\b|directions|website|book online|sponsored|visit site|financing/i.test(part);
+        }) ?? null;
         const { cid, cidDecimal } = cidFromUrl(placeUrl);
         out.push({
           position: out.length + 1,
@@ -9867,6 +9881,8 @@ var MapsSearchExtractor = class {
           reviewCount: reviewCountRaw ? reviewCountRaw.replace(/[()]/g, "") : null,
           category,
           address,
+          phone,
+          hoursStatus,
           websiteUrl,
           directionsUrl,
           metadata: parts.slice(0, 20)
@@ -9886,12 +9902,22 @@ function mapsErrorResponse(c, msg, errorCode) {
     retryable: blocked
   }, blocked ? 503 : 500);
 }
+async function cleanupDisposableProxy(kernelApiKey, proxyId) {
+  if (!kernelApiKey || !proxyId) return;
+  await deleteKernelProxyId(kernelApiKey, proxyId).catch((err) => {
+    console.warn(JSON.stringify({
+      event: "maps_search_proxy_delete_failed",
+      proxy_id_suffix: proxyId.slice(-6),
+      message: err instanceof Error ? err.message : String(err)
+    }));
+  });
+}
 var mapsApp = new Hono5();
 mapsApp.post("/search", createApiKeyAuth(), async (c) => {
   const user = c.get("user");
   const body = await c.req.json().catch(() => ({}));
   const parsed = MapsSearchOptionsSchema.safeParse({
-    kernelApiKey: process.env.KERNEL_API_KEY,
+    kernelApiKey: browserServiceApiKey(),
     ...body
   });
   if (!parsed.success) {
@@ -9906,8 +9932,23 @@ mapsApp.post("/search", createApiKeyAuth(), async (c) => {
   if (!ok) return c.json(insufficientBalanceResponse(balance_mc, MC_COSTS.maps_search), 402);
   const driver = new BrowserDriver();
   const extractor = new MapsSearchExtractor(driver);
+  let disposableProxyId;
   try {
-    const result = await extractor.extract(parsed.data);
+    const resolution = await resolveKernelProxyId({
+      kernelApiKey: parsed.data.kernelApiKey,
+      proxyMode: parsed.data.proxyMode,
+      configuredKernelProxyId: browserServiceProxyId(),
+      location: parsed.data.location,
+      proxyZip: parsed.data.proxyZip,
+      gl: parsed.data.gl,
+      fresh: parsed.data.proxyMode === "location"
+    });
+    disposableProxyId = resolution.disposableProxyId;
+    const result = await extractor.extract({
+      ...parsed.data,
+      kernelProxyId: parsed.data.proxyMode === "none" ? void 0 : resolution.kernelProxyId,
+      kernelProxyResolution: resolution.resolution
+    });
     await logRequestEvent({
       userId: user.id,
       source: "maps_search",
@@ -9931,6 +9972,7 @@ mapsApp.post("/search", createApiKeyAuth(), async (c) => {
     });
     return mapsErrorResponse(c, msg, "maps_search_failed");
   } finally {
+    await cleanupDisposableProxy(parsed.data.kernelApiKey, disposableProxyId);
     await driver.close();
   }
 });
@@ -9938,7 +9980,7 @@ mapsApp.post("/place", createApiKeyAuth(), async (c) => {
   const user = c.get("user");
   const body = await c.req.json().catch(() => ({}));
   const parsed = MapsPlaceOptionsSchema.safeParse({
-    kernelApiKey: process.env.KERNEL_API_KEY,
+    kernelApiKey: browserServiceApiKey(),
     ...body
   });
   if (!parsed.success) {
@@ -10006,9 +10048,593 @@ mapsApp.post("/place", createApiKeyAuth(), async (c) => {
   }
 });
 
-// src/api/serp-intelligence-routes.ts
+// src/api/directory-routes.ts
 import { Hono as Hono6 } 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";
+
+// src/directory/csv.ts
+function parseCsv(text) {
+  const rows = [];
+  let row = [];
+  let field = "";
+  let quoted = false;
+  for (let i = 0; i < text.length; i += 1) {
+    const ch = text[i];
+    const next = text[i + 1];
+    if (quoted) {
+      if (ch === '"' && next === '"') {
+        field += '"';
+        i += 1;
+      } else if (ch === '"') {
+        quoted = false;
+      } else {
+        field += ch;
+      }
+      continue;
+    }
+    if (ch === '"') {
+      quoted = true;
+    } else if (ch === ",") {
+      row.push(field);
+      field = "";
+    } else if (ch === "\n") {
+      row.push(field);
+      rows.push(row);
+      row = [];
+      field = "";
+    } else if (ch !== "\r") {
+      field += ch;
+    }
+  }
+  if (field.length > 0 || row.length > 0) {
+    row.push(field);
+    rows.push(row);
+  }
+  return rows;
+}
+function csvRecords(text) {
+  const rows = parseCsv(text).filter((row) => row.some((cell) => cell.trim() !== ""));
+  const header = rows[0]?.map((cell) => cell.trim()) ?? [];
+  return rows.slice(1).map((row) => {
+    const record = {};
+    for (let i = 0; i < header.length; i += 1) {
+      record[header[i]] = row[i] ?? "";
+    }
+    return record;
+  });
+}
+function csvCell(value) {
+  if (value === null || value === void 0) return "";
+  const text = String(value);
+  return /[",\n\r]/.test(text) ? `"${text.replace(/"/g, '""')}"` : text;
+}
+function rowsToCsv(headers, rows) {
+  return [
+    headers.join(","),
+    ...rows.map((row) => headers.map((header) => csvCell(row[header])).join(","))
+  ].join("\n") + "\n";
+}
+
+// src/directory/location-db.ts
+import { access, readFile } from "fs/promises";
+var POPULATION_YEARS = [2020, 2021, 2022, 2023, 2024, 2025];
+var STATE_META = {
+  AL: { abbr: "AL", fips: "01", name: "Alabama" },
+  AK: { abbr: "AK", fips: "02", name: "Alaska" },
+  AZ: { abbr: "AZ", fips: "04", name: "Arizona" },
+  AR: { abbr: "AR", fips: "05", name: "Arkansas" },
+  CA: { abbr: "CA", fips: "06", name: "California" },
+  CO: { abbr: "CO", fips: "08", name: "Colorado" },
+  CT: { abbr: "CT", fips: "09", name: "Connecticut" },
+  DE: { abbr: "DE", fips: "10", name: "Delaware" },
+  DC: { abbr: "DC", fips: "11", name: "District of Columbia" },
+  FL: { abbr: "FL", fips: "12", name: "Florida" },
+  GA: { abbr: "GA", fips: "13", name: "Georgia" },
+  HI: { abbr: "HI", fips: "15", name: "Hawaii" },
+  ID: { abbr: "ID", fips: "16", name: "Idaho" },
+  IL: { abbr: "IL", fips: "17", name: "Illinois" },
+  IN: { abbr: "IN", fips: "18", name: "Indiana" },
+  IA: { abbr: "IA", fips: "19", name: "Iowa" },
+  KS: { abbr: "KS", fips: "20", name: "Kansas" },
+  KY: { abbr: "KY", fips: "21", name: "Kentucky" },
+  LA: { abbr: "LA", fips: "22", name: "Louisiana" },
+  ME: { abbr: "ME", fips: "23", name: "Maine" },
+  MD: { abbr: "MD", fips: "24", name: "Maryland" },
+  MA: { abbr: "MA", fips: "25", name: "Massachusetts" },
+  MI: { abbr: "MI", fips: "26", name: "Michigan" },
+  MN: { abbr: "MN", fips: "27", name: "Minnesota" },
+  MS: { abbr: "MS", fips: "28", name: "Mississippi" },
+  MO: { abbr: "MO", fips: "29", name: "Missouri" },
+  MT: { abbr: "MT", fips: "30", name: "Montana" },
+  NE: { abbr: "NE", fips: "31", name: "Nebraska" },
+  NV: { abbr: "NV", fips: "32", name: "Nevada" },
+  NH: { abbr: "NH", fips: "33", name: "New Hampshire" },
+  NJ: { abbr: "NJ", fips: "34", name: "New Jersey" },
+  NM: { abbr: "NM", fips: "35", name: "New Mexico" },
+  NY: { abbr: "NY", fips: "36", name: "New York" },
+  NC: { abbr: "NC", fips: "37", name: "North Carolina" },
+  ND: { abbr: "ND", fips: "38", name: "North Dakota" },
+  OH: { abbr: "OH", fips: "39", name: "Ohio" },
+  OK: { abbr: "OK", fips: "40", name: "Oklahoma" },
+  OR: { abbr: "OR", fips: "41", name: "Oregon" },
+  PA: { abbr: "PA", fips: "42", name: "Pennsylvania" },
+  RI: { abbr: "RI", fips: "44", name: "Rhode Island" },
+  SC: { abbr: "SC", fips: "45", name: "South Carolina" },
+  SD: { abbr: "SD", fips: "46", name: "South Dakota" },
+  TN: { abbr: "TN", fips: "47", name: "Tennessee" },
+  TX: { abbr: "TX", fips: "48", name: "Texas" },
+  UT: { abbr: "UT", fips: "49", name: "Utah" },
+  VT: { abbr: "VT", fips: "50", name: "Vermont" },
+  VA: { abbr: "VA", fips: "51", name: "Virginia" },
+  WA: { abbr: "WA", fips: "53", name: "Washington" },
+  WV: { abbr: "WV", fips: "54", name: "West Virginia" },
+  WI: { abbr: "WI", fips: "55", name: "Wisconsin" },
+  WY: { abbr: "WY", fips: "56", name: "Wyoming" }
+};
+var STATE_BY_NAME = new Map(Object.values(STATE_META).map((s) => [s.name.toLowerCase(), s]));
+function normalizeState(input) {
+  const raw = input.trim();
+  const byAbbr = STATE_META[raw.toUpperCase()];
+  if (byAbbr) return byAbbr;
+  const byName = STATE_BY_NAME.get(raw.toLowerCase());
+  if (byName) return byName;
+  throw new Error(`Unsupported state "${input}". Use a US state abbreviation such as TN.`);
+}
+function censusStateUrl(fips) {
+  return `https://www2.census.gov/programs-surveys/popest/datasets/2020-2025/cities/totals/sub-est2025_${fips}.csv`;
+}
+function normalizeCityKey(value) {
+  return value.toLowerCase().replace(/[^a-z0-9]+/g, " ").trim();
+}
+function displayCityFromCensus(name) {
+  if (/^Nashville-Davidson metropolitan government/i.test(name)) return "Nashville";
+  return name.replace(/\s+(city|town|village|municipality|borough)$/i, "").trim();
+}
+function numberOrNull(value) {
+  if (value === void 0 || value.trim() === "") return null;
+  const n = Number(value);
+  return Number.isFinite(n) ? n : null;
+}
+function localLocationFileAllowed() {
+  if (process.env.MCP_SCRAPER_ALLOW_LOCAL_LOCATION_FILES === "true") return true;
+  if (process.env.VERCEL === "1" || process.env.NODE_ENV === "production") return false;
+  return true;
+}
+async function existingPath(value) {
+  const trimmed = value?.trim();
+  if (!trimmed) return null;
+  await access(trimmed);
+  return trimmed;
+}
+async function resolveUsZipsPath(requestedPath) {
+  const envPath = process.env.MCP_SCRAPER_USZIPS_CSV_PATH;
+  if (requestedPath && !localLocationFileAllowed()) {
+    throw new Error("usZipsCsvPath is only accepted in local/test mode. Set MCP_SCRAPER_USZIPS_CSV_PATH on the server for deployed use.");
+  }
+  const source = requestedPath ?? envPath;
+  if (!source) return null;
+  return existingPath(source);
+}
+async function loadZipGroups(stateAbbr, requestedPath, warnings) {
+  if (!requestedPath && !process.env.MCP_SCRAPER_USZIPS_CSV_PATH) {
+    return { path: null, groups: /* @__PURE__ */ new Map() };
+  }
+  const path5 = await resolveUsZipsPath(requestedPath);
+  if (!path5) return { path: null, groups: /* @__PURE__ */ new Map() };
+  const records = csvRecords(await readFile(path5, "utf8"));
+  const groups = /* @__PURE__ */ new Map();
+  for (const record of records) {
+    const state = (record.state_abbr ?? record.state ?? "").trim().toUpperCase();
+    const zip = (record.zipcode ?? record.zip ?? record.zip_code ?? "").trim();
+    const city = (record.city ?? "").trim();
+    const county = (record.county ?? "").trim();
+    if (state !== stateAbbr || !zip || !city) continue;
+    const key = normalizeCityKey(city);
+    if (!groups.has(key)) groups.set(key, { zips: /* @__PURE__ */ new Set(), counties: /* @__PURE__ */ new Set() });
+    const group = groups.get(key);
+    group?.zips.add(zip);
+    if (county) group?.counties.add(county);
+  }
+  if (!groups.size) warnings.push(`No ${stateAbbr} ZIP groups found in ${path5}`);
+  return { path: path5, groups };
+}
+async function resolveDirectoryMarkets(options) {
+  const state = normalizeState(options.state);
+  const sourceUrl = censusStateUrl(state.fips);
+  const warnings = [];
+  const response = await fetch(sourceUrl);
+  if (!response.ok) throw new Error(`Census location dataset request failed: ${response.status} ${response.statusText}`);
+  const records = csvRecords(await response.text());
+  const populationField = `POPESTIMATE${options.populationYear}`;
+  const zipData = options.includeZipGroups ? await loadZipGroups(state.abbr, options.usZipsCsvPath, warnings) : { path: null, groups: /* @__PURE__ */ new Map() };
+  const markets = records.filter((record) => record.SUMLEV === "162").map((record) => {
+    const population = numberOrNull(record[populationField]);
+    if (population === null || population < options.minPopulation) return null;
+    const censusName = record.NAME?.trim() ?? "";
+    if (!censusName) return null;
+    const city = displayCityFromCensus(censusName);
+    const zipGroup = zipData.groups.get(normalizeCityKey(city));
+    return {
+      city,
+      state: state.abbr,
+      location: `${city}, ${state.abbr}`,
+      cityKey: `${city}|${state.abbr}`,
+      censusName,
+      population,
+      populationYear: options.populationYear,
+      estimatesBase2020: numberOrNull(record.ESTIMATESBASE2020),
+      zips: zipGroup ? [...zipGroup.zips].sort() : [],
+      counties: zipGroup ? [...zipGroup.counties].sort() : []
+    };
+  }).filter((market) => market !== null).sort((a, b) => b.population - a.population || a.city.localeCompare(b.city)).slice(0, options.maxCities);
+  if (options.includeZipGroups && zipData.path && markets.some((m) => m.zips.length === 0)) {
+    warnings.push("Some Census places did not match the configured US ZIPS city names.");
+  }
+  return { markets, censusSourceUrl: sourceUrl, usZipsSourcePath: zipData.path, warnings };
+}
+
+// src/directory/directory-workflow.ts
+var DIRECTORY_MAX_ATTEMPTS = 3;
+var DIRECTORY_LOCATION_PROXY_MAX_ATTEMPTS = 5;
+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("location"),
+  proxyZip: z15.string().regex(/^\d{5}$/).optional(),
+  debug: z15.boolean().default(false),
+  headless: z15.boolean().default(true),
+  kernelApiKey: z15.string().optional()
+});
+async function cleanupDisposableProxy2(kernelApiKey, proxyId) {
+  if (!kernelApiKey || !proxyId) return;
+  try {
+    await deleteKernelProxyId(kernelApiKey, proxyId);
+  } catch (err) {
+    console.warn(JSON.stringify({
+      event: "directory_workflow_proxy_delete_failed",
+      proxy_id_suffix: proxyId.slice(-6),
+      message: err instanceof Error ? err.message : String(err)
+    }));
+  }
+}
+function maxAttemptsForProxyMode(proxyMode) {
+  return proxyMode === "location" ? DIRECTORY_LOCATION_PROXY_MAX_ATTEMPTS : DIRECTORY_MAX_ATTEMPTS;
+}
+function errorMessage(err) {
+  return err instanceof Error ? err.message : String(err);
+}
+function looksLikeProxyTunnelFailure(message) {
+  return /ERR_TUNNEL_CONNECTION_FAILED|ERR_PROXY_CONNECTION_FAILED|ERR_SOCKS_CONNECTION_FAILED|tunnel connection failed|proxy connection failed|transport error: proxy/i.test(message);
+}
+function looksLikeProxyUnavailable(message) {
+  return /proxy unavailable|proxy_unavailable|connection_test_failed|did not return a proxy id|configured fallback/i.test(message);
+}
+function retryableCitySearchError(err, proxyMode) {
+  if (err instanceof CaptchaError) return true;
+  const message = errorMessage(err);
+  if (/timeout|timed out|Timeout \d+ms exceeded|deadline/i.test(message)) return true;
+  return proxyMode === "location" && (looksLikeProxyTunnelFailure(message) || looksLikeProxyUnavailable(message));
+}
+function proxyZipForAttempt(options, market, attemptIndex) {
+  if (options.proxyZip) return options.proxyZip;
+  if (!market.zips.length) return void 0;
+  return market.zips[attemptIndex % market.zips.length];
+}
+async function mapLimit(items, limit, fn) {
+  const out = new Array(items.length);
+  let next = 0;
+  async function worker() {
+    while (next < items.length) {
+      const index = next;
+      next += 1;
+      out[index] = await fn(items[index]);
+    }
+  }
+  await Promise.all(Array.from({ length: Math.min(limit, items.length) }, () => worker()));
+  return out;
+}
+async function searchCityAttempt(options, market, attemptIndex) {
+  const driver = new BrowserDriver();
+  const extractor = new MapsSearchExtractor(driver);
+  const start = Date.now();
+  let disposableProxyId;
+  try {
+    const proxyZip = proxyZipForAttempt(options, market, attemptIndex);
+    const resolution = await resolveKernelProxyId({
+      kernelApiKey: options.kernelApiKey,
+      proxyMode: options.proxyMode,
+      configuredKernelProxyId: browserServiceProxyId(),
+      location: market.location,
+      proxyZip,
+      gl: options.gl,
+      attemptIndex,
+      fresh: options.proxyMode === "location"
+    });
+    disposableProxyId = resolution.disposableProxyId;
+    const result = await extractor.extract({
+      query: options.query,
+      location: market.location,
+      gl: options.gl,
+      hl: options.hl,
+      maxResults: options.maxResultsPerCity,
+      headless: options.headless,
+      kernelApiKey: options.kernelApiKey,
+      kernelProxyId: options.proxyMode === "none" ? void 0 : resolution.kernelProxyId,
+      kernelProxyResolution: resolution.resolution,
+      proxyMode: options.proxyMode,
+      proxyZip,
+      debug: options.debug
+    });
+    return {
+      city: market.city,
+      state: market.state,
+      location: market.location,
+      cityKey: market.cityKey,
+      censusName: market.censusName,
+      population: market.population,
+      populationYear: market.populationYear,
+      zips: market.zips,
+      counties: market.counties,
+      status: result.results.length ? "ok" : "empty",
+      error: null,
+      resultCount: result.resultCount,
+      durationMs: result.durationMs,
+      results: result.results
+    };
+  } finally {
+    await cleanupDisposableProxy2(options.kernelApiKey, disposableProxyId);
+  }
+}
+async function searchCity(options, market) {
+  const started = Date.now();
+  const maxAttempts = maxAttemptsForProxyMode(options.proxyMode);
+  let lastError = null;
+  for (let attemptIndex = 0; attemptIndex < maxAttempts; attemptIndex += 1) {
+    try {
+      return await searchCityAttempt(options, market, attemptIndex);
+    } catch (err) {
+      lastError = err;
+      const willRetry = attemptIndex < maxAttempts - 1 && retryableCitySearchError(err, options.proxyMode);
+      console.warn(JSON.stringify({
+        event: "directory_workflow_city_attempt_failed",
+        city: market.city,
+        state: market.state,
+        attempt_number: attemptIndex + 1,
+        max_attempts: maxAttempts,
+        will_retry: willRetry,
+        message: errorMessage(err)
+      }));
+      if (!willRetry) break;
+    }
+  }
+  return {
+    city: market.city,
+    state: market.state,
+    location: market.location,
+    cityKey: market.cityKey,
+    censusName: market.censusName,
+    population: market.population,
+    populationYear: market.populationYear,
+    zips: market.zips,
+    counties: market.counties,
+    status: "failed",
+    error: lastError ? errorMessage(lastError) : "City Maps search failed",
+    resultCount: 0,
+    durationMs: Date.now() - started,
+    results: []
+  };
+}
+function csvRowsFor(result) {
+  const rows = [];
+  for (const city of result.cities) {
+    if (!city.results.length) {
+      rows.push({
+        source_query: result.query,
+        source_location: city.location,
+        city: city.city,
+        state: city.state,
+        city_key: city.cityKey,
+        census_name: city.censusName,
+        population: city.population,
+        population_year: city.populationYear,
+        zip_count: city.zips.length,
+        zips: city.zips.join(" "),
+        counties: city.counties.join(" | "),
+        result_position: null,
+        business_name: null,
+        review_stars: null,
+        category: null,
+        address: null,
+        phone: null,
+        hours_status: null,
+        website_url: null,
+        directions_url: null,
+        place_url: null,
+        cid: null,
+        cid_decimal: null,
+        metadata: null,
+        result_status: city.status,
+        error: city.error,
+        extracted_at: result.extractedAt,
+        duration_ms: city.durationMs
+      });
+      continue;
+    }
+    for (const business of city.results) {
+      rows.push({
+        source_query: result.query,
+        source_location: city.location,
+        city: city.city,
+        state: city.state,
+        city_key: city.cityKey,
+        census_name: city.censusName,
+        population: city.population,
+        population_year: city.populationYear,
+        zip_count: city.zips.length,
+        zips: city.zips.join(" "),
+        counties: city.counties.join(" | "),
+        result_position: business.position,
+        business_name: business.name,
+        review_stars: business.rating,
+        category: business.category,
+        address: business.address,
+        phone: business.phone,
+        hours_status: business.hoursStatus,
+        website_url: business.websiteUrl,
+        directions_url: business.directionsUrl,
+        place_url: business.placeUrl,
+        cid: business.cid,
+        cid_decimal: business.cidDecimal,
+        metadata: business.metadata.join(" | "),
+        result_status: city.status,
+        error: city.error,
+        extracted_at: result.extractedAt,
+        duration_ms: city.durationMs
+      });
+    }
+  }
+  return rows;
+}
+async function saveDirectoryCsv(result) {
+  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 = join4(outDir, `${stamp}-${slug}-directory-workflow.csv`);
+  const headers = [
+    "source_query",
+    "source_location",
+    "city",
+    "state",
+    "city_key",
+    "census_name",
+    "population",
+    "population_year",
+    "zip_count",
+    "zips",
+    "counties",
+    "result_position",
+    "business_name",
+    "review_stars",
+    "category",
+    "address",
+    "phone",
+    "hours_status",
+    "website_url",
+    "directions_url",
+    "place_url",
+    "cid",
+    "cid_decimal",
+    "metadata",
+    "result_status",
+    "error",
+    "extracted_at",
+    "duration_ms"
+  ];
+  await writeFile(path5, rowsToCsv(headers, csvRowsFor(result)), "utf8");
+  return path5;
+}
+async function runDirectoryWorkflowFromPlan(options, plan) {
+  const started = Date.now();
+  const extractedAt = (/* @__PURE__ */ new Date()).toISOString();
+  const cities = await mapLimit(plan.markets, options.concurrency, (market) => searchCity(options, market));
+  const base = {
+    query: options.query,
+    state: plan.markets[0]?.state ?? options.state.toUpperCase(),
+    minPopulation: options.minPopulation,
+    populationYear: options.populationYear,
+    maxResultsPerCity: options.maxResultsPerCity,
+    concurrency: options.concurrency,
+    censusSourceUrl: plan.censusSourceUrl,
+    usZipsSourcePath: plan.usZipsSourcePath,
+    warnings: plan.warnings,
+    extractedAt,
+    selectedCityCount: plan.markets.length,
+    totalResultCount: cities.reduce((sum, city) => sum + city.resultCount, 0),
+    cities,
+    durationMs: Date.now() - started
+  };
+  const csvPath = options.saveCsv ? await saveDirectoryCsv(base) : null;
+  return { ...base, csvPath };
+}
+
+// src/api/directory-routes.ts
+var directoryApp = new Hono6();
+directoryApp.post("/run", createApiKeyAuth(), async (c) => {
+  const user = c.get("user");
+  const body = await c.req.json().catch(() => ({}));
+  const kernelApiKey = browserServiceApiKey();
+  const parsed = DirectoryWorkflowOptionsSchema.safeParse({
+    ...body,
+    kernelApiKey
+  });
+  if (!parsed.success) {
+    return c.json({ error: parsed.error.issues[0]?.message ?? "Invalid request" }, 400);
+  }
+  if (!kernelApiKey && parsed.data.proxyMode !== "none") {
+    return c.json({ error: "Browser service API key is required for directory workflow Maps searches unless proxyMode is none" }, 503);
+  }
+  const plan = await resolveDirectoryMarkets(parsed.data);
+  const requiredMc = plan.markets.length * MC_COSTS.maps_search;
+  if (requiredMc > 0) {
+    const debit = await debitMc(
+      user.id,
+      requiredMc,
+      LedgerOperation.MAPS_SEARCH,
+      `directory_workflow ${parsed.data.query} ${parsed.data.state} ${plan.markets.length} cities`
+    );
+    if (!debit.ok) return c.json(insufficientBalanceResponse(debit.balance_mc, requiredMc), 402);
+  }
+  try {
+    const result = await runDirectoryWorkflowFromPlan(parsed.data, plan);
+    const failedCities = result.cities.filter((city) => city.status === "failed").length;
+    if (failedCities > 0) {
+      await creditMc(user.id, failedCities * MC_COSTS.maps_search, LedgerOperation.REFUND, "failed directory_workflow city maps searches");
+    }
+    await logRequestEvent({
+      userId: user.id,
+      source: "directory_workflow",
+      status: failedCities === result.cities.length && result.cities.length > 0 ? "failed" : "done",
+      query: result.query,
+      location: result.state,
+      resultCount: result.totalResultCount,
+      result
+    });
+    return c.json(result);
+  } catch (err) {
+    if (requiredMc > 0) {
+      await creditMc(user.id, requiredMc, LedgerOperation.REFUND, "failed directory_workflow call");
+    }
+    const message = err instanceof Error ? err.message : String(err);
+    await logRequestEvent({
+      userId: user.id,
+      source: "directory_workflow",
+      status: "failed",
+      query: parsed.data.query,
+      location: parsed.data.state,
+      error: message
+    });
+    return c.json({ error: message, error_code: "directory_workflow_failed", retryable: true }, 500);
+  }
+});
+
+// src/api/serp-intelligence-routes.ts
+import { Hono as Hono7 } from "hono";
+
 // src/serp-intelligence/page-snapshot-extractor.ts
 import { createHash } from "crypto";
 import pLimit3 from "p-limit";
@@ -10319,7 +10945,7 @@ async function capturePageSnapshots(targets, options = {}) {
 }
 
 // src/serp-intelligence/schemas.ts
-import { z as z15 } from "zod";
+import { z as z16 } from "zod";
 var SerpIntelligenceDeviceValues = ["desktop", "mobile"];
 var SerpIntelligenceProxyModeValues = ["location", "configured", "none"];
 var SerpIntelligenceAttemptOutcomeValues = [
@@ -10331,6 +10957,8 @@ var SerpIntelligenceAttemptOutcomeValues = [
   "request_aborted",
   "timeout",
   "location_mismatch",
+  "proxy_tunnel_failed",
+  "proxy_unavailable",
   "mcp_unavailable",
   "error"
 ];
@@ -10379,171 +11007,171 @@ function isPublicHttpUrl(value) {
     return false;
   }
 }
-var SerpIntelligencePublicHttpUrlSchema = z15.string().url().refine(isPublicHttpUrl, "url must be a public HTTP or HTTPS URL");
-var SerpIntelligenceCaptureBodySchema = z15.object({
-  query: z15.string().trim().min(1, "query is required"),
-  location: z15.string().trim().min(1).optional(),
-  gl: z15.string().trim().length(2).default("us"),
-  hl: z15.string().trim().length(2).default("en"),
-  device: z15.enum(SerpIntelligenceDeviceValues).default("desktop"),
-  proxyMode: z15.enum(SerpIntelligenceProxyModeValues).default("location"),
-  proxyZip: z15.string().regex(/^\d{5}$/).optional(),
-  pages: z15.number().int().min(1).max(2).default(1),
-  debug: z15.boolean().default(false),
-  includePageSnapshots: z15.boolean().default(false),
-  pageSnapshotLimit: z15.number().int().min(0).max(10).default(0)
+var SerpIntelligencePublicHttpUrlSchema = z16.string().url().refine(isPublicHttpUrl, "url must be a public HTTP or HTTPS URL");
+var SerpIntelligenceCaptureBodySchema = z16.object({
+  query: z16.string().trim().min(1, "query is required"),
+  location: z16.string().trim().min(1).optional(),
+  gl: z16.string().trim().length(2).default("us"),
+  hl: z16.string().trim().length(2).default("en"),
+  device: z16.enum(SerpIntelligenceDeviceValues).default("desktop"),
+  proxyMode: z16.enum(SerpIntelligenceProxyModeValues).default("location"),
+  proxyZip: z16.string().regex(/^\d{5}$/).optional(),
+  pages: z16.number().int().min(1).max(2).default(1),
+  debug: z16.boolean().default(false),
+  includePageSnapshots: z16.boolean().default(false),
+  pageSnapshotLimit: z16.number().int().min(0).max(10).default(0)
 }).strict();
-var SerpIntelligencePageSnapshotRequestSchema = z15.object({
+var SerpIntelligencePageSnapshotRequestSchema = z16.object({
   url: SerpIntelligencePublicHttpUrlSchema,
-  sourceKind: z15.enum(SerpPageSnapshotSourceKindValues).default("configured_target"),
-  sourcePosition: z15.number().int().min(1).optional()
+  sourceKind: z16.enum(SerpPageSnapshotSourceKindValues).default("configured_target"),
+  sourcePosition: z16.number().int().min(1).optional()
 }).strict();
-var SerpIntelligencePageSnapshotsBodySchema = z15.object({
-  urls: z15.array(SerpIntelligencePublicHttpUrlSchema).min(1).max(25),
-  targets: z15.array(SerpIntelligencePageSnapshotRequestSchema).min(1).max(25).optional(),
-  maxConcurrency: z15.number().int().min(1).max(5).default(2),
-  timeoutMs: z15.number().int().min(1e3).max(6e4).default(15e3),
-  debug: z15.boolean().default(false)
+var SerpIntelligencePageSnapshotsBodySchema = z16.object({
+  urls: z16.array(SerpIntelligencePublicHttpUrlSchema).min(1).max(25),
+  targets: z16.array(SerpIntelligencePageSnapshotRequestSchema).min(1).max(25).optional(),
+  maxConcurrency: z16.number().int().min(1).max(5).default(2),
+  timeoutMs: z16.number().int().min(1e3).max(6e4).default(15e3),
+  debug: z16.boolean().default(false)
 }).strict();
-var SerpIntelligenceAICitationSchema = z15.object({
-  text: z15.string(),
-  href: z15.string()
+var SerpIntelligenceAICitationSchema = z16.object({
+  text: z16.string(),
+  href: z16.string()
 }).strict();
-var SerpIntelligenceOrganicResultSchema = z15.object({
-  position: z15.number().int().min(1),
-  title: z15.string(),
-  url: z15.string(),
-  domain: z15.string(),
-  cite: z15.string().nullable(),
-  snippet: z15.string().nullable(),
-  isRedditStyle: z15.boolean(),
-  inlineRating: z15.object({
-    value: z15.string(),
-    count: z15.string()
+var SerpIntelligenceOrganicResultSchema = z16.object({
+  position: z16.number().int().min(1),
+  title: z16.string(),
+  url: z16.string(),
+  domain: z16.string(),
+  cite: z16.string().nullable(),
+  snippet: z16.string().nullable(),
+  isRedditStyle: z16.boolean(),
+  inlineRating: z16.object({
+    value: z16.string(),
+    count: z16.string()
   }).strict().nullable()
 }).strict();
-var SerpIntelligenceLocationEvidenceSchema = z15.object({
-  status: z15.enum(SerpIntelligenceLocalizationStatusValues),
-  expected: z15.object({
-    city: z15.string(),
-    regionCode: z15.string().nullable(),
-    canonicalLocation: z15.string()
+var SerpIntelligenceLocationEvidenceSchema = z16.object({
+  status: z16.enum(SerpIntelligenceLocalizationStatusValues),
+  expected: z16.object({
+    city: z16.string(),
+    regionCode: z16.string().nullable(),
+    canonicalLocation: z16.string()
   }).strict().nullable(),
-  candidates: z15.array(z15.object({
-    city: z15.string(),
-    regionCode: z15.string(),
-    count: z15.number().int().min(0),
-    examples: z15.array(z15.string())
+  candidates: z16.array(z16.object({
+    city: z16.string(),
+    regionCode: z16.string(),
+    count: z16.number().int().min(0),
+    examples: z16.array(z16.string())
   }).strict())
 }).strict();
-var SerpIntelligenceHarvestResultSchema = z15.object({
-  seed: z15.string(),
-  location: z15.string().nullable(),
-  extractedAt: z15.string(),
-  totalQuestions: z15.number().int().min(0),
-  surface: z15.enum(["web", "aim", "unknown"]),
-  aiOverview: z15.object({
-    detected: z15.boolean(),
-    text: z15.string().nullable(),
-    citations: z15.array(SerpIntelligenceAICitationSchema),
-    expanded: z15.boolean().optional(),
-    fullyExpanded: z15.boolean().optional(),
-    sections: z15.array(z15.string()).optional()
+var SerpIntelligenceHarvestResultSchema = z16.object({
+  seed: z16.string(),
+  location: z16.string().nullable(),
+  extractedAt: z16.string(),
+  totalQuestions: z16.number().int().min(0),
+  surface: z16.enum(["web", "aim", "unknown"]),
+  aiOverview: z16.object({
+    detected: z16.boolean(),
+    text: z16.string().nullable(),
+    citations: z16.array(SerpIntelligenceAICitationSchema),
+    expanded: z16.boolean().optional(),
+    fullyExpanded: z16.boolean().optional(),
+    sections: z16.array(z16.string()).optional()
   }).strict(),
-  aiMode: z15.object({
-    detected: z15.boolean(),
-    text: z15.string().nullable(),
-    citations: z15.array(SerpIntelligenceAICitationSchema)
+  aiMode: z16.object({
+    detected: z16.boolean(),
+    text: z16.string().nullable(),
+    citations: z16.array(SerpIntelligenceAICitationSchema)
   }).strict(),
-  tree: z15.array(z15.unknown()),
-  flat: z15.array(z15.unknown()),
-  videos: z15.array(z15.unknown()),
-  forums: z15.array(z15.unknown()),
-  organicResults: z15.array(SerpIntelligenceOrganicResultSchema),
-  localPack: z15.array(z15.unknown()),
-  entityIds: z15.object({
-    entities: z15.array(z15.object({
-      name: z15.string(),
-      kgId: z15.string().nullable(),
-      cid: z15.string().nullable(),
-      gcid: z15.string().nullable()
+  tree: z16.array(z16.unknown()),
+  flat: z16.array(z16.unknown()),
+  videos: z16.array(z16.unknown()),
+  forums: z16.array(z16.unknown()),
+  organicResults: z16.array(SerpIntelligenceOrganicResultSchema),
+  localPack: z16.array(z16.unknown()),
+  entityIds: z16.object({
+    entities: z16.array(z16.object({
+      name: z16.string(),
+      kgId: z16.string().nullable(),
+      cid: z16.string().nullable(),
+      gcid: z16.string().nullable()
     }).strict()),
-    kgIds: z15.array(z15.string()),
-    cids: z15.array(z15.string()),
-    gcids: z15.array(z15.string())
+    kgIds: z16.array(z16.string()),
+    cids: z16.array(z16.string()),
+    gcids: z16.array(z16.string())
   }).strict(),
-  stats: z15.object({
-    seed: z15.string(),
-    totalQuestions: z15.number().int().min(0),
-    maxDepthReached: z15.number().int().min(0),
-    durationMs: z15.number().min(0),
-    errorCount: z15.number().int().min(0)
+  stats: z16.object({
+    seed: z16.string(),
+    totalQuestions: z16.number().int().min(0),
+    maxDepthReached: z16.number().int().min(0),
+    durationMs: z16.number().min(0),
+    errorCount: z16.number().int().min(0)
   }).strict(),
-  diagnostics: z15.object({
-    completionStatus: z15.enum(["paa_found", "no_paa", "serp_only"]),
-    problem: z15.null(),
-    warnings: z15.array(z15.unknown()).optional(),
-    debug: z15.object({
+  diagnostics: z16.object({
+    completionStatus: z16.enum(["paa_found", "no_paa", "serp_only"]),
+    problem: z16.null(),
+    warnings: z16.array(z16.unknown()).optional(),
+    debug: z16.object({
       locationEvidence: SerpIntelligenceLocationEvidenceSchema.optional()
     }).passthrough().optional()
   }).passthrough(),
-  whatPeopleSaying: z15.array(z15.unknown())
+  whatPeopleSaying: z16.array(z16.unknown())
 }).strict();
-var SerpIntelligenceCaptureAttemptSchema = z15.object({
-  attemptNumber: z15.number().int().min(1),
-  outcome: z15.enum(SerpIntelligenceAttemptOutcomeValues),
-  startedAt: z15.string().optional(),
-  completedAt: z15.string().optional(),
-  durationMs: z15.number().min(0).optional(),
-  problemCode: z15.string().optional(),
-  message: z15.string().optional(),
-  kernelSessionId: z15.string().nullable().optional(),
-  cleanupSucceeded: z15.boolean().nullable().optional()
+var SerpIntelligenceCaptureAttemptSchema = z16.object({
+  attemptNumber: z16.number().int().min(1),
+  outcome: z16.enum(SerpIntelligenceAttemptOutcomeValues),
+  startedAt: z16.string().optional(),
+  completedAt: z16.string().optional(),
+  durationMs: z16.number().min(0).optional(),
+  problemCode: z16.string().optional(),
+  message: z16.string().optional(),
+  kernelSessionId: z16.string().nullable().optional(),
+  cleanupSucceeded: z16.boolean().nullable().optional()
 }).strict();
-var SerpPageSnapshotCaptureSchema = z15.object({
+var SerpPageSnapshotCaptureSchema = z16.object({
   url: SerpIntelligencePublicHttpUrlSchema,
   requestedUrl: SerpIntelligencePublicHttpUrlSchema,
   finalUrl: SerpIntelligencePublicHttpUrlSchema.nullable(),
-  sourceKind: z15.enum(SerpPageSnapshotSourceKindValues),
-  sourcePosition: z15.number().int().min(1).nullable(),
-  status: z15.enum(SerpPageFetchStatusValues),
-  fetchedVia: z15.enum(SerpPageFetchedViaValues).nullable(),
-  httpStatus: z15.number().int().min(100).max(599).nullable(),
-  contentType: z15.string().nullable(),
-  title: z15.string().nullable(),
+  sourceKind: z16.enum(SerpPageSnapshotSourceKindValues),
+  sourcePosition: z16.number().int().min(1).nullable(),
+  status: z16.enum(SerpPageFetchStatusValues),
+  fetchedVia: z16.enum(SerpPageFetchedViaValues).nullable(),
+  httpStatus: z16.number().int().min(100).max(599).nullable(),
+  contentType: z16.string().nullable(),
+  title: z16.string().nullable(),
   canonicalUrl: SerpIntelligencePublicHttpUrlSchema.nullable(),
-  metaDescription: z15.string().nullable(),
-  headings: z15.array(z15.object({
-    level: z15.number().int().min(1).max(6),
-    text: z15.string()
+  metaDescription: z16.string().nullable(),
+  headings: z16.array(z16.object({
+    level: z16.number().int().min(1).max(6),
+    text: z16.string()
   }).strict()).default([]),
-  artifact: z15.object({
-    htmlBlobUrl: z15.string().url().nullable(),
-    textBlobUrl: z15.string().url().nullable(),
-    markdownBlobUrl: z15.string().url().nullable(),
-    screenshotBlobUrl: z15.string().url().nullable(),
-    contentSha256: z15.string().nullable(),
-    capturedAt: z15.string().nullable()
+  artifact: z16.object({
+    htmlBlobUrl: z16.string().url().nullable(),
+    textBlobUrl: z16.string().url().nullable(),
+    markdownBlobUrl: z16.string().url().nullable(),
+    screenshotBlobUrl: z16.string().url().nullable(),
+    contentSha256: z16.string().nullable(),
+    capturedAt: z16.string().nullable()
   }).strict(),
-  error: z15.object({
-    code: z15.string(),
-    message: z15.string()
+  error: z16.object({
+    code: z16.string(),
+    message: z16.string()
   }).strict().nullable()
 }).strict();
-var SerpIntelligenceCaptureResponseSchema = z15.object({
+var SerpIntelligenceCaptureResponseSchema = z16.object({
   harvestResult: SerpIntelligenceHarvestResultSchema,
-  attempts: z15.array(SerpIntelligenceCaptureAttemptSchema),
+  attempts: z16.array(SerpIntelligenceCaptureAttemptSchema),
   locationEvidence: SerpIntelligenceLocationEvidenceSchema.nullable(),
-  pageSnapshotArtifacts: z15.array(SerpPageSnapshotCaptureSchema),
-  billing: z15.object({
-    creditsUsed: z15.number().min(0).optional(),
-    requestId: z15.string().optional(),
-    jobId: z15.string().optional()
+  pageSnapshotArtifacts: z16.array(SerpPageSnapshotCaptureSchema),
+  billing: z16.object({
+    creditsUsed: z16.number().min(0).optional(),
+    requestId: z16.string().optional(),
+    jobId: z16.string().optional()
   }).strict().optional()
 }).strict();
-var SerpIntelligencePageSnapshotsResponseSchema = z15.object({
-  pageSnapshotArtifacts: z15.array(SerpPageSnapshotCaptureSchema),
-  attempts: z15.array(SerpIntelligenceCaptureAttemptSchema).default([])
+var SerpIntelligencePageSnapshotsResponseSchema = z16.object({
+  pageSnapshotArtifacts: z16.array(SerpPageSnapshotCaptureSchema),
+  attempts: z16.array(SerpIntelligenceCaptureAttemptSchema).default([])
 }).strict();
 
 // src/serp-intelligence/serp-capture-service.ts
@@ -10715,7 +11343,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 Hono6();
+var serpIntelligenceApp = new Hono7();
 serpIntelligenceApp.use("*", createApiKeyAuth());
 function structuredError(input) {
   return {
@@ -10890,7 +11518,7 @@ serpIntelligenceApp.post("/page-snapshots", async (c) => {
 });
 
 // src/mcp/mcp-routes.ts
-import { Hono as Hono7 } from "hono";
+import { Hono as Hono8 } from "hono";
 import { WebStandardStreamableHTTPServerTransport } from "@modelcontextprotocol/sdk/server/webStandardStreamableHttp.js";
 configureReportSaving(false);
 function mcpAuthError() {
@@ -10920,11 +11548,11 @@ async function requireMcpCallerKey(c) {
   if (!user) return mcpAuthError();
   return callerKey;
 }
-var mcpApp = new Hono7();
+var mcpApp = new Hono8();
 function registerSerpIntelligenceCaptureTools(server, executor) {
   server.registerTool("capture_serp_snapshot", {
     title: "SERP Intelligence Snapshot",
-    description: "Capture a structured SERP Intelligence Google snapshot through POST /serp-intelligence/capture, the same product capture path used by Phoenix. Split query from location, infer gl/hl, use proxyMode location for localized residential proxy evidence, configured for the static residential proxy, and none only for direct-network debugging. Set debug true when investigating location evidence, proxy behavior, CAPTCHA, or capture reliability.",
+    description: "Capture a structured SERP Intelligence Google snapshot through POST /serp-intelligence/capture, the same product capture path used by Phoenix. Split query from location, infer gl/hl, use proxyMode location for localized US residential evidence; location mode creates fresh proxy IDs across retries and rejects wrong-location evidence before returning. Use configured only for the static residential proxy, and none only for direct-network debugging. Set debug true when investigating location evidence, proxy behavior, CAPTCHA, or capture reliability.",
     inputSchema: CaptureSerpSnapshotInputSchema,
     annotations: liveWebToolAnnotations("SERP Intelligence Snapshot")
   }, async (input) => executor.captureSerpSnapshot(input));
@@ -10956,7 +11584,7 @@ mcpApp.all("/", async (c) => {
 });
 
 // src/api/browser-agent-routes.ts
-import { Hono as Hono8 } from "hono";
+import { Hono as Hono9 } from "hono";
 
 // src/api/browser-agent-db.ts
 import { randomUUID } from "crypto";
@@ -11233,6 +11861,10 @@ async function replayStop(runtimeSessionId, replayId) {
   const k = client();
   await k.browsers.replays.stop(replayId, { id: runtimeSessionId });
 }
+async function replayDownload(runtimeSessionId, replayId) {
+  const k = client();
+  return k.browsers.replays.download(replayId, { id: runtimeSessionId });
+}
 async function replayList(runtimeSessionId) {
   const k = client();
   const res = await k.browsers.replays.list(runtimeSessionId);
@@ -11261,6 +11893,7 @@ function publicSession(row) {
     session_id: row.id,
     status: row.status,
     label: row.label,
+    live_view_url: row.live_view_url,
     created_at: row.created_at,
     last_action_at: row.last_action_at,
     closed_at: row.closed_at,
@@ -11272,6 +11905,14 @@ function failure(err) {
   const msg = err instanceof Error ? err.message : String(err);
   return { error: sanitizeVendorName(msg) };
 }
+function replayDownloadUrl(sessionId, replayId) {
+  return `/agent/sessions/${encodeURIComponent(sessionId)}/replays/${encodeURIComponent(replayId)}/download`;
+}
+function replayFilename(sessionId, replayId) {
+  const safeSession = sessionId.replace(/[^a-zA-Z0-9_-]/g, "-").slice(0, 80);
+  const safeReplay = replayId.replace(/[^a-zA-Z0-9_-]/g, "-").slice(0, 120);
+  return `${safeSession}-${safeReplay}.mp4`;
+}
 async function loadOpenSession(id, userId) {
   const row = await getSessionRow(id);
   if (!row) return null;
@@ -11279,7 +11920,7 @@ async function loadOpenSession(id, userId) {
   return row;
 }
 function buildBrowserAgentRoutes() {
-  const app2 = new Hono8();
+  const app2 = new Hono9();
   app2.use("*", async (c, next) => {
     await migrateBrowserAgent();
     return next();
@@ -11495,7 +12136,11 @@ function buildBrowserAgentRoutes() {
         viewUrl: started.viewUrl,
         label: typeof body.label === "string" ? body.label : null
       });
-      return c.json({ replay_id: started.replayId });
+      return c.json({
+        replay_id: started.replayId,
+        view_url: started.viewUrl,
+        download_url: replayDownloadUrl(row.id, started.replayId)
+      });
     } catch (err) {
       return c.json(failure(err), 502);
     }
@@ -11517,7 +12162,12 @@ function buildBrowserAgentRoutes() {
         viewUrl = null;
       }
       await recordReplayStop(replayId, viewUrl);
-      return c.json({ ok: true });
+      return c.json({
+        ok: true,
+        replay_id: replayId,
+        view_url: viewUrl,
+        download_url: replayDownloadUrl(row.id, replayId)
+      });
     } catch (err) {
       return c.json(failure(err), 502);
     }
@@ -11531,12 +12181,35 @@ function buildBrowserAgentRoutes() {
       replays: rows.map((r) => ({
         replay_id: r.replay_id,
         view_url: r.view_url,
+        download_url: replayDownloadUrl(row.id, r.replay_id),
         label: r.label,
         started_at: r.started_at,
         stopped_at: r.stopped_at
       }))
     });
   });
+  app2.get("/sessions/:id/replays/:replayId/download", async (c) => {
+    const user = c.get("user");
+    const row = await loadOpenSession(c.req.param("id"), user.id);
+    if (!row) return c.json({ error: "not found" }, 404);
+    const replayId = c.req.param("replayId");
+    const rows = await listReplayRows(row.id);
+    if (!rows.some((r) => r.replay_id === replayId)) return c.json({ error: "replay not found" }, 404);
+    try {
+      const res = await replayDownload(row.runtime_session_id, replayId);
+      if (!res.ok) return c.json({ error: `replay download failed (${res.status})` }, res.status);
+      return new Response(res.body, {
+        status: 200,
+        headers: {
+          "Content-Type": res.headers.get("content-type") ?? "video/mp4",
+          "Content-Disposition": `attachment; filename="${replayFilename(row.id, replayId)}"`,
+          "Cache-Control": "private, max-age=300"
+        }
+      });
+    } catch (err) {
+      return c.json(failure(err), 502);
+    }
+  });
   return app2;
 }
 
@@ -11560,6 +12233,7 @@ function renderConsoleHtml(initialSessionId) {
   input[type=text], input[type=password], input[type=url] { background: #141925; border: 1px solid #232b3a; color: #e6eaf2; border-radius: 7px; padding: 7px 10px; }
   button { background: #2b6cff; border: 0; color: #fff; border-radius: 7px; padding: 7px 12px; cursor: pointer; font-weight: 500; }
   button.ghost { background: #1a2030; color: #cdd5e4; border: 1px solid #28303f; }
+  button.linkish { background: transparent; color: #7aa2ff; border: 0; padding: 0; font-size: 13px; font-weight: 500; }
   button:disabled { opacity: .5; cursor: default; }
   .layout { display: grid; grid-template-columns: 280px 1fr; height: calc(100vh - 53px); }
   aside { border-right: 1px solid #1c2230; overflow-y: auto; padding: 12px; }
@@ -11632,6 +12306,26 @@ async function closeCurrent() {
   await refreshSessions();
 }
 
+async function downloadReplay(replayId) {
+  if (!state.current || !replayId) return;
+  const res = await fetch('/agent/sessions/' + encodeURIComponent(state.current) + '/replays/' + encodeURIComponent(replayId) + '/download', {
+    headers: { 'x-api-key': state.key },
+  });
+  if (!res.ok) {
+    alert('Replay download failed: ' + await res.text());
+    return;
+  }
+  const blob = await res.blob();
+  const url = URL.createObjectURL(blob);
+  const a = document.createElement('a');
+  a.href = url;
+  a.download = state.current + '-' + replayId + '.mp4';
+  document.body.appendChild(a);
+  a.click();
+  a.remove();
+  URL.revokeObjectURL(url);
+}
+
 function frameSrc() {
   if (!state.liveUrl) return null;
   const sep = state.liveUrl.includes('?') ? '&' : '?';
@@ -11686,9 +12380,10 @@ function render() {
     const rep = h('<div class="replays"><h3>Replays</h3></div>');
     if (!state.replays.length) rep.appendChild(h('<div class="muted">No replays recorded.</div>'));
     for (const r of state.replays) {
-      const status = r.stopped_at ? 'ready' : 'recording\u2026';
+      const status = r.stopped_at ? 'ready' : 'recording...';
       const link = r.view_url ? '<a href="' + esc(r.view_url) + '" target="_blank" rel="noopener">view mp4</a>' : '<span class="muted">' + status + '</span>';
-      rep.appendChild(h('<div class="replay"><span class="muted">' + esc(r.started_at || '') + '</span><span class="spacer"></span>' + link + '</div>'));
+      const download = r.stopped_at ? '<button class="linkish replay-download" data-rid="' + esc(r.replay_id) + '">download mp4</button>' : '';
+      rep.appendChild(h('<div class="replay"><span class="muted">' + esc(r.started_at || '') + '</span><span class="spacer"></span>' + link + download + '</div>'));
     }
     main.appendChild(rep);
 
@@ -11702,6 +12397,9 @@ function render() {
   if (reload) reload.onclick = () => selectSession(state.current);
   const close = document.getElementById('close');
   if (close) close.onclick = closeCurrent;
+  document.querySelectorAll('.replay-download').forEach(btn => {
+    btn.onclick = () => downloadReplay(btn.getAttribute('data-rid'));
+  });
 }
 
 render();
@@ -11713,9 +12411,9 @@ if (state.key) { refreshSessions(); if (state.current) selectSession(state.curre
 
 // src/api/stripe-routes.ts
 import Stripe from "stripe";
-import { Hono as Hono9 } from "hono";
+import { Hono as Hono10 } from "hono";
 var stripe = new Stripe(process.env.STRIPE_SECRET_KEY, { apiVersion: "2026-02-25.clover" });
-var stripeApp = new Hono9();
+var stripeApp = new Hono10();
 stripeApp.post("/webhooks", async (c) => {
   const sig = c.req.header("stripe-signature");
   const body = await c.req.text();
@@ -11810,27 +12508,27 @@ import { getCookie, setCookie, deleteCookie } from "hono/cookie";
 import Stripe2 from "stripe";
 
 // src/api/billing-schemas.ts
-import { z as z16 } from "zod";
-var BillingCheckoutBodySchema = z16.object({
-  priceId: z16.string().min(1)
+import { z as z17 } from "zod";
+var BillingCheckoutBodySchema = z17.object({
+  priceId: z17.string().min(1)
 });
-var FreeCreditBreakdownSchema = z16.object({
-  signup_grant_mc: z16.number().int().nonnegative(),
-  monthly_refresh_mc: z16.number().int().nonnegative(),
-  total_free_mc: z16.number().int().nonnegative(),
-  signup_grant_credits: z16.number().nonnegative(),
-  monthly_refresh_credits: z16.number().nonnegative(),
-  total_free_credits: z16.number().nonnegative()
+var FreeCreditBreakdownSchema = z17.object({
+  signup_grant_mc: z17.number().int().nonnegative(),
+  monthly_refresh_mc: z17.number().int().nonnegative(),
+  total_free_mc: z17.number().int().nonnegative(),
+  signup_grant_credits: z17.number().nonnegative(),
+  monthly_refresh_credits: z17.number().nonnegative(),
+  total_free_credits: z17.number().nonnegative()
 });
-var BillingBalanceResponseSchema = z16.object({
-  balance_mc: z16.number().int().nonnegative(),
-  balance_credits: z16.number().nonnegative(),
+var BillingBalanceResponseSchema = z17.object({
+  balance_mc: z17.number().int().nonnegative(),
+  balance_credits: z17.number().nonnegative(),
   free_credits: FreeCreditBreakdownSchema,
-  ledger: z16.array(z16.any())
+  ledger: z17.array(z17.any())
 });
-var MonthlyRefreshSweepResultSchema = z16.object({
-  usersRefreshed: z16.number().int().nonnegative(),
-  totalMcGranted: z16.number().int().nonnegative()
+var MonthlyRefreshSweepResultSchema = z17.object({
+  usersRefreshed: z17.number().int().nonnegative(),
+  totalMcGranted: z17.number().int().nonnegative()
 });
 
 // src/api/credit-operations.ts
@@ -12041,7 +12739,7 @@ var sessionAuth = createMiddleware3(async (c, next) => {
   c.set("sessionUser", { ...refreshed, balance_mc: balanceMc });
   return next();
 });
-var app = new Hono10();
+var app = new Hono11();
 var STRIPE_API_VERSION = "2026-02-25.clover";
 function requireStripeSecret() {
   const secret2 = process.env.STRIPE_SECRET_KEY?.trim();
@@ -12687,7 +13385,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-KJ4A7WIR.js");
+  const { drainQueue } = await import("./worker-NAKGTIF5.js");
   const budget = { maxJobs: 10, deadlineMs: Date.now() + 28e4 };
   const [results, sweepResult] = await Promise.all([
     drainQueue(budget),
@@ -12701,6 +13399,7 @@ app.route("/youtube", youtubeApp);
 app.route("/screenshot", screenshotApp);
 app.route("/facebook", facebookAdApp);
 app.route("/maps", mapsApp);
+app.route("/directory", directoryApp);
 app.route("/serp-intelligence", serpIntelligenceApp);
 app.route("/mcp", mcpApp);
 app.route("/agent", buildBrowserAgentRoutes());
@@ -12812,4 +13511,4 @@ app.get("/blog/:slug/", (c) => {
 export {
   app
 };
-//# sourceMappingURL=server-ASCMKUQ5.js.map
+//# sourceMappingURL=server-CJMX2QUM.js.map