mcp-scraper 0.2.7 → 0.2.9

package/dist/{server-RIKRBDOI.js → server-BKJ7LULQ.js}

@@ -15,45 +15,14 @@ import {
   harvestProblemResponse,
   insufficientBalanceResponse,
   serializeHarvestProblem
-} from "./chunk-IQOCZGJJ.js";
-import {
-  BrowserDriver,
-  MapsPlaceOptionsSchema,
-  MapsSearchOptionsSchema,
-  MapsSelectors,
-  RawMapsAboutAttributeSchema,
-  RawMapsHoursRowSchema,
-  RawMapsOverviewSchema,
-  RawMapsReviewStatsSchema,
-  browserServiceApiKey,
-  browserServiceProxyId,
-  buildYouTubeChannelVideosUrl,
-  deleteKernelProxyId,
-  harvest,
-  resolveKernelProxyId
-} from "./chunk-MY3S7EX7.js";
-import {
-  CaptureSerpPageSnapshotsInputSchema,
-  CaptureSerpSnapshotInputSchema,
-  HttpMcpToolExecutor,
-  buildPaaExtractorMcpServer,
-  configureReportSaving,
-  harvestTimeoutBudget,
-  liveWebToolAnnotations,
-  outputBaseDir
-} from "./chunk-7SI6XIR3.js";
-import {
-  CaptchaError,
-  RECAPTCHA_INSTRUCTIONS,
-  sanitizeVendorName
-} from "./chunk-M2S27J6Z.js";
-import "./chunk-IZE5UW7Y.js";
+} from "./chunk-ROS67BNV.js";
 import {
   SiteAuditJobRowSchema,
   cancelJob,
   checkRateLimit,
   claimMonthlyFreeRefresh,
   completeJob,
+  completeWorkflowRunRecord,
   consumePasswordResetToken,
   countActiveJobsForUser,
   countActiveUsers,
@@ -61,10 +30,14 @@ import {
   createPasswordResetToken,
   createRunningJob,
   createUser,
+  createWorkflowRun,
+  createWorkflowSchedule,
   creditMc,
   deactivateUser,
   debitMc,
+  deleteWorkflowSchedule,
   failJob,
+  failWorkflowRunRecord,
   getDb,
   getJob,
   getLedger,
@@ -73,15 +46,27 @@ import {
   getUserById,
   getUserByStripeCustomerId,
   getUserStats,
+  getWorkflowArtifact,
+  getWorkflowRun,
+  getWorkflowSchedule,
   ledgerExistsForOperation,
   ledgerExistsForStripePI,
+  listDueWorkflowSchedules,
   listHarvestAttempts,
   listJobs,
   listRequestEvents,
   listUsers,
+  listWorkflowArtifacts,
+  listWorkflowRuns,
+  listWorkflowSchedules,
   logRequestEvent,
+  markWorkflowRunRunning,
+  markWorkflowScheduleRan,
+  patchWorkflowSchedule,
   reconcileBalanceMc,
   recordStripeEvent,
+  recordWorkflowWebhookDelivery,
+  replaceWorkflowArtifacts,
   revokeApiKey,
   rotateApiKey,
   setConcurrencySubId,
@@ -89,7 +74,47 @@ import {
   setPassword,
   setStripeCustomerId,
   verifyPassword
-} from "./chunk-D4CJBZBY.js";
+} from "./chunk-7GCCOT3M.js";
+import {
+  BrowserDriver,
+  MapsPlaceOptionsSchema,
+  MapsSearchOptionsSchema,
+  MapsSelectors,
+  RawMapsAboutAttributeSchema,
+  RawMapsHoursRowSchema,
+  RawMapsOverviewSchema,
+  RawMapsReviewStatsSchema,
+  browserServiceApiKey,
+  browserServiceProxyId,
+  buildYouTubeChannelVideosUrl,
+  deleteKernelProxyId,
+  harvest,
+  resolveKernelProxyId
+} from "./chunk-CQTAKXBN.js";
+import {
+  CaptureSerpPageSnapshotsInputSchema,
+  CaptureSerpSnapshotInputSchema,
+  HttpMcpToolExecutor,
+  buildPaaExtractorMcpServer,
+  configureReportSaving,
+  harvestTimeoutBudget,
+  liveWebToolAnnotations,
+  outputBaseDir
+} from "./chunk-XAY5U67D.js";
+import {
+  CaptchaError,
+  RECAPTCHA_INSTRUCTIONS,
+  sanitizeVendorName
+} from "./chunk-M2S27J6Z.js";
+import {
+  csvRecords,
+  listWorkflowDefinitions,
+  rowsToCsv,
+  runWorkflow,
+  workflowDefinition,
+  workflowOutputBaseDir
+} from "./chunk-L6IS63WS.js";
+import "./chunk-BJDCPCIE.js";
 
 // src/api/outbound-sanitize.ts
 var KEY_RENAMES = {
@@ -4848,7 +4873,7 @@ async function extractSite(opts) {
 }
 
 // src/api/server.ts
-import { Hono as Hono11 } from "hono";
+import { Hono as Hono12 } from "hono";
 import { serve as serveInngest } from "inngest/hono";
 
 // src/inngest/client.ts
@@ -9893,24 +9918,205 @@ var MapsSearchExtractor = class {
   }
 };
 
-// src/api/maps-routes.ts
-function mapsErrorResponse(c, msg, errorCode) {
-  const blocked = msg.includes("CAPTCHA") || msg.includes("blocked");
-  return c.json({
-    error: sanitizeVendorName(msg),
-    error_code: blocked ? "captcha_or_blocked" : errorCode,
-    retryable: blocked
-  }, blocked ? 503 : 500);
+// src/maps-search-rotation.ts
+var MAPS_SEARCH_MAX_ATTEMPTS = 3;
+var MAPS_SEARCH_LOCATION_PROXY_MAX_ATTEMPTS = 5;
+var MapsSearchRotationError = class extends Error {
+  constructor(message, attempts, retryable, errorCode = "maps_search_failed") {
+    super(message);
+    this.attempts = attempts;
+    this.retryable = retryable;
+    this.errorCode = errorCode;
+  }
+  attempts;
+  retryable;
+  errorCode;
+  name = "MapsSearchRotationError";
+};
+function mapsSearchMaxAttemptsForProxyMode(proxyMode) {
+  return proxyMode === "location" ? MAPS_SEARCH_LOCATION_PROXY_MAX_ATTEMPTS : MAPS_SEARCH_MAX_ATTEMPTS;
+}
+function mapsSearchErrorMessage(err) {
+  return sanitizeVendorName(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 looksLikeBrowserClosed(message) {
+  return /Target page, context or browser has been closed|browser has been closed|context has been closed|page has been closed|browser not found|CDP session closed|Connection closed|WebSocket.*closed|Protocol error.*closed|Browser closed|disconnected/i.test(message);
+}
+function mapsSearchFailureOutcome(err) {
+  if (err instanceof CaptchaError) return "captcha";
+  const message = mapsSearchErrorMessage(err);
+  if (/timeout|timed out|Timeout \d+ms exceeded|deadline/i.test(message)) return "timeout";
+  if (looksLikeProxyTunnelFailure(message)) return "proxy_tunnel_failed";
+  if (looksLikeProxyUnavailable(message)) return "proxy_unavailable";
+  if (looksLikeBrowserClosed(message)) return "browser_closed";
+  return "unknown_error";
+}
+function retryableMapsSearchError(err, proxyMode) {
+  if (err instanceof CaptchaError) return true;
+  const message = mapsSearchErrorMessage(err);
+  if (/timeout|timed out|Timeout \d+ms exceeded|deadline/i.test(message)) return true;
+  if (looksLikeBrowserClosed(message)) return true;
+  return proxyMode === "location" && (looksLikeProxyTunnelFailure(message) || looksLikeProxyUnavailable(message));
+}
+function suffix(value) {
+  return value ? value.slice(-8) : null;
+}
+function attemptFromDebug(input) {
+  const network = input.debug.networkLocation;
+  const browserSessionId = input.debug.kernel?.sessionId ?? null;
+  const target = input.resolution?.target ?? null;
+  return {
+    attemptNumber: input.attemptIndex + 1,
+    maxAttempts: input.maxAttempts,
+    status: input.status,
+    outcome: input.outcome,
+    willRetry: input.willRetry,
+    durationMs: input.durationMs,
+    resultCount: input.resultCount,
+    error: input.error,
+    proxyMode: input.proxyMode,
+    proxyResolutionSource: input.resolution?.source ?? null,
+    proxyIdSuffix: input.resolution?.proxyIdSuffix ?? null,
+    proxyTargetLevel: target?.level ?? null,
+    proxyTargetLocation: target?.canonicalLocation ?? null,
+    proxyTargetZip: target?.zip ?? null,
+    browserSessionIdSuffix: suffix(browserSessionId),
+    observedIp: network?.ip ?? null,
+    observedCity: network?.city ?? null,
+    observedRegion: network?.region ?? null
+  };
 }
-async function cleanupDisposableProxy(kernelApiKey, proxyId) {
+async function cleanupDisposableProxy(kernelApiKey, proxyId, eventName) {
   if (!kernelApiKey || !proxyId) return;
-  await deleteKernelProxyId(kernelApiKey, proxyId).catch((err) => {
+  try {
+    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)
+      event: eventName,
+      proxy_id_suffix: suffix(proxyId),
+      message: mapsSearchErrorMessage(err)
     }));
-  });
+  }
+}
+async function runMapsSearchWithRotation(options) {
+  const attempts = [];
+  const maxAttempts = mapsSearchMaxAttemptsForProxyMode(options.proxyMode);
+  const started = Date.now();
+  let lastError = null;
+  for (let attemptIndex = 0; attemptIndex < maxAttempts; attemptIndex += 1) {
+    const attemptStarted = Date.now();
+    const driver = new BrowserDriver();
+    const extractor = new MapsSearchExtractor(driver);
+    const proxyZip = options.proxyZipForAttempt?.(attemptIndex) ?? options.proxyZip;
+    let resolution = null;
+    let disposableProxyId;
+    try {
+      resolution = await resolveKernelProxyId({
+        kernelApiKey: options.kernelApiKey,
+        proxyMode: options.proxyMode,
+        configuredKernelProxyId: options.kernelProxyId ?? options.configuredKernelProxyId,
+        location: options.location,
+        proxyZip,
+        gl: options.gl,
+        attemptIndex,
+        fresh: options.proxyMode === "location"
+      });
+      disposableProxyId = resolution.disposableProxyId;
+      const result = await extractor.extract({
+        ...options,
+        proxyZip,
+        kernelProxyId: options.proxyMode === "none" ? void 0 : resolution.kernelProxyId,
+        kernelProxyResolution: resolution.resolution
+      });
+      const attempt = attemptFromDebug({
+        attemptIndex,
+        maxAttempts,
+        status: "ok",
+        outcome: "success",
+        willRetry: false,
+        durationMs: Date.now() - attemptStarted,
+        resultCount: result.resultCount,
+        error: null,
+        proxyMode: options.proxyMode,
+        resolution: resolution.resolution,
+        debug: driver.getDebugSnapshot()
+      });
+      attempts.push(attempt);
+      return {
+        ...result,
+        attempts: attempts.slice(),
+        durationMs: Date.now() - started
+      };
+    } catch (err) {
+      lastError = err;
+      const retryable = retryableMapsSearchError(err, options.proxyMode);
+      const willRetry = attemptIndex < maxAttempts - 1 && retryable;
+      const attempt = attemptFromDebug({
+        attemptIndex,
+        maxAttempts,
+        status: "failed",
+        outcome: mapsSearchFailureOutcome(err),
+        willRetry,
+        durationMs: Date.now() - attemptStarted,
+        resultCount: 0,
+        error: mapsSearchErrorMessage(err),
+        proxyMode: options.proxyMode,
+        resolution: resolution?.resolution ?? null,
+        debug: driver.getDebugSnapshot()
+      });
+      attempts.push(attempt);
+      console.warn(JSON.stringify({
+        event: options.failureEventName ?? "maps_search_attempt_failed",
+        ...options.logContext,
+        attempt_number: attempt.attemptNumber,
+        max_attempts: attempt.maxAttempts,
+        outcome: attempt.outcome,
+        will_retry: attempt.willRetry,
+        proxy_resolution_source: attempt.proxyResolutionSource,
+        proxy_id_suffix: attempt.proxyIdSuffix,
+        browser_session_id_suffix: attempt.browserSessionIdSuffix,
+        observed_city: attempt.observedCity,
+        observed_region: attempt.observedRegion,
+        message: attempt.error
+      }));
+      if (!willRetry) {
+        throw new MapsSearchRotationError(
+          mapsSearchErrorMessage(err),
+          attempts,
+          retryable,
+          err instanceof CaptchaError ? "captcha_or_blocked" : "maps_search_failed"
+        );
+      }
+    } finally {
+      await cleanupDisposableProxy(options.kernelApiKey, disposableProxyId, "maps_search_proxy_delete_failed");
+      await driver.close();
+    }
+  }
+  throw new MapsSearchRotationError(
+    lastError ? mapsSearchErrorMessage(lastError) : "Maps search failed",
+    attempts,
+    true
+  );
+}
+
+// src/api/maps-routes.ts
+function mapsErrorResponse(c, err, errorCode) {
+  const msg = err instanceof Error ? err.message : String(err);
+  const rotationError = err instanceof MapsSearchRotationError ? err : null;
+  const blocked = msg.includes("CAPTCHA") || msg.includes("blocked");
+  const retryable = rotationError?.retryable ?? blocked;
+  return c.json({
+    error: sanitizeVendorName(msg),
+    error_code: rotationError?.errorCode ?? (blocked ? "captcha_or_blocked" : errorCode),
+    retryable,
+    attempts: rotationError?.attempts ?? void 0
+  }, retryable ? 503 : 500);
 }
 var mapsApp = new Hono5();
 mapsApp.post("/search", createApiKeyAuth(), async (c) => {
@@ -9930,24 +10136,10 @@ mapsApp.post("/search", createApiKeyAuth(), async (c) => {
     [parsed.data.query, parsed.data.location].filter(Boolean).join(" ")
   );
   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 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({
+    const result = await runMapsSearchWithRotation({
       ...parsed.data,
-      kernelProxyId: parsed.data.proxyMode === "none" ? void 0 : resolution.kernelProxyId,
-      kernelProxyResolution: resolution.resolution
+      configuredKernelProxyId: browserServiceProxyId()
     });
     await logRequestEvent({
       userId: user.id,
@@ -9968,12 +10160,10 @@ mapsApp.post("/search", createApiKeyAuth(), async (c) => {
       status: "failed",
       query: [parsed.data.query, parsed.data.location].filter(Boolean).join(" "),
       location: parsed.data.location,
-      error: msg
+      error: msg,
+      result: err instanceof MapsSearchRotationError ? { attempts: err.attempts } : void 0
     });
-    return mapsErrorResponse(c, msg, "maps_search_failed");
-  } finally {
-    await cleanupDisposableProxy(parsed.data.kernelApiKey, disposableProxyId);
-    await driver.close();
+    return mapsErrorResponse(c, err, "maps_search_failed");
   }
 });
 mapsApp.post("/place", createApiKeyAuth(), async (c) => {
@@ -10056,69 +10246,6 @@ 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];
@@ -10278,8 +10405,6 @@ async function resolveDirectoryMarkets(options) {
 }
 
 // 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"),
@@ -10299,36 +10424,9 @@ var DirectoryWorkflowOptionsSchema = z15.object({
   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;
@@ -10347,25 +10445,10 @@ async function mapLimit(items, limit, fn) {
   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;
+async function searchCity(options, market) {
+  const started = Date.now();
   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({
+    const result = await runMapsSearchWithRotation({
       query: options.query,
       location: market.location,
       gl: options.gl,
@@ -10373,11 +10456,16 @@ async function searchCityAttempt(options, market, attemptIndex) {
       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
+      proxyZip: options.proxyZip,
+      debug: options.debug,
+      configuredKernelProxyId: browserServiceProxyId(),
+      proxyZipForAttempt: (attemptIndex) => proxyZipForAttempt(options, market, attemptIndex),
+      failureEventName: "directory_workflow_city_attempt_failed",
+      logContext: {
+        city: market.city,
+        state: market.state
+      }
     });
     return {
       city: market.city,
@@ -10393,50 +10481,29 @@ async function searchCityAttempt(options, market, attemptIndex) {
       error: null,
       resultCount: result.resultCount,
       durationMs: result.durationMs,
+      attempts: result.attempts ?? [],
       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;
-    }
+  } catch (err) {
+    const attempts = err instanceof MapsSearchRotationError ? err.attempts : [];
+    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: errorMessage(err),
+      resultCount: 0,
+      durationMs: Date.now() - started,
+      attempts,
+      results: []
+    };
   }
-  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 = [];
@@ -10457,6 +10524,7 @@ function csvRowsFor(result) {
         result_position: null,
         business_name: null,
         review_stars: null,
+        review_count: null,
         category: null,
         address: null,
         phone: null,
@@ -10490,6 +10558,7 @@ function csvRowsFor(result) {
         result_position: business.position,
         business_name: business.name,
         review_stars: business.rating,
+        review_count: business.reviewCount,
         category: business.category,
         address: business.address,
         phone: business.phone,
@@ -10530,6 +10599,7 @@ async function saveDirectoryCsv(result) {
     "result_position",
     "business_name",
     "review_stars",
+    "review_count",
     "category",
     "address",
     "phone",
@@ -10632,8 +10702,360 @@ directoryApp.post("/run", createApiKeyAuth(), async (c) => {
   }
 });
 
-// src/api/serp-intelligence-routes.ts
+// 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({
+  workflowId: WorkflowIdSchema,
+  input: WorkflowInputSchema,
+  webhookUrl: z16.string().url().optional()
+});
+var ScheduleCreateSchema = z16.object({
+  workflowId: WorkflowIdSchema,
+  name: z16.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()
+});
+var SchedulePatchSchema = z16.object({
+  name: z16.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()
+});
+function hostedWorkflowOutputDir() {
+  return workflowOutputBaseDir(process.env.MCP_SCRAPER_WORKFLOW_OUTPUT_DIR?.trim() || "/tmp/mcp-scraper-workflows");
+}
+function originFromUrl(url) {
+  const parsed = new URL(url);
+  return `${parsed.protocol}//${parsed.host}`;
+}
+function addCadence(fromIso, cadence) {
+  const next = new Date(fromIso);
+  if (!Number.isFinite(next.getTime())) return new Date(Date.now() + 24 * 60 * 60 * 1e3).toISOString();
+  if (cadence === "daily") next.setUTCDate(next.getUTCDate() + 1);
+  else if (cadence === "weekly") next.setUTCDate(next.getUTCDate() + 7);
+  else next.setUTCMonth(next.getUTCMonth() + 1);
+  return next.toISOString();
+}
+function defaultNextRunAt(cadence) {
+  return addCadence((/* @__PURE__ */ new Date()).toISOString(), cadence);
+}
+function validateWorkflowInput(workflowId, input) {
+  const definition = workflowDefinition(workflowId);
+  return definition.inputSchema.parse(input);
+}
+async function validateWebhookUrl(url) {
+  if (!url) return null;
+  const result = await validatePublicHttpUrl(url, { field: "webhookUrl", requireHttps: true });
+  if (result.error) throw new Error(result.error);
+  return url;
+}
+function runDownloadUrl(c, runId, artifactId) {
+  return `${originFromUrl(c.req.url)}/workflows/runs/${runId}/artifacts/${artifactId}`;
+}
+function exposeRun(c, run, artifacts = []) {
+  return {
+    ...run,
+    artifacts: artifacts.map((artifact) => ({
+      ...artifact,
+      downloadUrl: runDownloadUrl(c, run.id, artifact.id)
+    }))
+  };
+}
+async function persistRunArtifacts(runId, userId, manifest) {
+  if (!manifest) return [];
+  return replaceWorkflowArtifacts(runId, userId, manifest.artifacts);
+}
+async function readManifestFromSummary(summary) {
+  if (!summary.reportPath) return null;
+  const manifestPath = summary.reportPath.replace(/report\.html$/, "manifest.json");
+  try {
+    return JSON.parse(await readFile2(manifestPath, "utf8"));
+  } catch {
+    return null;
+  }
+}
+function webhookSignature(body, timestamp) {
+  const secret2 = process.env.MCP_SCRAPER_WEBHOOK_SECRET?.trim();
+  if (!secret2) return null;
+  return createHmac("sha256", secret2).update(`${timestamp}.${body}`).digest("hex");
+}
+async function deliverWorkflowWebhook(input) {
+  if (!input.webhookUrl) return;
+  const payload = {
+    event: input.run.status === "failed" ? "workflow.run.failed" : input.run.status === "partial" ? "workflow.run.partial" : "workflow.run.succeeded",
+    runId: input.run.id,
+    scheduleId: input.scheduleId,
+    workflowId: input.run.workflow_id,
+    status: input.run.status,
+    completedAt: input.run.completed_at ?? (/* @__PURE__ */ new Date()).toISOString(),
+    summary: {
+      title: input.summary?.title ?? input.run.workflow_id,
+      counts: input.summary?.counts ?? {},
+      warnings: input.summary?.warnings ?? [],
+      errors: input.summary?.errors ?? (input.run.error_message ? [input.run.error_message] : [])
+    },
+    artifacts: input.artifacts.map((artifact) => ({
+      kind: artifact.kind,
+      label: artifact.label,
+      path: artifact.path
+    }))
+  };
+  const body = JSON.stringify(payload);
+  const timestamp = (/* @__PURE__ */ new Date()).toISOString();
+  const headers = {
+    "Content-Type": "application/json",
+    "x-mcp-scraper-timestamp": timestamp
+  };
+  const signature = webhookSignature(body, timestamp);
+  if (signature) headers["x-mcp-scraper-signature"] = signature;
+  let lastError = null;
+  for (let attempt = 1; attempt <= 3; attempt++) {
+    try {
+      const res = await fetch(input.webhookUrl, { method: "POST", headers, body, signal: AbortSignal.timeout(15e3) });
+      if (res.ok) {
+        await recordWorkflowWebhookDelivery({ runId: input.run.id, scheduleId: input.scheduleId, userId: input.userId, webhookUrl: input.webhookUrl, status: "delivered", attempts: attempt });
+        return;
+      }
+      lastError = `HTTP ${res.status}`;
+    } catch (err) {
+      lastError = err instanceof Error ? err.message : String(err);
+    }
+    await new Promise((resolve) => setTimeout(resolve, attempt * 500));
+  }
+  await recordWorkflowWebhookDelivery({ runId: input.run.id, scheduleId: input.scheduleId, userId: input.userId, webhookUrl: input.webhookUrl, status: "failed", attempts: 3, lastError });
+}
+async function executeWorkflowRun(input) {
+  await markWorkflowRunRunning(input.runId);
+  try {
+    const summary = await runWorkflow(input.workflowId, input.workflowInput, {
+      apiKey: input.user.api_key,
+      apiUrl: input.apiUrl,
+      outputDir: hostedWorkflowOutputDir(),
+      runId: input.runId
+    });
+    const manifest = await readManifestFromSummary(summary);
+    await completeWorkflowRunRecord(input.runId, summary.status, manifest ?? { summary });
+    const run = await getWorkflowRun(input.runId, input.user.id);
+    if (!run) throw new Error("Workflow run disappeared after execution");
+    const artifacts = await persistRunArtifacts(input.runId, input.user.id, manifest);
+    await deliverWorkflowWebhook({ userId: input.user.id, run, scheduleId: input.scheduleId ?? null, webhookUrl: input.webhookUrl ?? null, summary, artifacts });
+    return { run, summary, artifacts };
+  } catch (err) {
+    const message = err instanceof Error ? err.message : String(err);
+    await failWorkflowRunRecord(input.runId, message, { error: message });
+    const run = await getWorkflowRun(input.runId, input.user.id);
+    if (!run) throw err;
+    await deliverWorkflowWebhook({ userId: input.user.id, run, scheduleId: input.scheduleId ?? null, webhookUrl: input.webhookUrl ?? null, summary: null, artifacts: [] });
+    throw err;
+  }
+}
+workflowApp.get("/definitions", createApiKeyAuth(), (c) => {
+  return c.json({ workflows: listWorkflowDefinitions() });
+});
+workflowApp.post("/run", createApiKeyAuth(), async (c) => {
+  const user = c.get("user");
+  const parsed = RunBodySchema.safeParse(await c.req.json().catch(() => ({})));
+  if (!parsed.success) return c.json({ error: parsed.error.issues[0]?.message ?? "Invalid request" }, 400);
+  let input;
+  let webhookUrl;
+  try {
+    input = validateWorkflowInput(parsed.data.workflowId, parsed.data.input);
+    webhookUrl = await validateWebhookUrl(parsed.data.webhookUrl);
+  } catch (err) {
+    return c.json({ error: err instanceof Error ? err.message : String(err) }, 400);
+  }
+  const run = await createWorkflowRun({ userId: user.id, workflowId: parsed.data.workflowId, workflowInput: input });
+  try {
+    const executed = await executeWorkflowRun({
+      runId: run.id,
+      user,
+      workflowId: parsed.data.workflowId,
+      workflowInput: input,
+      apiUrl: originFromUrl(c.req.url),
+      webhookUrl
+    });
+    return c.json({ run: exposeRun(c, executed.run, executed.artifacts), summary: executed.summary });
+  } catch (err) {
+    const failed = await getWorkflowRun(run.id, user.id);
+    return c.json({ run: failed, error: err instanceof Error ? err.message : String(err) }, 500);
+  }
+});
+workflowApp.get("/runs", createApiKeyAuth(), async (c) => {
+  const user = c.get("user");
+  const runs = await listWorkflowRuns(user.id);
+  return c.json({ runs });
+});
+workflowApp.get("/runs/:id", createApiKeyAuth(), async (c) => {
+  const user = c.get("user");
+  const run = await getWorkflowRun(c.req.param("id"), user.id);
+  if (!run) return c.json({ error: "Run not found" }, 404);
+  const artifacts = await listWorkflowArtifacts(run.id, user.id);
+  return c.json({ run: exposeRun(c, run, artifacts) });
+});
+workflowApp.get("/runs/:id/artifacts/:artifactId", createApiKeyAuth(), async (c) => {
+  const user = c.get("user");
+  const run = await getWorkflowRun(c.req.param("id"), user.id);
+  if (!run) return c.json({ error: "Run not found" }, 404);
+  const artifact = await getWorkflowArtifact(c.req.param("artifactId"), user.id);
+  if (!artifact || artifact.run_id !== run.id) return c.json({ error: "Artifact not found" }, 404);
+  try {
+    const content = await readFile2(artifact.path);
+    return new Response(content, {
+      headers: {
+        "Content-Type": artifact.content_type,
+        "Content-Disposition": `attachment; filename="${artifact.path.split("/").pop() || artifact.id}"`
+      }
+    });
+  } catch {
+    return c.json({ error: "Artifact file is no longer available" }, 410);
+  }
+});
+workflowApp.post("/schedules", createApiKeyAuth(), async (c) => {
+  const user = c.get("user");
+  const parsed = ScheduleCreateSchema.safeParse(await c.req.json().catch(() => ({})));
+  if (!parsed.success) return c.json({ error: parsed.error.issues[0]?.message ?? "Invalid request" }, 400);
+  let input;
+  let webhookUrl;
+  try {
+    input = validateWorkflowInput(parsed.data.workflowId, parsed.data.input);
+    webhookUrl = await validateWebhookUrl(parsed.data.webhookUrl);
+  } catch (err) {
+    return c.json({ error: err instanceof Error ? err.message : String(err) }, 400);
+  }
+  const schedule = await createWorkflowSchedule({
+    userId: user.id,
+    workflowId: parsed.data.workflowId,
+    name: parsed.data.name ?? workflowDefinition(parsed.data.workflowId).title,
+    workflowInput: input,
+    cadence: parsed.data.cadence,
+    timezone: parsed.data.timezone,
+    webhookUrl,
+    nextRunAt: parsed.data.nextRunAt ?? defaultNextRunAt(parsed.data.cadence)
+  });
+  return c.json({ schedule }, 201);
+});
+workflowApp.get("/schedules", createApiKeyAuth(), async (c) => {
+  const user = c.get("user");
+  return c.json({ schedules: await listWorkflowSchedules(user.id) });
+});
+workflowApp.patch("/schedules/:id", createApiKeyAuth(), async (c) => {
+  const user = c.get("user");
+  const existing = await getWorkflowSchedule(c.req.param("id"), user.id);
+  if (!existing) return c.json({ error: "Schedule not found" }, 404);
+  const parsed = SchedulePatchSchema.safeParse(await c.req.json().catch(() => ({})));
+  if (!parsed.success) return c.json({ error: parsed.error.issues[0]?.message ?? "Invalid request" }, 400);
+  let nextInput;
+  let webhookUrl;
+  try {
+    nextInput = parsed.data.input ? validateWorkflowInput(existing.workflow_id, parsed.data.input) : void 0;
+    webhookUrl = parsed.data.webhookUrl === void 0 ? void 0 : await validateWebhookUrl(parsed.data.webhookUrl);
+  } catch (err) {
+    return c.json({ error: err instanceof Error ? err.message : String(err) }, 400);
+  }
+  const schedule = await patchWorkflowSchedule({
+    id: existing.id,
+    userId: user.id,
+    name: parsed.data.name,
+    status: parsed.data.status,
+    workflowInput: nextInput,
+    cadence: parsed.data.cadence,
+    timezone: parsed.data.timezone,
+    webhookUrl,
+    nextRunAt: parsed.data.nextRunAt
+  });
+  return c.json({ schedule });
+});
+workflowApp.delete("/schedules/:id", createApiKeyAuth(), async (c) => {
+  const user = c.get("user");
+  const deleted = await deleteWorkflowSchedule(c.req.param("id"), user.id);
+  if (!deleted) return c.json({ error: "Schedule not found" }, 404);
+  return c.json({ ok: true });
+});
+workflowApp.post("/schedules/:id/run", createApiKeyAuth(), async (c) => {
+  const user = c.get("user");
+  const schedule = await getWorkflowSchedule(c.req.param("id"), user.id);
+  if (!schedule) return c.json({ error: "Schedule not found" }, 404);
+  const run = await createWorkflowRun({ userId: user.id, scheduleId: schedule.id, workflowId: schedule.workflow_id, workflowInput: schedule.input });
+  try {
+    const executed = await executeWorkflowRun({
+      runId: run.id,
+      user,
+      workflowId: schedule.workflow_id,
+      workflowInput: schedule.input,
+      apiUrl: originFromUrl(c.req.url),
+      scheduleId: schedule.id,
+      webhookUrl: schedule.webhook_url
+    });
+    return c.json({ run: exposeRun(c, executed.run, executed.artifacts), summary: executed.summary });
+  } catch (err) {
+    const failed = await getWorkflowRun(run.id, user.id);
+    return c.json({ run: failed, error: err instanceof Error ? err.message : String(err) }, 500);
+  }
+});
+async function dispatchDueWorkflowSchedules(apiUrl, limit = 3) {
+  const now = (/* @__PURE__ */ new Date()).toISOString();
+  const due = await listDueWorkflowSchedules(now, limit);
+  const results = [];
+  for (const schedule of due) {
+    const user = await getUserById(schedule.user_id);
+    if (!user) {
+      results.push({ scheduleId: schedule.id, status: "failed", error: "User not found" });
+      continue;
+    }
+    const scheduledFor = schedule.next_run_at ?? now;
+    const run = await createWorkflowRun({
+      userId: user.id,
+      scheduleId: schedule.id,
+      workflowId: schedule.workflow_id,
+      workflowInput: schedule.input,
+      idempotencyKey: `${schedule.id}:${scheduledFor}`
+    });
+    await markWorkflowScheduleRan(schedule.id, now, addCadence(scheduledFor, schedule.cadence));
+    if (run.status !== "queued") {
+      results.push({ scheduleId: schedule.id, runId: run.id, status: run.status });
+      continue;
+    }
+    try {
+      const executed = await executeWorkflowRun({
+        runId: run.id,
+        user,
+        workflowId: schedule.workflow_id,
+        workflowInput: schedule.input,
+        apiUrl,
+        scheduleId: schedule.id,
+        webhookUrl: schedule.webhook_url
+      });
+      results.push({ scheduleId: schedule.id, runId: executed.run.id, status: executed.run.status });
+    } catch (err) {
+      results.push({ scheduleId: schedule.id, runId: run.id, status: "failed", error: err instanceof Error ? err.message : String(err) });
+    }
+  }
+  return { dispatched: results.length, results };
+}
+workflowApp.post("/cron/dispatch", async (c) => {
+  const secret2 = c.req.header("authorization");
+  if (!process.env.CRON_SECRET || secret2 !== `Bearer ${process.env.CRON_SECRET}`) {
+    return c.json({ error: "Unauthorized" }, 401);
+  }
+  return c.json(await dispatchDueWorkflowSchedules(originFromUrl(c.req.url)));
+});
+
+// src/api/serp-intelligence-routes.ts
+import { Hono as Hono8 } from "hono";
 
 // src/serp-intelligence/page-snapshot-extractor.ts
 import { createHash } from "crypto";
@@ -10945,7 +11367,7 @@ async function capturePageSnapshots(targets, options = {}) {
 }
 
 // src/serp-intelligence/schemas.ts
-import { z as z16 } from "zod";
+import { z as z17 } from "zod";
 var SerpIntelligenceDeviceValues = ["desktop", "mobile"];
 var SerpIntelligenceProxyModeValues = ["location", "configured", "none"];
 var SerpIntelligenceAttemptOutcomeValues = [
@@ -11007,171 +11429,171 @@ function isPublicHttpUrl(value) {
     return false;
   }
 }
-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)
+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("location"),
+  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)
 }).strict();
-var SerpIntelligencePageSnapshotRequestSchema = z16.object({
+var SerpIntelligencePageSnapshotRequestSchema = z17.object({
   url: SerpIntelligencePublicHttpUrlSchema,
-  sourceKind: z16.enum(SerpPageSnapshotSourceKindValues).default("configured_target"),
-  sourcePosition: z16.number().int().min(1).optional()
+  sourceKind: z17.enum(SerpPageSnapshotSourceKindValues).default("configured_target"),
+  sourcePosition: z17.number().int().min(1).optional()
 }).strict();
-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)
+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)
 }).strict();
-var SerpIntelligenceAICitationSchema = z16.object({
-  text: z16.string(),
-  href: z16.string()
+var SerpIntelligenceAICitationSchema = z17.object({
+  text: z17.string(),
+  href: z17.string()
 }).strict();
-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()
+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()
   }).strict().nullable()
 }).strict();
-var SerpIntelligenceLocationEvidenceSchema = z16.object({
-  status: z16.enum(SerpIntelligenceLocalizationStatusValues),
-  expected: z16.object({
-    city: z16.string(),
-    regionCode: z16.string().nullable(),
-    canonicalLocation: z16.string()
+var SerpIntelligenceLocationEvidenceSchema = z17.object({
+  status: z17.enum(SerpIntelligenceLocalizationStatusValues),
+  expected: z17.object({
+    city: z17.string(),
+    regionCode: z17.string().nullable(),
+    canonicalLocation: z17.string()
   }).strict().nullable(),
-  candidates: z16.array(z16.object({
-    city: z16.string(),
-    regionCode: z16.string(),
-    count: z16.number().int().min(0),
-    examples: z16.array(z16.string())
+  candidates: z17.array(z17.object({
+    city: z17.string(),
+    regionCode: z17.string(),
+    count: z17.number().int().min(0),
+    examples: z17.array(z17.string())
   }).strict())
 }).strict();
-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()
+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()
   }).strict(),
-  aiMode: z16.object({
-    detected: z16.boolean(),
-    text: z16.string().nullable(),
-    citations: z16.array(SerpIntelligenceAICitationSchema)
+  aiMode: z17.object({
+    detected: z17.boolean(),
+    text: z17.string().nullable(),
+    citations: z17.array(SerpIntelligenceAICitationSchema)
   }).strict(),
-  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()
+  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()
     }).strict()),
-    kgIds: z16.array(z16.string()),
-    cids: z16.array(z16.string()),
-    gcids: z16.array(z16.string())
+    kgIds: z17.array(z17.string()),
+    cids: z17.array(z17.string()),
+    gcids: z17.array(z17.string())
   }).strict(),
-  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)
+  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)
   }).strict(),
-  diagnostics: z16.object({
-    completionStatus: z16.enum(["paa_found", "no_paa", "serp_only"]),
-    problem: z16.null(),
-    warnings: z16.array(z16.unknown()).optional(),
-    debug: z16.object({
+  diagnostics: z17.object({
+    completionStatus: z17.enum(["paa_found", "no_paa", "serp_only"]),
+    problem: z17.null(),
+    warnings: z17.array(z17.unknown()).optional(),
+    debug: z17.object({
       locationEvidence: SerpIntelligenceLocationEvidenceSchema.optional()
     }).passthrough().optional()
   }).passthrough(),
-  whatPeopleSaying: z16.array(z16.unknown())
+  whatPeopleSaying: z17.array(z17.unknown())
 }).strict();
-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()
+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()
 }).strict();
-var SerpPageSnapshotCaptureSchema = z16.object({
+var SerpPageSnapshotCaptureSchema = z17.object({
   url: SerpIntelligencePublicHttpUrlSchema,
   requestedUrl: SerpIntelligencePublicHttpUrlSchema,
   finalUrl: SerpIntelligencePublicHttpUrlSchema.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(),
+  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(),
   canonicalUrl: SerpIntelligencePublicHttpUrlSchema.nullable(),
-  metaDescription: z16.string().nullable(),
-  headings: z16.array(z16.object({
-    level: z16.number().int().min(1).max(6),
-    text: z16.string()
+  metaDescription: z17.string().nullable(),
+  headings: z17.array(z17.object({
+    level: z17.number().int().min(1).max(6),
+    text: z17.string()
   }).strict()).default([]),
-  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()
+  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()
   }).strict(),
-  error: z16.object({
-    code: z16.string(),
-    message: z16.string()
+  error: z17.object({
+    code: z17.string(),
+    message: z17.string()
   }).strict().nullable()
 }).strict();
-var SerpIntelligenceCaptureResponseSchema = z16.object({
+var SerpIntelligenceCaptureResponseSchema = z17.object({
   harvestResult: SerpIntelligenceHarvestResultSchema,
-  attempts: z16.array(SerpIntelligenceCaptureAttemptSchema),
+  attempts: z17.array(SerpIntelligenceCaptureAttemptSchema),
   locationEvidence: SerpIntelligenceLocationEvidenceSchema.nullable(),
-  pageSnapshotArtifacts: z16.array(SerpPageSnapshotCaptureSchema),
-  billing: z16.object({
-    creditsUsed: z16.number().min(0).optional(),
-    requestId: z16.string().optional(),
-    jobId: z16.string().optional()
+  pageSnapshotArtifacts: z17.array(SerpPageSnapshotCaptureSchema),
+  billing: z17.object({
+    creditsUsed: z17.number().min(0).optional(),
+    requestId: z17.string().optional(),
+    jobId: z17.string().optional()
   }).strict().optional()
 }).strict();
-var SerpIntelligencePageSnapshotsResponseSchema = z16.object({
-  pageSnapshotArtifacts: z16.array(SerpPageSnapshotCaptureSchema),
-  attempts: z16.array(SerpIntelligenceCaptureAttemptSchema).default([])
+var SerpIntelligencePageSnapshotsResponseSchema = z17.object({
+  pageSnapshotArtifacts: z17.array(SerpPageSnapshotCaptureSchema),
+  attempts: z17.array(SerpIntelligenceCaptureAttemptSchema).default([])
 }).strict();
 
 // src/serp-intelligence/serp-capture-service.ts
@@ -11343,7 +11765,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 Hono7();
+var serpIntelligenceApp = new Hono8();
 serpIntelligenceApp.use("*", createApiKeyAuth());
 function structuredError(input) {
   return {
@@ -11518,7 +11940,7 @@ serpIntelligenceApp.post("/page-snapshots", async (c) => {
 });
 
 // src/mcp/mcp-routes.ts
-import { Hono as Hono8 } from "hono";
+import { Hono as Hono9 } from "hono";
 import { WebStandardStreamableHTTPServerTransport } from "@modelcontextprotocol/sdk/server/webStandardStreamableHttp.js";
 configureReportSaving(false);
 function mcpAuthError() {
@@ -11548,11 +11970,11 @@ async function requireMcpCallerKey(c) {
   if (!user) return mcpAuthError();
   return callerKey;
 }
-var mcpApp = new Hono8();
+var mcpApp = new Hono9();
 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 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.",
+    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, briefly waits for browser-service automatic CAPTCHA/challenge solving when Google blocks a page, and rotates to a new proxy/session if the challenge does not clear or location evidence is wrong. 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));
@@ -11584,7 +12006,7 @@ mcpApp.all("/", async (c) => {
 });
 
 // src/api/browser-agent-routes.ts
-import { Hono as Hono9 } from "hono";
+import { Hono as Hono10 } from "hono";
 
 // src/api/browser-agent-db.ts
 import { randomUUID } from "crypto";
@@ -12105,7 +12527,7 @@ async function loadOpenSession(id, userId) {
   return row;
 }
 function buildBrowserAgentRoutes() {
-  const app2 = new Hono9();
+  const app2 = new Hono10();
   app2.use("*", async (c, next) => {
     await migrateBrowserAgent();
     return next();
@@ -12620,9 +13042,9 @@ if (state.key) { refreshSessions(); if (state.current) selectSession(state.curre
 
 // src/api/stripe-routes.ts
 import Stripe from "stripe";
-import { Hono as Hono10 } from "hono";
+import { Hono as Hono11 } from "hono";
 var stripe = new Stripe(process.env.STRIPE_SECRET_KEY, { apiVersion: "2026-02-25.clover" });
-var stripeApp = new Hono10();
+var stripeApp = new Hono11();
 stripeApp.post("/webhooks", async (c) => {
   const sig = c.req.header("stripe-signature");
   const body = await c.req.text();
@@ -12717,27 +13139,27 @@ import { getCookie, setCookie, deleteCookie } from "hono/cookie";
 import Stripe2 from "stripe";
 
 // src/api/billing-schemas.ts
-import { z as z17 } from "zod";
-var BillingCheckoutBodySchema = z17.object({
-  priceId: z17.string().min(1)
-});
-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 = z17.object({
-  balance_mc: z17.number().int().nonnegative(),
-  balance_credits: z17.number().nonnegative(),
+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(),
   free_credits: FreeCreditBreakdownSchema,
-  ledger: z17.array(z17.any())
+  ledger: z18.array(z18.any())
 });
-var MonthlyRefreshSweepResultSchema = z17.object({
-  usersRefreshed: z17.number().int().nonnegative(),
-  totalMcGranted: z17.number().int().nonnegative()
+var MonthlyRefreshSweepResultSchema = z18.object({
+  usersRefreshed: z18.number().int().nonnegative(),
+  totalMcGranted: z18.number().int().nonnegative()
 });
 
 // src/api/credit-operations.ts
@@ -12838,7 +13260,7 @@ async function getFreeCreditBreakdown(userId) {
 }
 
 // src/api/session.ts
-import { createHmac, timingSafeEqual } from "crypto";
+import { createHmac as createHmac2, timingSafeEqual } from "crypto";
 var isProduction = () => process.env.NODE_ENV === "production" || process.env.VERCEL === "1";
 function getSessionSecret() {
   const configured = process.env.SESSION_SECRET?.trim();
@@ -12857,7 +13279,7 @@ function safeEqualHex(a, b) {
 }
 function signSession(userId) {
   const payload = String(userId);
-  const sig = createHmac("sha256", secret()).update(payload).digest("hex");
+  const sig = createHmac2("sha256", secret()).update(payload).digest("hex");
   return `${payload}.${sig}`;
 }
 function verifySession(token) {
@@ -12865,7 +13287,7 @@ function verifySession(token) {
   if (dot === -1) return null;
   const payload = token.slice(0, dot);
   const sig = token.slice(dot + 1);
-  const expected = createHmac("sha256", secret()).update(payload).digest("hex");
+  const expected = createHmac2("sha256", secret()).update(payload).digest("hex");
   if (!safeEqualHex(sig, expected)) return null;
   const id = parseInt(payload);
   return isNaN(id) ? null : id;
@@ -12948,7 +13370,7 @@ var sessionAuth = createMiddleware3(async (c, next) => {
   c.set("sessionUser", { ...refreshed, balance_mc: balanceMc });
   return next();
 });
-var app = new Hono11();
+var app = new Hono12();
 var STRIPE_API_VERSION = "2026-02-25.clover";
 function requireStripeSecret() {
   const secret2 = process.env.STRIPE_SECRET_KEY?.trim();
@@ -13594,13 +14016,14 @@ 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-NAKGTIF5.js");
+  const { drainQueue } = await import("./worker-TDJQ6TH3.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([
     drainQueue(budget),
     runMonthlyRefreshSweep()
   ]);
-  return c.json({ drained: results.length, results, sweepResult });
+  return c.json({ drained: results.length, results, sweepResult, workflowDispatch: workflowDispatchResult });
 });
 app.on(["GET", "POST", "PUT"], "/api/inngest", serveInngest({ client: inngest, functions: [siteAuditFn] }));
 app.route("/api/internal/site-architecture-auditor", siteAuditApp);
@@ -13609,6 +14032,7 @@ app.route("/screenshot", screenshotApp);
 app.route("/facebook", facebookAdApp);
 app.route("/maps", mapsApp);
 app.route("/directory", directoryApp);
+app.route("/workflows", workflowApp);
 app.route("/serp-intelligence", serpIntelligenceApp);
 app.route("/mcp", mcpApp);
 app.route("/agent", buildBrowserAgentRoutes());
@@ -13720,4 +14144,4 @@ app.get("/blog/:slug/", (c) => {
 export {
   app
 };
-//# sourceMappingURL=server-RIKRBDOI.js.map
+//# sourceMappingURL=server-BKJ7LULQ.js.map