mcp-scraper 0.3.24 → 0.3.26

package/dist/bin/api-server.js

@@ -17,9 +17,9 @@ loadDotEnv();
 async function main() {
   const [{ serve }, { app }, { startWorker }, { migrate }] = await Promise.all([
     import("@hono/node-server"),
-    import("../server-2SRARAO5.js"),
-    import("../worker-UM5UM6O5.js"),
-    import("../db-EG5ETPTY.js")
+    import("../server-HIGHKTEV.js"),
+    import("../worker-UC6D2756.js"),
+    import("../db-FP2ABUU4.js")
   ]);
   const PORT = parseInt(process.env.PORT ?? "3001");
   try {

package/dist/bin/mcp-scraper-cli.cjs

@@ -8,7 +8,7 @@ var import_promises4 = require("fs/promises");
 var import_node_path3 = require("path");
 
 // src/version.ts
-var PACKAGE_VERSION = "0.3.24";
+var PACKAGE_VERSION = "0.3.26";
 
 // src/cli/agent-config.ts
 function apiKeyValue(options) {
@@ -339,6 +339,26 @@ function slugify(s) {
   return s.toLowerCase().replace(/\s+/g, "-").replace(/[^a-z0-9-]/g, "");
 }
 
+// src/output/memory-library-sink.ts
+async function postToMemoryLibrary(args) {
+  const url = process.env.MCP_MEMORY_INGEST_URL;
+  const key = process.env.MCP_MEMORY_KEY;
+  if (!url || !key) return;
+  try {
+    const res = await fetch(url, {
+      method: "POST",
+      headers: { "content-type": "application/json" },
+      body: JSON.stringify({ data: { apiKey: key, title: args.title, content: args.content, source: args.source } })
+    });
+    const body = await res.json().catch(() => null);
+    if (!res.ok || body?.result?.error) {
+      console.warn("[memory-library-sink] ingest not accepted:", res.status, body?.result?.message ?? "");
+    }
+  } catch (err) {
+    console.warn("[memory-library-sink] ingest failed:", err?.message);
+  }
+}
+
 // src/workflows/artifact-writer.ts
 function workflowOutputBaseDir(outputDir) {
   return outputDir?.trim() || process.env.MCP_SCRAPER_OUTPUT_DIR?.trim() || (0, import_node_path2.join)((0, import_node_os2.homedir)(), "Downloads", "mcp-scraper");
@@ -379,6 +399,7 @@ var ArtifactWriter = class _ArtifactWriter {
   async remember(kind, label, path, rows) {
     const size = await (0, import_promises2.stat)(path).then((s) => s.size).catch(() => void 0);
     this.artifacts.push({ kind, label, path, bytes: size, rows });
+    await postToMemoryLibrary({ title: `${this.title} ${label}`, content: `artifact: ${path}`, source: `mcp-scraper-workflow:${this.workflowId}:${this.runId}` });
     return path;
   }
   async writeJson(label, relativePath, data) {
@@ -473,7 +494,7 @@ async function openWorkflowReport(id, outputDir) {
 
 // src/workflows/registry.ts
 var import_promises3 = require("fs/promises");
-var import_zod6 = require("zod");
+var import_zod7 = require("zod");
 
 // src/workflows/http-client.ts
 var WorkflowHttpClient = class {
@@ -796,7 +817,7 @@ var import_zod3 = require("zod");
 
 // src/schemas.ts
 var import_zod2 = require("zod");
-var DEFAULT_PROXY_MODE = "configured";
+var DEFAULT_PROXY_MODE = "none";
 var DEFAULT_MAPS_PROXY_MODE = "location";
 var HarvestOptionsSchema = import_zod2.z.object({
   query: import_zod2.z.string().min(1),
@@ -818,7 +839,8 @@ var HarvestOptionsSchema = import_zod2.z.object({
   outputDir: import_zod2.z.string().default("./paa-output"),
   format: import_zod2.z.enum(["json", "csv", "both"]).default("both"),
   serpOnly: import_zod2.z.boolean().default(false),
-  pages: import_zod2.z.number().int().min(1).max(2).default(1)
+  pages: import_zod2.z.number().int().min(1).max(2).default(1),
+  softDeadlineMs: import_zod2.z.number().optional()
 });
 var MapsPlaceOptionsSchema = import_zod2.z.object({
   businessName: import_zod2.z.string().min(1),
@@ -1024,20 +1046,41 @@ ${summary}
   }
 };
 
-// src/workflows/workflows/local-competitive-audit.ts
+// src/workflows/workflows/get-leads.ts
 var import_zod4 = require("zod");
-var LocalCompetitiveAuditInputSchema = import_zod4.z.object({
-  query: import_zod4.z.string().min(1),
-  state: import_zod4.z.string().min(2).default("TN"),
-  minPopulation: import_zod4.z.number().int().min(0).default(1e5),
-  maxCities: import_zod4.z.number().int().min(1).max(100).default(25),
-  maxResultsPerCity: import_zod4.z.number().int().min(1).max(50).default(20),
-  hydrateTop: import_zod4.z.number().int().min(0).max(10).default(5),
-  maxReviews: import_zod4.z.number().int().min(0).max(500).default(50),
-  concurrency: import_zod4.z.number().int().min(1).max(5).default(5),
-  proxyMode: import_zod4.z.enum(["location", "configured", "none"]).default(DEFAULT_MAPS_PROXY_MODE),
-  returnPartial: import_zod4.z.boolean().default(true)
+var GetLeadsInputSchema = import_zod4.z.object({
+  query: import_zod4.z.string().min(1).describe('Business category, niche, or keyword to search on Google Maps, e.g. "roofers", "med spas", "dentists". Do not include the city here.'),
+  location: import_zod4.z.string().min(1).describe('City / market to search, e.g. "Houston, TX" or "Austin, Texas".'),
+  maxResults: import_zod4.z.number().int().min(1).max(50).default(25).describe("How many Maps businesses to collect for the market. Maximum 50."),
+  enrichWebsites: import_zod4.z.boolean().default(true).describe("Visit each business website (home + contact pages) to harvest email and social links. Uses the proxy/browser-backed extractor so blocked sites still resolve."),
+  hydrateReviewCounts: import_zod4.z.boolean().default(true).describe("Deep-dive each profile to confirm the review count and booking URL that the Maps search list omits."),
+  concurrency: import_zod4.z.number().int().min(1).max(4).default(3).describe("How many businesses to enrich in parallel. Keep low to respect per-account concurrency limits."),
+  proxyMode: import_zod4.z.enum(["location", "configured", "none"]).default(DEFAULT_MAPS_PROXY_MODE).describe("Proxy targeting for the Maps search. location targets the market; none is for local debugging.")
 });
+var LEADS_CSV_HEADERS = [
+  "position",
+  "business_name",
+  "review_stars",
+  "review_count",
+  "category",
+  "address",
+  "phone",
+  "website",
+  "email",
+  "email_domain_match",
+  "email_status",
+  "socials",
+  "booking_url",
+  "place_url",
+  "cid",
+  "source_location"
+];
+var EMAIL_RE = /[A-Za-z0-9._%+-]+@[A-Za-z0-9.-]+\.[A-Za-z]{2,}/g;
+var MAILTO_RE = /mailto:([^"'?>\s]+)/gi;
+var SOCIAL_RE = /https?:\/\/(?:www\.)?(?:facebook|instagram|linkedin|twitter|youtube|tiktok)\.com\/[^\s"'<>)]+/gi;
+var EMAIL_BAD = [".png", ".jpg", ".jpeg", ".gif", ".svg", ".webp", ".ico", "sentry", "wix.com", "wixpress", "example.", "godaddy", "squarespace", "schema.org", "@2x", "u003e", "core-js"];
+var EMAIL_PREFIX = ["info@", "office@", "contact@", "sales@", "hello@", "admin@", "service@", "support@"];
+var SOCIAL_SKIP = ["/sharer", "/share?", "/intent/", "plugins/", "/dialog/", "platform.", "badge", "developers."];
 async function mapLimit(items, limit, fn) {
   const out = new Array(items.length);
   let next = 0;
@@ -1051,6 +1094,224 @@ async function mapLimit(items, limit, fn) {
   await Promise.all(Array.from({ length: Math.min(limit, items.length) }, () => worker()));
   return out;
 }
+function hostRoot(url) {
+  try {
+    return new URL(url).hostname.replace(/^www\./, "").split(".")[0].toLowerCase();
+  } catch {
+    return "";
+  }
+}
+function cleanEmails(raw) {
+  const out = /* @__PURE__ */ new Set();
+  for (const value of raw) {
+    const email = value.trim().toLowerCase().replace(/\.$/, "");
+    if (email.split("@").length !== 2) continue;
+    if (email.length > 60) continue;
+    if (EMAIL_BAD.some((bad) => email.includes(bad))) continue;
+    out.add(email);
+  }
+  return [...out];
+}
+function pickEmail(emails, host) {
+  if (!emails.length) return "";
+  const root = hostRoot(host);
+  for (const prefix of EMAIL_PREFIX) {
+    const hit = emails.find((e) => e.startsWith(prefix) && root && e.split("@")[1].includes(root));
+    if (hit) return hit;
+  }
+  const domainHit = emails.find((e) => root && e.split("@")[1].includes(root));
+  if (domainHit) return domainHit;
+  for (const prefix of EMAIL_PREFIX) {
+    const hit = emails.find((e) => e.startsWith(prefix));
+    if (hit) return hit;
+  }
+  return emails[0];
+}
+function parseContacts(html) {
+  const mailtos = [...html.matchAll(MAILTO_RE)].map((m) => decodeURIComponent(m[1]).split("?")[0]);
+  const inline = html.match(EMAIL_RE) ?? [];
+  const emails = cleanEmails([...mailtos, ...inline]);
+  const socials = [...new Set((html.match(SOCIAL_RE) ?? []).map((s) => s.replace(/[)"'<>]+$/, "")).filter((s) => !SOCIAL_SKIP.some((skip) => s.toLowerCase().includes(skip))))].slice(0, 5);
+  return { emails, socials };
+}
+function buildAttemptUrls(website) {
+  const urls = /* @__PURE__ */ new Set();
+  urls.add(website);
+  try {
+    const origin = new URL(website).origin;
+    urls.add(`${origin}/contact`);
+    urls.add(`${origin}/contact-us`);
+  } catch {
+    return [...urls];
+  }
+  return [...urls].slice(0, 3);
+}
+var getLeadsWorkflowDefinition = {
+  id: "get-leads",
+  title: "Get Leads",
+  description: "Build an outreach-ready local lead list: Google Maps search for a niche in a market, confirm review counts + booking URLs, then visit each business website (home + contact) to harvest email and social links, with proxy/browser-backed extraction so blocked sites still resolve. Saves a leads CSV.",
+  inputSchema: GetLeadsInputSchema,
+  async run(input, ctx) {
+    await ctx.artifacts.writeManifest("running", {}, [], []);
+    const warnings = [];
+    const errors = [];
+    const search = await ctx.client.post("/maps/search", {
+      query: input.query,
+      location: input.location,
+      maxResults: input.maxResults,
+      proxyMode: input.proxyMode
+    }, 18e4);
+    await ctx.artifacts.writeJson("Maps search raw", "raw/maps-search.json", search);
+    const seen = /* @__PURE__ */ new Set();
+    const deduped = search.results.filter((result) => {
+      const key = result.cid ?? result.placeUrl ?? result.name.toLowerCase();
+      if (seen.has(key)) return false;
+      seen.add(key);
+      return true;
+    });
+    const rows = await mapLimit(deduped, input.concurrency, async (result) => {
+      let reviewCount = result.reviewCount ?? "";
+      let bookingUrl = "";
+      let website = result.websiteUrl ?? "";
+      if (input.hydrateReviewCounts) {
+        try {
+          const place = await ctx.client.post("/maps/place", {
+            businessName: result.name,
+            location: input.location,
+            includeReviews: false
+          }, 18e4);
+          reviewCount = place.reviewCount ?? reviewCount;
+          bookingUrl = place.bookingUrl ?? "";
+          website = website || (place.website ?? "");
+        } catch (err) {
+          warnings.push(`Review hydration failed for ${result.name}: ${err instanceof Error ? err.message : String(err)}`);
+        }
+      }
+      let email = "";
+      let socials = [];
+      let emailStatus = website ? "no email found" : "no website";
+      let domainMatch = "";
+      if (input.enrichWebsites && website) {
+        const attempts = buildAttemptUrls(website);
+        let reached = false;
+        const allEmails = [];
+        const allSocials = /* @__PURE__ */ new Set();
+        for (const attemptUrl of attempts) {
+          try {
+            const page = await ctx.client.post("/extract-url", { url: attemptUrl }, 12e4);
+            reached = true;
+            const parsed = parseContacts(page.bodyHtml ?? page.bodyMarkdown ?? "");
+            allEmails.push(...parsed.emails);
+            parsed.socials.forEach((s) => allSocials.add(s));
+            if (parsed.emails.length) break;
+          } catch {
+            continue;
+          }
+        }
+        socials = [...allSocials].slice(0, 5);
+        email = pickEmail([...new Set(allEmails)], website);
+        if (email) {
+          domainMatch = hostRoot(website) && email.split("@")[1].includes(hostRoot(website)) ? "yes" : "NO-verify";
+          emailStatus = domainMatch === "yes" ? "ok" : "ok (off-domain \u2014 verify)";
+        } else if (!reached) {
+          emailStatus = "site unreachable";
+        } else if (socials.length) {
+          emailStatus = "form/social only";
+        }
+      }
+      return {
+        position: result.position,
+        business_name: result.name,
+        review_stars: result.rating ?? "",
+        review_count: reviewCount,
+        category: result.category ?? "",
+        address: result.address ?? "",
+        phone: result.phone ?? "",
+        website,
+        email,
+        email_domain_match: domainMatch,
+        email_status: emailStatus,
+        socials: socials.join(" ; "),
+        booking_url: bookingUrl,
+        place_url: result.placeUrl,
+        cid: result.cid ?? "",
+        source_location: input.location
+      };
+    });
+    await ctx.artifacts.writeCsv("Leads CSV", "exports/leads.csv", LEADS_CSV_HEADERS, rows);
+    await ctx.artifacts.writeJson("Leads evidence", "evidence.json", { input, search: { query: search.searchQuery, resultCount: search.resultCount }, rows });
+    const withEmail = rows.filter((r) => r.email).length;
+    const domainMatched = rows.filter((r) => r.email_domain_match === "yes").length;
+    const withReviewCount = rows.filter((r) => r.review_count).length;
+    const withSocials = rows.filter((r) => r.socials).length;
+    const withWebsite = rows.filter((r) => r.website).length;
+    const summary = `${rows.length} ${input.query} in ${input.location}: ${withEmail} emails (${domainMatched} domain-matched), ${withReviewCount} review counts, ${withSocials} with socials.`;
+    await ctx.artifacts.writeText("Summary", "summary.md", `# Get Leads
+
+${summary}
+`);
+    await ctx.artifacts.writeText("Agent tasks", "tasks.md", [
+      "# Get Leads \u2014 next steps",
+      "",
+      "- [ ] Verify deliverability of the harvested emails before outreach (MX/SMTP check).",
+      '- [ ] For "form/social only" rows, use the website contact form or the captured social profile.',
+      '- [ ] Treat "off-domain \u2014 verify" emails with care; they may belong to a web developer or parent brand.',
+      "- [ ] Respect CAN-SPAM / GDPR \u2014 scraped contact data is not consent to email."
+    ].join("\n"));
+    const reportPath = await ctx.artifacts.writeHtml("HTML report", "report.html", renderWorkflowReport({
+      title: "Get Leads",
+      subtitle: `${input.query} \xB7 ${input.location}`,
+      summary,
+      warnings,
+      tables: [
+        {
+          title: "Leads",
+          columns: ["position", "business_name", "review_stars", "review_count", "phone", "website", "email", "email_status", "socials", "booking_url"],
+          rows
+        }
+      ]
+    }));
+    const status2 = errors.length ? "failed" : warnings.length ? "partial" : "succeeded";
+    const counts = {
+      businesses: rows.length,
+      withWebsite,
+      emails: withEmail,
+      domainMatchedEmails: domainMatched,
+      reviewCounts: withReviewCount,
+      withSocials
+    };
+    await ctx.artifacts.writeManifest(status2, counts, warnings, errors);
+    return { title: "Get Leads", summary, status: status2, counts, warnings, errors, reportPath };
+  }
+};
+
+// src/workflows/workflows/local-competitive-audit.ts
+var import_zod5 = require("zod");
+var LocalCompetitiveAuditInputSchema = import_zod5.z.object({
+  query: import_zod5.z.string().min(1),
+  state: import_zod5.z.string().min(2).default("TN"),
+  minPopulation: import_zod5.z.number().int().min(0).default(1e5),
+  maxCities: import_zod5.z.number().int().min(1).max(100).default(25),
+  maxResultsPerCity: import_zod5.z.number().int().min(1).max(50).default(20),
+  hydrateTop: import_zod5.z.number().int().min(0).max(10).default(5),
+  maxReviews: import_zod5.z.number().int().min(0).max(500).default(50),
+  concurrency: import_zod5.z.number().int().min(1).max(5).default(5),
+  proxyMode: import_zod5.z.enum(["location", "configured", "none"]).default(DEFAULT_MAPS_PROXY_MODE),
+  returnPartial: import_zod5.z.boolean().default(true)
+});
+async function mapLimit2(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], index);
+    }
+  }
+  await Promise.all(Array.from({ length: Math.min(limit, items.length) }, () => worker()));
+  return out;
+}
 function numberFrom(value) {
   if (value === null || value === void 0 || value === "") return null;
   const parsed = Number(String(value).replace(/[^\d.]/g, ""));
@@ -1104,7 +1365,7 @@ var localCompetitiveAuditWorkflowDefinition = {
       seen.add(key);
       return true;
     });
-    const hydrated = await mapLimit(deduped, 3, async ({ city, result }, index) => {
+    const hydrated = await mapLimit2(deduped, 3, async ({ city, result }, index) => {
       try {
         const detail = await ctx.client.post("/maps/place", {
           businessName: result.name,
@@ -1224,7 +1485,7 @@ ${summary}
 };
 
 // src/workflows/workflows/comparison-briefs.ts
-var import_zod5 = require("zod");
+var import_zod6 = require("zod");
 
 // src/workflows/workflows/seo-workflow-utils.ts
 var STOP_WORDS = /* @__PURE__ */ new Set([
@@ -1367,7 +1628,7 @@ function pageSummaryRow(page, source) {
     schema_types: (page.schemaTypes ?? []).join("; ")
   };
 }
-async function mapLimit2(items, limit, fn) {
+async function mapLimit3(items, limit, fn) {
   const out = new Array(items.length);
   let next = 0;
   async function worker() {
@@ -1382,49 +1643,49 @@ async function mapLimit2(items, limit, fn) {
 }
 
 // src/workflows/workflows/comparison-briefs.ts
-var ProxyModeSchema = import_zod5.z.enum(["location", "configured", "none"]);
-var MapComparisonInputSchema = import_zod5.z.object({
-  query: import_zod5.z.string().min(1),
-  location: import_zod5.z.string().optional(),
-  state: import_zod5.z.string().optional(),
-  minPopulation: import_zod5.z.number().int().min(0).default(1e5),
-  maxCities: import_zod5.z.number().int().min(1).max(100).default(5),
-  maxResultsPerCity: import_zod5.z.number().int().min(1).max(50).default(20),
-  hydrateTop: import_zod5.z.number().int().min(0).max(10).default(5),
-  maxReviews: import_zod5.z.number().int().min(0).max(500).default(25),
-  concurrency: import_zod5.z.number().int().min(1).max(5).default(5),
+var ProxyModeSchema = import_zod6.z.enum(["location", "configured", "none"]);
+var MapComparisonInputSchema = import_zod6.z.object({
+  query: import_zod6.z.string().min(1),
+  location: import_zod6.z.string().optional(),
+  state: import_zod6.z.string().optional(),
+  minPopulation: import_zod6.z.number().int().min(0).default(1e5),
+  maxCities: import_zod6.z.number().int().min(1).max(100).default(5),
+  maxResultsPerCity: import_zod6.z.number().int().min(1).max(50).default(20),
+  hydrateTop: import_zod6.z.number().int().min(0).max(10).default(5),
+  maxReviews: import_zod6.z.number().int().min(0).max(500).default(25),
+  concurrency: import_zod6.z.number().int().min(1).max(5).default(5),
   proxyMode: ProxyModeSchema.default(DEFAULT_MAPS_PROXY_MODE),
-  returnPartial: import_zod5.z.boolean().default(true)
+  returnPartial: import_zod6.z.boolean().default(true)
 }).refine((input) => input.location || input.state, {
   message: "Either location or state is required for map-comparison"
 });
-var SerpComparisonInputSchema = import_zod5.z.object({
-  keyword: import_zod5.z.string().min(1),
-  domain: import_zod5.z.string().optional(),
-  url: import_zod5.z.string().url().optional(),
-  location: import_zod5.z.string().optional(),
-  maxResults: import_zod5.z.number().int().min(1).max(20).default(10),
-  maxQuestions: import_zod5.z.number().int().min(1).max(200).default(40),
-  extractTop: import_zod5.z.number().int().min(0).max(10).default(5),
-  includePaa: import_zod5.z.boolean().default(true),
-  includeAiOverview: import_zod5.z.boolean().default(true),
-  returnPartial: import_zod5.z.boolean().default(true)
+var SerpComparisonInputSchema = import_zod6.z.object({
+  keyword: import_zod6.z.string().min(1),
+  domain: import_zod6.z.string().optional(),
+  url: import_zod6.z.string().url().optional(),
+  location: import_zod6.z.string().optional(),
+  maxResults: import_zod6.z.number().int().min(1).max(20).default(10),
+  maxQuestions: import_zod6.z.number().int().min(1).max(200).default(40),
+  extractTop: import_zod6.z.number().int().min(0).max(10).default(5),
+  includePaa: import_zod6.z.boolean().default(true),
+  includeAiOverview: import_zod6.z.boolean().default(true),
+  returnPartial: import_zod6.z.boolean().default(true)
 });
-var PaaExpansionBriefInputSchema = import_zod5.z.object({
-  keyword: import_zod5.z.string().min(1),
-  location: import_zod5.z.string().optional(),
-  maxQuestions: import_zod5.z.number().int().min(1).max(300).default(80),
-  depth: import_zod5.z.number().int().min(1).max(6).default(3),
-  returnPartial: import_zod5.z.boolean().default(true)
+var PaaExpansionBriefInputSchema = import_zod6.z.object({
+  keyword: import_zod6.z.string().min(1),
+  location: import_zod6.z.string().optional(),
+  maxQuestions: import_zod6.z.number().int().min(1).max(300).default(80),
+  depth: import_zod6.z.number().int().min(1).max(6).default(3),
+  returnPartial: import_zod6.z.boolean().default(true)
 });
-var AiOverviewLanguageInputSchema = import_zod5.z.object({
-  keyword: import_zod5.z.string().min(1),
-  domain: import_zod5.z.string().optional(),
-  url: import_zod5.z.string().url().optional(),
-  location: import_zod5.z.string().optional(),
-  maxQuestions: import_zod5.z.number().int().min(1).max(200).default(40),
-  extractTop: import_zod5.z.number().int().min(0).max(8).default(3),
-  returnPartial: import_zod5.z.boolean().default(true)
+var AiOverviewLanguageInputSchema = import_zod6.z.object({
+  keyword: import_zod6.z.string().min(1),
+  domain: import_zod6.z.string().optional(),
+  url: import_zod6.z.string().url().optional(),
+  location: import_zod6.z.string().optional(),
+  maxQuestions: import_zod6.z.number().int().min(1).max(200).default(40),
+  extractTop: import_zod6.z.number().int().min(0).max(8).default(3),
+  returnPartial: import_zod6.z.boolean().default(true)
 });
 function businessRowsFromMaps(location, query, results) {
   return results.map((result) => ({
@@ -1541,7 +1802,7 @@ function pageGapRows(targetPage, competitorPages) {
   return rows.slice(0, 150);
 }
 async function extractPages(ctx, sources, warnings, labelPrefix) {
-  return mapLimit2(sources.filter((source) => source.url), 2, async (source, index) => {
+  return mapLimit3(sources.filter((source) => source.url), 2, async (source, index) => {
     try {
       const page = await ctx.client.post("/extract-url", { url: source.url }, 18e4);
       await ctx.artifacts.writeJson(`${labelPrefix} ${index + 1}`, `raw/extract-url/${labelPrefix.toLowerCase()}-${index + 1}.json`, page);
@@ -1590,7 +1851,7 @@ var mapComparisonWorkflowDefinition = {
     }
     const compareRows = comparisonRows(rows);
     const selected = compareRows.slice(0, input.hydrateTop * Math.max(1, input.location ? 1 : input.maxCities));
-    const hydrated = await mapLimit2(selected, 3, async (row, index) => {
+    const hydrated = await mapLimit3(selected, 3, async (row, index) => {
       try {
         const detail = await ctx.client.post("/maps/place", {
           businessName: row.business_name,
@@ -1925,6 +2186,7 @@ var aiOverviewLanguageWorkflowDefinition = {
 // src/workflows/registry.ts
 var DEFINITIONS = [
   directoryWorkflowDefinition,
+  getLeadsWorkflowDefinition,
   agentPacketWorkflowDefinition,
   localCompetitiveAuditWorkflowDefinition,
   mapComparisonWorkflowDefinition,