lacspace-leads 1.7.2 → 1.9.0

package/dist/cli.js

@@ -1,7 +1,7 @@
 #!/usr/bin/env node
 
 // src/cli.ts
-import { writeFileSync as writeFileSync2, existsSync as existsSync2, readFileSync as readFileSync2 } from "fs";
+import { writeFileSync as writeFileSync3, existsSync as existsSync3, readFileSync as readFileSync2, unlinkSync as unlinkSync2 } from "fs";
 import { resolve as resolve2, extname as extname2 } from "path";
 import { createInterface } from "readline/promises";
 import { stdin, stdout, stderr, argv, exit } from "process";
@@ -717,17 +717,6 @@ function rowsToLeads(rows) {
 }
 
 // src/scrape.ts
-async function pool(items, n, fn, signal) {
-  let next = 0;
-  const workers = Array.from({ length: Math.max(1, Math.min(n, items.length)) }, async () => {
-    for (; ; ) {
-      const i = next++;
-      if (i >= items.length || signal?.aborted) return;
-      await fn(items[i], i);
-    }
-  });
-  await Promise.all(workers);
-}
 var LeadsError = class extends Error {
   code;
   cause;
@@ -765,9 +754,14 @@ function parseLatLng(url) {
   if (at) return { latitude: parseFloat(at[1]), longitude: parseFloat(at[2]) };
   return {};
 }
+function placeKey(href) {
+  const id = href.match(/!1s(0x[0-9a-f]+:0x[0-9a-f]+)/i) ?? href.match(/[?&]cid=(\d+)/);
+  if (id) return id[1].toLowerCase();
+  return href.split("?")[0].replace(/\/@[^/]+/, "").toLowerCase();
+}
 async function launchBrowser(headless, proxy) {
   let lastErr;
-  const base = { headless };
+  const base = { headless, handleSIGINT: false };
   if (proxy) base.proxy = { server: proxy };
   for (const channel of ["chrome", "msedge"]) {
     try {
@@ -828,7 +822,7 @@ async function extractDetail(page, fields, fallbackName) {
   const text = async (sel) => {
     const loc = page.locator(sel).first();
     if (await loc.count()) {
-      const t = (await loc.innerText().catch(() => "")).trim();
+      const t = (await loc.innerText({ timeout: 2e3 }).catch(() => "")).trim();
       return t || void 0;
     }
     return void 0;
@@ -836,7 +830,7 @@ async function extractDetail(page, fields, fallbackName) {
   const aria = async (sel) => {
     const loc = page.locator(sel).first();
     if (await loc.count()) {
-      return await loc.getAttribute("aria-label").catch(() => null) ?? void 0;
+      return await loc.getAttribute("aria-label", { timeout: 2e3 }).catch(() => null) ?? void 0;
     }
     return void 0;
   };
@@ -854,14 +848,14 @@ async function extractDetail(page, fields, fallbackName) {
     const box = page.locator("div.F7nice").first();
     if (await box.count()) {
       if (fields.has("rating")) {
-        const rt = await box.locator('span[aria-hidden="true"]').first().innerText().catch(() => "");
+        const rt = await box.locator('span[aria-hidden="true"]').first().innerText({ timeout: 1500 }).catch(() => "");
         lead.rating = parseRating(rt);
       }
       if (fields.has("reviews")) {
-        const rv = await box.locator('span[aria-label*="review"]').first().getAttribute("aria-label").catch(() => null);
+        const rv = await box.locator('span[aria-label*="review"]').first().getAttribute("aria-label", { timeout: 1500 }).catch(() => null);
         let count = parseReviewCount(rv);
         if (count === void 0) {
-          const boxText = await box.innerText().catch(() => "");
+          const boxText = await box.innerText({ timeout: 1500 }).catch(() => "");
           const m = boxText.match(/\(([\d.,\s]+)\)/);
           if (m) count = parseReviewCount(m[1]);
         }
@@ -878,7 +872,7 @@ async function extractDetail(page, fields, fallbackName) {
   if (fields.has("website")) {
     const site = page.locator('a[data-item-id="authority"]').first();
     if (await site.count()) {
-      lead.website = await site.getAttribute("href").catch(() => null) ?? void 0;
+      lead.website = await site.getAttribute("href", { timeout: 2e3 }).catch(() => null) ?? void 0;
     }
   }
   if (fields.has("priceLevel")) {
@@ -934,6 +928,7 @@ async function scrapeLeads(opts) {
   const near = opts.near;
   const collect = new Set(fields);
   if (wantEnrich) collect.add("website");
+  if (opts.filters?.hasWebsite || opts.filters?.noWebsite || opts.filters?.hasContact) collect.add("website");
   if (near) {
     collect.add("latitude");
     collect.add("longitude");
@@ -949,6 +944,7 @@ async function scrapeLeads(opts) {
       locale
     });
     const page = await context.newPage();
+    page.setDefaultTimeout(5e3);
     const urlOpts = { hl: locale };
     if (opts.region) urlOpts.gl = opts.region;
     if (near) urlOpts.center = { lat: near.lat, lng: near.lng, zoom: zoomForRadius(opts.radiusM ?? opts.zoomRadiusM ?? 2e3, near.lat) };
@@ -976,6 +972,19 @@ async function scrapeLeads(opts) {
       onProgress?.("no listings found (Google may have shown a CAPTCHA or an empty result).");
       return [];
     }
+    {
+      const seen = /* @__PURE__ */ new Set();
+      const uniq = cards.filter((card) => {
+        const k = placeKey(card.href);
+        if (seen.has(k)) return false;
+        seen.add(k);
+        return true;
+      });
+      if (uniq.length !== cards.length) {
+        onProgress?.(`${cards.length - uniq.length} listing${cards.length - uniq.length === 1 ? "" : "s"} shown twice in the feed \u2014 opening each place once.`);
+        cards.splice(0, cards.length, ...uniq);
+      }
+    }
     if (opts.skipListing) {
       const all = cards;
       const before = all.length;
@@ -992,9 +1001,87 @@ async function scrapeLeads(opts) {
       }
       if (all.length === 0) return [];
     }
-    let leads = [];
+    const dedupeBy = opts.dedupe ?? "smart";
+    const seenKeys = /* @__PURE__ */ new Set();
+    const accepted = [];
+    const order = /* @__PURE__ */ new Map();
+    const socialFields = ENRICHED_FIELDS.filter((f) => f !== "email");
+    const concurrency = Math.max(1, Math.trunc(opts.concurrency ?? 3));
+    let inflight = 0;
+    let enriched = 0;
+    const waiters = [];
+    const tasks = [];
+    const settleOne = () => new Promise((res) => waiters.push(res));
+    const finish = async (lead) => {
+      if ((opts.cleanUrls ?? true) && lead.website) lead.website = cleanWebsite(lead.website);
+      if (near && typeof lead.latitude === "number" && typeof lead.longitude === "number") {
+        const m = haversineMeters(near, { lat: lead.latitude, lng: lead.longitude });
+        lead.distanceKm = Math.round(m / 1e3 * 100) / 100;
+      }
+      if (near && opts.radiusM !== void 0 && !(lead.distanceKm !== void 0 && lead.distanceKm * 1e3 <= opts.radiusM)) return;
+      const key = dedupeKey(lead, dedupeBy);
+      if (key !== void 0) {
+        if (seenKeys.has(key)) return;
+        seenKeys.add(key);
+      }
+      if (wantEnrich && lead.website && !overBudget() && !signal?.aborted) {
+        onProgress?.(`enriching ${++enriched}: ${lead.name ?? lead.website}\u2026`);
+        try {
+          const c2 = await enrichContacts(lead.website);
+          if (fields.has("email") && c2.email) lead.email = c2.email;
+          for (const f of socialFields) {
+            const v = c2[f];
+            if (fields.has(f) && v) lead[f] = v;
+          }
+        } catch {
+        }
+      }
+      if (wantVerify && lead.email && !signal?.aborted) {
+        try {
+          await verifyEmails([lead], { concurrency: 1 });
+        } catch {
+        }
+      }
+      if (opts.country && fields.has("phone") && lead.phone) lead.phone = normalizePhone(lead.phone, opts.country);
+      if (opts.filters && filterLeads([lead], opts.filters).length === 0) return;
+      if (!fields.has("website")) delete lead.website;
+      if (wantVerify && !fields.has("emailStatus")) delete lead.emailStatus;
+      if (near) {
+        if (!fields.has("latitude")) delete lead.latitude;
+        if (!fields.has("longitude")) delete lead.longitude;
+        if (!fields.has("distanceKm")) delete lead.distanceKm;
+      }
+      accepted.push(lead);
+      try {
+        opts.onResult?.(lead);
+      } catch {
+      }
+    };
+    const schedule = async (lead, index) => {
+      order.set(lead, index);
+      while (inflight >= concurrency) await settleOne();
+      inflight++;
+      tasks.push(finish(lead).catch(() => {
+      }).finally(() => {
+        inflight--;
+        waiters.shift()?.();
+      }));
+    };
+    const wantMore = async () => {
+      if (!opts.remaining) return true;
+      for (; ; ) {
+        const left = opts.remaining();
+        if (left <= 0) return false;
+        if (left - inflight > 0) return true;
+        if (inflight === 0) return true;
+        await settleOne();
+      }
+    };
+    let read = 0;
     if (!wantDetails) {
-      leads = cards.map((c2) => {
+      for (let i = 0; i < cards.length; i++) {
+        if (signal?.aborted || !await wantMore()) break;
+        const c2 = cards[i];
         const lead = {};
         if (collect.has("name")) lead.name = c2.name;
         if (collect.has("mapsUrl")) lead.mapsUrl = c2.href;
@@ -1003,17 +1090,16 @@ async function scrapeLeads(opts) {
           if (collect.has("latitude")) lead.latitude = geo.latitude;
           if (collect.has("longitude")) lead.longitude = geo.longitude;
         }
-        return lead;
-      });
-      for (const lead of leads) {
+        read++;
         try {
           onLead?.(lead);
         } catch {
         }
+        await schedule(lead, i);
       }
     } else {
       for (let i = 0; i < cards.length; i++) {
-        if (signal?.aborted || overBudget()) break;
+        if (signal?.aborted || overBudget() || !await wantMore()) break;
         const card = cards[i];
         onProgress?.(`reading ${i + 1}/${cards.length}: ${card.name ?? "listing"}\u2026`);
         let lead;
@@ -1039,84 +1125,20 @@ async function scrapeLeads(opts) {
           }
         }
         if (lead) {
-          leads.push(lead);
+          read++;
           try {
             onLead?.(lead);
           } catch {
           }
+          await schedule(lead, i);
         }
         if (delayMs) await page.waitForTimeout(pauseMs());
       }
     }
-    onProgress?.(`collected ${leads.length} listing${leads.length === 1 ? "" : "s"}.`);
-    if (opts.cleanUrls ?? true) {
-      for (const lead of leads) {
-        if (lead.website) lead.website = cleanWebsite(lead.website);
-      }
-    }
-    if (near) {
-      for (const lead of leads) {
-        if (typeof lead.latitude === "number" && typeof lead.longitude === "number") {
-          const m = haversineMeters(near, { lat: lead.latitude, lng: lead.longitude });
-          lead.distanceKm = Math.round(m / 1e3 * 100) / 100;
-        }
-      }
-      if (opts.radiusM !== void 0) {
-        const r = opts.radiusM;
-        leads = leads.filter((l) => l.distanceKm !== void 0 && l.distanceKm * 1e3 <= r);
-        onProgress?.(`within ${Math.round(r)} m: ${leads.length} listing${leads.length === 1 ? "" : "s"}.`);
-      }
-    }
-    leads = dedupeLeads(leads, opts.dedupe ?? "website");
-    if (wantEnrich) {
-      const socialFields = ENRICHED_FIELDS.filter((f) => f !== "email");
-      let done = 0;
-      await pool(
-        leads,
-        Math.max(1, Math.trunc(opts.concurrency ?? 3)),
-        async (lead) => {
-          if (overBudget()) return;
-          const site = lead.website;
-          if (site) {
-            onProgress?.(`enriching ${++done}/${leads.length}: ${lead.name ?? site}\u2026`);
-            const c2 = await enrichContacts(site);
-            if (fields.has("email") && c2.email) lead.email = c2.email;
-            for (const f of socialFields) {
-              const v = c2[f];
-              if (fields.has(f) && v) lead[f] = v;
-            }
-          }
-          if (!fields.has("website")) delete lead.website;
-        },
-        signal
-      );
-    }
-    if (wantVerify && !signal?.aborted) {
-      onProgress?.("verifying email domains\u2026");
-      const vOpts = {
-        concurrency: Math.max(1, Math.trunc(opts.concurrency ?? 5))
-      };
-      if (onProgress) vOpts.onProgress = (m) => onProgress(m);
-      await verifyEmails(leads, vOpts);
-    }
-    if (opts.country && fields.has("phone")) {
-      for (const lead of leads) {
-        if (lead.phone) lead.phone = normalizePhone(lead.phone, opts.country);
-      }
-    }
-    if (opts.filters) leads = filterLeads(leads, opts.filters);
+    await Promise.all(tasks);
+    onProgress?.(`read ${read} listing${read === 1 ? "" : "s"}.`);
+    let leads = accepted.sort((a, b) => (order.get(a) ?? 0) - (order.get(b) ?? 0));
     if (opts.sort) leads = sortLeads(leads, opts.sort, opts.sortDir);
-    if (wantVerify && !fields.has("emailStatus")) for (const l of leads) delete l.emailStatus;
-    if (near) {
-      const keepLat = fields.has("latitude");
-      const keepLng = fields.has("longitude");
-      const keepDist = fields.has("distanceKm");
-      for (const l of leads) {
-        if (!keepLat) delete l.latitude;
-        if (!keepLng) delete l.longitude;
-        if (!keepDist) delete l.distanceKm;
-      }
-    }
     onProgress?.(`collected ${leads.length} lead${leads.length === 1 ? "" : "s"}.`);
     return leads;
   } finally {
@@ -1146,8 +1168,29 @@ async function searchLeadsBatch(queries, opts = {}) {
   void _q;
   let merged = seedLeads ? [...seedLeads] : [];
   const seenDedupe = shared.dedupe ?? "website";
+  const userOnResult = shared.onResult;
+  const userRemaining = shared.remaining;
+  const liveKeys = /* @__PURE__ */ new Set();
+  for (const l of merged) {
+    const k = dedupeKey(l, seenDedupe);
+    if (k !== void 0) liveKeys.add(k);
+  }
+  let live = merged.length;
+  const onResult = (lead) => {
+    const k = dedupeKey(lead, seenDedupe);
+    if (k !== void 0) {
+      if (liveKeys.has(k)) return;
+      liveKeys.add(k);
+    }
+    live++;
+    try {
+      userOnResult?.(lead);
+    } catch {
+    }
+  };
+  const remaining = () => Math.min(total !== void 0 && total > 0 ? total - live : Infinity, userRemaining ? userRemaining() : Infinity);
   for (let i = 0; i < queries.length; i++) {
-    if (signal?.aborted) break;
+    if (signal?.aborted || remaining() <= 0) break;
     const q = queries[i];
     const label = (() => {
       try {
@@ -1170,6 +1213,8 @@ async function searchLeadsBatch(queries, opts = {}) {
       ...q.area ? { area: q.area } : {}
     };
     delete subOpts.sort;
+    subOpts.onResult = onResult;
+    if (userRemaining || total !== void 0 && total > 0) subOpts.remaining = remaining;
     if (signal) subOpts.signal = signal;
     if (onProgress) subOpts.onProgress = (m) => onProgress(`  ${m}`);
     try {
@@ -1189,16 +1234,18 @@ async function searchLeadsBatch(queries, opts = {}) {
 
 // src/config.ts
 async function runConfig(config, hooks = {}) {
-  const { searches, filters, total, out, format, append, sheet, ...shared } = config;
+  const { searches, filters, total, out, format, append, sheet, push, ...shared } = config;
   void out;
   void format;
   void append;
   void sheet;
+  void push;
   const opts = { ...shared };
   if (filters) opts.filters = filters;
   if (total !== void 0) opts.total = total;
   if (hooks.onProgress) opts.onProgress = hooks.onProgress;
   if (hooks.signal) opts.signal = hooks.signal;
+  if (hooks.onResult) opts.onResult = hooks.onResult;
   if (hooks.skip) opts.skip = hooks.skip;
   if (hooks.seedLeads) opts.seedLeads = hooks.seedLeads;
   if (hooks.onQueryDone) opts.onQueryDone = hooks.onQueryDone;
@@ -1210,6 +1257,12 @@ function assertConfig(value) {
   if (!Array.isArray(searches) || searches.length === 0) {
     throw new Error('Config needs a non-empty "searches" array, e.g. [{ "type": "cafes", "city": "Kathmandu" }].');
   }
+  const push = value.push;
+  if (push !== void 0) {
+    if (!push || typeof push !== "object" || Array.isArray(push)) throw new Error('Config "push" must be an object: { "url": "https://\u2026", "token": "\u2026" }.');
+    if (push.url !== void 0 && typeof push.url !== "string") throw new Error('Config "push.url" must be a string.');
+    if (push.token !== void 0 && typeof push.token !== "string") throw new Error('Config "push.token" must be a string.');
+  }
 }
 
 // src/convert.ts
@@ -1430,6 +1483,151 @@ function formatSummary(s) {
   return lines.join("\n");
 }
 
+// src/live.ts
+import { appendFileSync, closeSync, existsSync as existsSync2, fstatSync, openSync, renameSync as renameSync2, writeFileSync as writeFileSync2, writeSync } from "fs";
+import { stringify as csvStringify3 } from "@lacspace/csv";
+var pick = (lead, fields) => {
+  const o = {};
+  for (const f of fields) if (lead[f] !== void 0) o[f] = lead[f];
+  return o;
+};
+function createLiveWriter(opts) {
+  const { file, format, fields } = opts;
+  const by = opts.dedupe ?? "smart";
+  const toStdout = file === "-" || !!opts.stdout;
+  const out = opts.stdout ?? { write: (c2) => process.stdout.write(c2) };
+  if (toStdout && (format === "json" || format === "xlsx")) throw new Error(`live output to stdout needs csv or ndjson, not ${format}`);
+  const rows = [];
+  const keys = /* @__PURE__ */ new Set();
+  let added = 0;
+  let failed = false;
+  let dirty = false;
+  let jsonFd;
+  const warn = (err) => {
+    if (!failed) opts.onWriteError?.(err);
+    failed = true;
+    dirty = true;
+  };
+  const atomic = (data) => {
+    const tmp = `${file}.tmp`;
+    writeFileSync2(tmp, data);
+    renameSync2(tmp, file);
+  };
+  const csvLine = (lead) => csvStringify3(toRows([lead], fields), { header: false, escapeFormulas: true });
+  const csvHeader = () => csvStringify3([toRows([{}], fields)[0]], { escapeFormulas: true }).split(/\r?\n/)[0] + "\n";
+  const nl = (s) => s.endsWith("\n") ? s : s + "\n";
+  const rewrite = (list) => {
+    const { data, binary } = serialize([...list], format, fields, opts.sheetName ? { sheetName: opts.sheetName } : {});
+    if (format === "csv" && !list.length) atomic(csvHeader());
+    else atomic(binary ? Buffer.from(data) : format === "json" ? data : nl(data));
+  };
+  const jsonAppend = (lead) => {
+    jsonFd ??= openSync(file, "r+");
+    const size = fstatSync(jsonFd).size;
+    const body = JSON.stringify(pick(lead, fields), null, 2).replace(/^/gm, "  ");
+    const chunk = (rows.length === 1 ? "\n" : ",\n") + body + "\n]";
+    writeSync(jsonFd, chunk, Math.max(1, size - (rows.length === 1 ? 1 : 2)));
+  };
+  const start = () => {
+    for (const l of opts.seed ?? []) {
+      const k = dedupeKey(l, by);
+      if (k !== void 0) keys.add(k);
+      rows.push(l);
+    }
+    if (toStdout) {
+      if (format === "csv") out.write(csvHeader());
+      return;
+    }
+    try {
+      if (format === "json" && !rows.length) atomic("[]");
+      else rewrite(rows);
+    } catch (e) {
+      warn(e);
+    }
+  };
+  const write = (lead) => {
+    if (toStdout) {
+      out.write(format === "csv" ? nl(csvLine(lead)) : JSON.stringify(pick(lead, fields)) + "\n");
+      return;
+    }
+    if (dirty) {
+      try {
+        if (jsonFd !== void 0) {
+          closeSync(jsonFd);
+          jsonFd = void 0;
+        }
+        rewrite(rows);
+        dirty = false;
+      } catch (e) {
+        warn(e);
+      }
+      return;
+    }
+    try {
+      if (format === "csv") appendFileSync(file, nl(csvLine(lead)));
+      else if (format === "ndjson") appendFileSync(file, JSON.stringify(pick(lead, fields)) + "\n");
+      else if (format === "json") {
+        if (rows.length > 1 && !existsSync2(file)) throw new Error("output file disappeared");
+        jsonAppend(lead);
+      } else rewrite(rows);
+    } catch (e) {
+      warn(e);
+    }
+  };
+  start();
+  return {
+    add(lead) {
+      const k = dedupeKey(lead, by);
+      if (k !== void 0) {
+        if (keys.has(k)) return false;
+        keys.add(k);
+      }
+      rows.push(lead);
+      added++;
+      write(lead);
+      return true;
+    },
+    get count() {
+      return rows.length;
+    },
+    get added() {
+      return added;
+    },
+    get leads() {
+      return rows;
+    },
+    flush() {
+      if (toStdout || !dirty) return;
+      try {
+        if (jsonFd !== void 0) {
+          closeSync(jsonFd);
+          jsonFd = void 0;
+        }
+        rewrite(rows);
+        dirty = false;
+      } catch (e) {
+        warn(e);
+      }
+    },
+    finish(final) {
+      if (jsonFd !== void 0) {
+        try {
+          closeSync(jsonFd);
+        } catch {
+        }
+        jsonFd = void 0;
+      }
+      if (toStdout) return;
+      try {
+        rewrite(final ?? rows);
+        dirty = false;
+      } catch (e) {
+        warn(e);
+      }
+    }
+  };
+}
+
 // src/pipe.ts
 function leadDomain(website) {
   if (!website) return void 0;
@@ -1463,6 +1661,262 @@ function leadsToEnrichInput(leads) {
   return out;
 }
 
+// src/push.ts
+var VERSION = "1.9.0";
+var PUSH_TOKEN_ENV = "LACSPACE_LEADS_PUSH_TOKEN";
+var LOCAL_HOSTS = /* @__PURE__ */ new Set(["localhost", "127.0.0.1", "[::1]"]);
+function validatePushUrl(raw) {
+  const s = (raw ?? "").trim();
+  if (!s) throw new Error("--push needs a URL, e.g. --push https://api.example.com/leads");
+  let u;
+  try {
+    u = new URL(s);
+  } catch {
+    throw new Error(`--push URL is not valid: "${maskUrl(s)}"`);
+  }
+  if (u.protocol === "https:") return u;
+  if (u.protocol === "http:" && LOCAL_HOSTS.has(u.hostname.toLowerCase())) return u;
+  if (u.protocol === "http:") throw new Error(`--push must use https:// (plain http is only allowed for localhost, 127.0.0.1 or [::1]): ${maskUrl(s)}`);
+  throw new Error(`--push must be an https:// URL, not ${u.protocol}`);
+}
+function maskUrl(raw) {
+  try {
+    const u = new URL(raw);
+    return `${u.protocol}//${u.host}${u.pathname}${u.search ? "?\u2026" : ""}`;
+  } catch {
+    return String(raw).replace(/\/\/[^@/]+@/, "//***@").replace(/\?.*$/, "?\u2026");
+  }
+}
+function resolvePush(input) {
+  const url = input.flagUrl ?? input.config?.url;
+  if (url === void 0) return void 0;
+  const token = input.flagToken || input.config?.token || input.env?.[PUSH_TOKEN_ENV] || void 0;
+  return token ? { url, token } : { url };
+}
+function parseRetryAfter(value, capMs = 6e4, now = Date.now()) {
+  if (value == null) return void 0;
+  const v = value.trim();
+  if (!v) return void 0;
+  let ms;
+  if (/^\d+(\.\d+)?$/.test(v)) ms = parseFloat(v) * 1e3;
+  else {
+    const t = Date.parse(v);
+    if (Number.isNaN(t)) return void 0;
+    ms = t - now;
+  }
+  return Math.min(Math.max(0, ms), capMs);
+}
+function formatPushSummary(s) {
+  const bits = [`sent ${s.sent} lead${s.sent === 1 ? "" : "s"} in ${s.batches} batch${s.batches === 1 ? "" : "es"}`, `failed ${s.failed}`];
+  if (s.dropped) bits.push(`dropped ${s.dropped} (queue full)`);
+  bits.push(s.rejected ? "REJECTED (401/403)" : "not rejected");
+  return `push: ${bits.join(", ")}`;
+}
+var randomId = () => {
+  const c2 = globalThis.crypto;
+  if (c2?.randomUUID) return c2.randomUUID();
+  const h = (n) => Array.from({ length: n }, () => Math.floor(Math.random() * 16).toString(16)).join("");
+  return `${h(8)}-${h(4)}-4${h(3)}-${"89ab"[Math.floor(Math.random() * 4)]}${h(3)}-${h(12)}`;
+};
+function createPusher(opts) {
+  const url = validatePushUrl(opts.url).toString();
+  const doFetch = opts.fetch ?? globalThis.fetch;
+  const batchSize = Math.max(1, opts.batchSize ?? 10);
+  const intervalMs = Math.max(1, opts.intervalMs ?? 3e3);
+  const maxQueue = Math.max(1, opts.maxQueue ?? 2e3);
+  const maxBatch = Math.max(batchSize, opts.maxBatch ?? 500);
+  const timeoutMs = opts.timeoutMs ?? 15e3;
+  const delays = opts.retryDelaysMs ?? [1e3, 3e3, 9e3];
+  const maxRetryAfterMs = opts.maxRetryAfterMs ?? 6e4;
+  const warn = (m) => {
+    try {
+      opts.onWarn?.(m);
+    } catch {
+    }
+  };
+  const run = opts.run ?? randomId();
+  const s = opts.search ?? {};
+  const search = {
+    type: s.type || null,
+    city: s.city || null,
+    area: s.area || null,
+    target: typeof s.target === "number" && Number.isFinite(s.target) ? s.target : null
+  };
+  const headers = {
+    "Content-Type": "application/json",
+    "User-Agent": `lacspace-leads/${VERSION}`
+  };
+  if (opts.token) headers.Authorization = `Bearer ${opts.token}`;
+  const pending = [];
+  const st = { sent: 0, batches: 0, failed: 0, dropped: 0, rejected: false, doneSent: false };
+  let seq = 0;
+  let timer;
+  let due = false;
+  let finishing = false;
+  let finished = false;
+  let sending;
+  let warnedDrop = false;
+  const warned4xx = /* @__PURE__ */ new Set();
+  const stop = new AbortController();
+  const sleep = (ms) => new Promise((res) => {
+    if (stop.signal.aborted) return res();
+    const t = setTimeout(done, ms);
+    function done() {
+      clearTimeout(t);
+      stop.signal.removeEventListener("abort", done);
+      res();
+    }
+    stop.signal.addEventListener("abort", done);
+  });
+  const post = async (payload) => {
+    const body = JSON.stringify(payload);
+    for (let attempt = 0; ; attempt++) {
+      if (stop.signal.aborted) return "stopped";
+      const ac = new AbortController();
+      const onStop = () => ac.abort();
+      stop.signal.addEventListener("abort", onStop);
+      const to = setTimeout(() => ac.abort(), timeoutMs);
+      let status = 0;
+      let retryAfter = null;
+      try {
+        const res = await doFetch(url, { method: "POST", headers, body, signal: ac.signal });
+        status = res.status;
+        retryAfter = res.headers.get("retry-after");
+        try {
+          await res.arrayBuffer();
+        } catch {
+        }
+      } catch {
+        status = 0;
+      } finally {
+        clearTimeout(to);
+        stop.signal.removeEventListener("abort", onStop);
+      }
+      if (stop.signal.aborted) return status >= 200 && status < 300 ? "ok" : "stopped";
+      if (status >= 200 && status < 300) return "ok";
+      if (status === 401 || status === 403) return "rejected";
+      const retryable = status === 0 || status === 429 || status >= 500;
+      if (!retryable) {
+        if (!warned4xx.has(status)) {
+          warned4xx.add(status);
+          warn(`push: endpoint answered HTTP ${status}; dropping that batch and carrying on`);
+        }
+        return "dropped";
+      }
+      if (attempt >= delays.length) return "failed";
+      let wait = delays[attempt] ?? 1e3;
+      if (status === 429) wait = parseRetryAfter(retryAfter, maxRetryAfterMs) ?? wait;
+      await sleep(wait);
+    }
+  };
+  const reject = (lost) => {
+    st.rejected = true;
+    st.failed += lost + pending.length;
+    pending.length = 0;
+    if (timer) {
+      clearTimeout(timer);
+      timer = void 0;
+    }
+    warn(`push rejected: token invalid or expired, leads are still being saved to ${opts.file ?? "the output file"}`);
+  };
+  const sendLeads = async (leads) => {
+    const outcome = await post({ leads, search, run, seq: ++seq, done: false });
+    if (outcome === "ok") {
+      st.sent += leads.length;
+      st.batches++;
+      return;
+    }
+    if (outcome === "rejected") {
+      reject(leads.length);
+      return;
+    }
+    st.failed += leads.length;
+    if (outcome === "failed") warn(`push: a batch of ${leads.length} lead${leads.length === 1 ? "" : "s"} could not be delivered after retries (still in the file)`);
+  };
+  const schedule = () => {
+    if (timer || !pending.length || st.rejected || finishing) return;
+    timer = setTimeout(() => {
+      timer = void 0;
+      due = true;
+      void drain();
+    }, intervalMs);
+    timer.unref?.();
+  };
+  const drain = () => {
+    if (sending) return sending;
+    sending = (async () => {
+      try {
+        while (!st.rejected && !stop.signal.aborted && pending.length && (due || finishing || pending.length >= batchSize)) {
+          due = false;
+          if (timer) {
+            clearTimeout(timer);
+            timer = void 0;
+          }
+          await sendLeads(pending.splice(0, maxBatch));
+        }
+      } catch {
+      } finally {
+        sending = void 0;
+      }
+      schedule();
+    })();
+    return sending;
+  };
+  const snapshot = () => ({ ...st, pending: pending.length });
+  return {
+    push(lead) {
+      if (st.rejected || finished || stop.signal.aborted) return;
+      if (pending.length >= maxQueue) {
+        st.dropped++;
+        if (!warnedDrop) {
+          warnedDrop = true;
+          warn(`push: the endpoint is too slow, ${maxQueue} leads are already waiting; extra leads are not pushed (they are still in the file)`);
+        }
+        return;
+      }
+      pending.push(lead);
+      if (pending.length >= batchSize) void drain();
+      else schedule();
+    },
+    async finish(stats, fopts) {
+      if (finished) return snapshot();
+      finishing = true;
+      if (timer) {
+        clearTimeout(timer);
+        timer = void 0;
+      }
+      const limit = fopts?.timeoutMs ?? opts.finishTimeoutMs ?? 5e3;
+      let deadline;
+      const work = (async () => {
+        await drain();
+        await drain();
+        if (st.rejected || stop.signal.aborted) return;
+        const payload = { leads: [], search, run, seq: ++seq, done: true };
+        if (stats) payload.stats = stats;
+        const outcome = await post(payload);
+        if (outcome === "ok") st.doneSent = true;
+        else if (outcome === "rejected") reject(0);
+      })();
+      await Promise.race([
+        work.catch(() => void 0),
+        new Promise((res) => {
+          deadline = setTimeout(res, limit);
+        })
+      ]);
+      if (deadline) clearTimeout(deadline);
+      stop.abort();
+      await Promise.race([work.catch(() => void 0), new Promise((r) => setTimeout(r, 50))]);
+      if (pending.length) {
+        st.failed += pending.length;
+        pending.length = 0;
+      }
+      finished = true;
+      return snapshot();
+    },
+    stats: snapshot
+  };
+}
+
 // src/sweep.ts
 var MAX_PER_SEARCH = 120;
 var MIN_PER_STEP = 40;
@@ -1531,8 +1985,26 @@ async function sweepLeads(opts) {
     stats.unique = collected.length;
     return collected.length - before;
   };
-  const enough = () => collected.length >= want;
-  const stepLimit = () => Math.min(cap, Math.max(MIN_PER_STEP, (want - collected.length) * 2));
+  const userOnResult = shared.onResult;
+  const userRemaining = shared.remaining;
+  const userSkip = shared.skipListing;
+  const liveKeys = /* @__PURE__ */ new Set();
+  let live = 0;
+  const onResult = (lead) => {
+    const k = dedupeKey(lead, dedupeBy);
+    if (k !== void 0) {
+      if (liveKeys.has(k)) return;
+      liveKeys.add(k);
+    }
+    live++;
+    try {
+      userOnResult?.(lead);
+    } catch {
+    }
+  };
+  const remaining = () => Math.min(want - Math.max(live, collected.length), userRemaining ? userRemaining() : Infinity);
+  const enough = () => remaining() <= 0;
+  const stepLimit = () => Math.min(cap, Math.max(MIN_PER_STEP, Math.max(0, remaining()) * 2));
   let center = near ? { lat: near.lat, lng: near.lng } : void 0;
   const captureCenter = (c2) => {
     center ??= c2;
@@ -1543,7 +2015,9 @@ async function sweepLeads(opts) {
       ...shared,
       ...step,
       limit: stepLimit(),
-      onCenter: captureCenter
+      onCenter: captureCenter,
+      onResult,
+      remaining
     };
     const found = await scrapeLeads(searchOpts);
     stats.searches++;
@@ -1569,7 +2043,9 @@ async function sweepLeads(opts) {
           limit: stepLimit(),
           near: point,
           onCenter: captureCenter,
-          skipListing
+          skipListing: (l) => skipListing(l) || (userSkip?.(l) ?? false),
+          onResult,
+          remaining
         };
         delete tileOpts.area;
         delete tileOpts.city;
@@ -1667,6 +2143,7 @@ function parseArgs(list) {
     jitter: false,
     resume: false,
     summary: false,
+    live: true,
     yes: false,
     help: false
   };
@@ -1723,10 +2200,14 @@ function parseArgs(list) {
     else if (arg === "--business-status") a.businessStatus = next();
     else if (arg === "--name-exclude" || arg === "--exclude-names") a.nameExclude = next();
     else if (arg === "--resume") a.resume = true;
+    else if (arg === "--no-live") a.live = false;
+    else if (arg === "--live") a.live = true;
     else if (arg === "--summary") a.summary = true;
     else if (arg === "--dedupe-across") a.dedupeAcross = next();
     else if (arg === "--enrich-out") a.enrichOut = next();
     else if (arg === "--config") a.config = next();
+    else if (arg === "--push") a.push = next();
+    else if (arg === "--push-token") a.pushToken = next();
     else if (arg === "--dedupe") a.dedupe = next();
     else if (arg === "--sort") a.sort = next();
     else if (arg === "--desc") a.desc = true;
@@ -1800,8 +2281,8 @@ ${c("bold", "Filters & order")}
       --category <text> Keep only leads whose category/tags contain this text
       --business-status <s>  Keep only this status (operational | closed | temporarily-closed)
       --name-exclude <list>  Drop leads whose name contains any of these terms
-      --dedupe <key>    website | phone | name | smart | none   (default website;
-                        --append uses smart: website\u2192phone\u2192name)
+      --dedupe <key>    website | phone | name | smart | none   (default smart:
+                        same website, else same phone, else same name)
       --dedupe-across <file>  Drop leads already present in an existing master file
       --sort <key>      rating | reviews | name | priceLevel | distance
       --desc / --asc    Sort direction (distance defaults nearest-first)
@@ -1817,7 +2298,19 @@ ${c("bold", "Output")}
       --sheet <name>    Excel sheet name         (default "Leads")
       --summary         Print run stats (rating bands, % with contact, top categories)
       --enrich-out <f>  Also write { name, website, domain } NDJSON for lacspace-enrich
-      --resume          Resume an interrupted city sweep from its checkpoint file
+      --resume          Continue an interrupted run: keeps the rows already in the
+                        output file, skips those listings and fills up to --target
+                        (multi-area sweeps also use their checkpoint file)
+      --no-live         Write the file only at the end. By default every lead is
+                        added to the file the moment it is found (csv/ndjson rows
+                        append, json stays valid, xlsx is rewritten), so stopping
+                        early never loses what was collected
+
+${c("bold", "Push to a CRM / Lacspace Mail")}
+      --push <url>      Also POST finished leads (batches of 10 / every 3s) to this
+                        https endpoint while the file is written as usual
+      --push-token <t>  Bearer token for --push. Prefer the env var
+                        LACSPACE_LEADS_PUSH_TOKEN (shell history can't see it)
 
 ${c("bold", "Runtime")}
       --delay <ms>      Pause between listings    (default 700)
@@ -1845,6 +2338,7 @@ ${c("bold", "Examples")}
   npx lacspace-leads gyms --city Lalitpur --dedupe-across master.csv -o new.csv --append
   npx lacspace-leads clinics --city Pokhara --enrich-out sites.ndjson   # feed lacspace-enrich
   npx lacspace-leads convert leads.json -f xlsx
+  LACSPACE_LEADS_PUSH_TOKEN=\u2026 npx lacspace-leads restaurants --city Kathmandu --target 300 --push https://api.lacspace.com/api/webmail/leads/import
 
 ${c("dim", "Please scrape responsibly: keep volumes small, respect Google's Terms of")}
 ${c("dim", "Service and local data-protection law, and use only public business data.")}
@@ -1858,6 +2352,43 @@ async function prompt(q, fallback = "") {
     rl.close();
   }
 }
+function setupPush(args, config) {
+  const p = resolvePush({ flagUrl: args.push, flagToken: args.pushToken, config: config?.push, env: process.env });
+  if (!p) {
+    if (args.pushToken) log(c("yellow", "  ! --push-token given without --push; ignoring it."));
+    return void 0;
+  }
+  try {
+    validatePushUrl(p.url);
+  } catch (err) {
+    log(c("red", `
+\u2717 ${err.message}
+`));
+    exit(1);
+  }
+  if (args.pushToken) log(c("yellow", "  ! --push-token is visible in shell history and the process list; prefer LACSPACE_LEADS_PUSH_TOKEN."));
+  return p;
+}
+function startPusher(p, file, search) {
+  const s = {};
+  if (search.type) s.type = search.type;
+  if (search.city) s.city = search.city;
+  if (search.area) s.area = search.area;
+  if (search.target !== void 0) s.target = search.target;
+  return createPusher({
+    url: p.url,
+    ...p.token ? { token: p.token } : {},
+    search: s,
+    file,
+    onWarn: (m) => log(c("yellow", `  ! ${m}`))
+  });
+}
+async function endPush(pusher, stats, timeoutMs) {
+  if (!pusher) return;
+  const st = await pusher.finish(stats, timeoutMs !== void 0 ? { timeoutMs } : void 0);
+  log(`  ${st.rejected || st.failed || st.dropped ? c("yellow", "!") : c("green", "\u2714")} ${c("dim", formatPushSummary(st))}`);
+}
+var pushEcho = (p) => `${maskUrl(p.url)}${p.token ? c("dim", " (token ***)") : c("dim", " (no token)")}`;
 async function runConvert(rest) {
   const a = parseArgs(rest);
   const input = rest.find((x) => !x.startsWith("-") && x !== a.format && x !== a.out && x !== a.sheet);
@@ -1913,6 +2444,8 @@ ${c("bold", c("magenta", "\u25C6 lacspace-leads config"))} ${c("dim", "\u2014 ru
     exit(1);
     return;
   }
+  const pushCfg = setupPush(args, config);
+  if (pushCfg) log(`  ${c("dim", "push")}    ${pushEcho(pushCfg)}`);
   log(`  ${c("dim", "searches")} ${config.searches.length}   ${c("dim", "format")} ${format}${config.append ? c("dim", "  (append)") : ""}${args.resume ? c("dim", "  (resume)") : ""}
 `);
   const out = resolve2(args.out ?? config.out ?? defaultFilename("leads-campaign", format));
@@ -1932,15 +2465,28 @@ ${c("bold", c("magenta", "\u25C6 lacspace-leads config"))} ${c("dim", "\u2014 ru
       saveCheckpoint(file, cp);
     };
   }
+  const uniq = (xs) => [...new Set(xs.map((x) => x?.trim()).filter((x) => !!x))].join(", ") || void 0;
+  const pusher = pushCfg ? startPusher(pushCfg, out, {
+    type: uniq(config.searches.map((q) => q.type ?? q.query)),
+    city: uniq(config.searches.map((q) => q.city)),
+    area: uniq(config.searches.map((q) => q.area)),
+    ...config.total !== void 0 ? { target: config.total } : {}
+  }) : void 0;
   const controller = new AbortController();
   const onSig = () => controller.abort();
   process.once("SIGINT", onSig);
   let leads;
   try {
-    leads = await runConfig(config, { signal: controller.signal, onProgress: (m) => log(`  ${c("cyan", "\u25F7")} ${c("dim", m)}`), ...resumeHooks });
+    leads = await runConfig(config, {
+      signal: controller.signal,
+      onProgress: (m) => log(`  ${c("cyan", "\u25F7")} ${c("dim", m)}`),
+      ...pusher ? { onResult: (l) => pusher.push(l) } : {},
+      ...resumeHooks
+    });
   } catch (err) {
     log(c("red", `
 \u2717 ${err.message}`));
+    await endPush(pusher, computeStats([]), 3e3);
     exit(1);
     return;
   } finally {
@@ -1949,10 +2495,11 @@ ${c("bold", c("magenta", "\u25C6 lacspace-leads config"))} ${c("dim", "\u2014 ru
   if (!leads.length) {
     log(c("yellow", "\n  No leads collected.\n"));
     if (cpFile) clearCheckpoint(cpFile);
+    await endPush(pusher, computeStats([]));
     return;
   }
   const fields = config.fields ? normalizeFields(config.fields) : ALL_FIELDS.filter((f) => leads.some((l) => l[f] !== void 0));
-  if (args.dedupeAcross && existsSync2(args.dedupeAcross)) {
+  if (args.dedupeAcross && existsSync3(args.dedupeAcross)) {
     try {
       const master = rowsToLeads(await readRows(args.dedupeAcross));
       const before = leads.length;
@@ -1962,7 +2509,7 @@ ${c("bold", c("magenta", "\u25C6 lacspace-leads config"))} ${c("dim", "\u2014 ru
       log(c("yellow", `  ! couldn't read --dedupe-across (${err.message})`));
     }
   }
-  if ((args.append || config.append) && existsSync2(out)) {
+  if ((args.append || config.append) && existsSync3(out)) {
     try {
       const existing = rowsToLeads(await readRows(out));
       const before = existing.length;
@@ -1976,18 +2523,19 @@ ${c("bold", c("magenta", "\u25C6 lacspace-leads config"))} ${c("dim", "\u2014 ru
     const inputs = leadsToEnrichInput(leads);
     const nd = inputs.map((o) => JSON.stringify(o)).join("\n") + (inputs.length ? "\n" : "");
     const enrichPath = resolve2(args.enrichOut);
-    writeFileSync2(enrichPath, nd);
+    writeFileSync3(enrichPath, nd);
     log(`  ${c("cyan", "\u25F7")} ${c("dim", `wrote ${inputs.length} enrich input${inputs.length === 1 ? "" : "s"} \u2192 ${enrichPath}`)}`);
   }
   const serOpts = {};
   if (args.sheet ?? config.sheet) serOpts.sheetName = args.sheet ?? config.sheet;
   const { data, binary } = serialize(leads, format, fields, serOpts);
-  writeFileSync2(out, binary ? Buffer.from(data) : data);
+  writeFileSync3(out, binary ? Buffer.from(data) : data);
   if (cpFile) clearCheckpoint(cpFile);
   const s = computeStats(leads);
   log(`
   ${c("green", "\u2714")} Saved ${c("bold", String(leads.length))} leads \u2192 ${c("cyan", out)}`);
   log(`    ${c("dim", `${s.withPhone} with a phone \xB7 ${s.withWebsite} with a website \xB7 ${s.withEmail} with an email`)}`);
+  await endPush(pusher, s);
   if (args.summary) {
     log("");
     formatSummary(summarize(leads)).split("\n").forEach((line, i) => {
@@ -2052,6 +2600,7 @@ ${c("bold", c("magenta", "\u25C6 lacspace-leads"))} ${c("dim", "\u2014 Google Ma
     exit(1);
     return;
   }
+  const pushCfg = setupPush(args);
   const nearPoint = args.near ? parseLatLngPair(args.near) : void 0;
   const tileStepM = args.step ? parseDistance(args.step) : void 0;
   if (!args.details && (args.split || args.noWebsite)) {
@@ -2146,6 +2695,7 @@ ${c("bold", c("magenta", "\u25C6 lacspace-leads"))} ${c("dim", "\u2014 Google Ma
   else if (nearPoint) log(`  ${c("dim", "sort")}    distance (nearest first)`);
   if (args.country) log(`  ${c("dim", "phones")}  E.164 for ${args.country}`);
   if (args.proxy) log(`  ${c("dim", "proxy")}   ${args.proxy.replace(/\/\/[^@]+@/, "//***@")}`);
+  if (pushCfg) log(`  ${c("dim", "push")}    ${pushEcho(pushCfg)} ${c("dim", "(the file is written as well)")}`);
   log(`  ${c("dim", "limit")}   ${args.limit}${isBatch ? "/search" : ""}${args.total ? ` (cap ${args.total})` : ""}   ${c("dim", "format")} ${args.format}   ${c("dim", "\u2192")} ${toStdout ? "stdout" : out}${args.append ? c("dim", " (append)") : ""}`);
   if (!args.yes) {
     const ok = await prompt(`
@@ -2158,9 +2708,103 @@ ${c("yellow", "!")} This opens a browser and searches Google Maps. Continue? ${c
   log("");
   const controller = new AbortController();
   const onSig = () => {
+    if (controller.signal.aborted) {
+      writerRef.current?.flush();
+      log(c("yellow", "\n  ! Quit. Rows already written stay in the file; --resume continues from them.\n"));
+      if (pusherRef.current) {
+        const p = pusherRef.current;
+        pusherRef.current = void 0;
+        void endPush(p, computeStats([...writerRef.current?.leads ?? []]), 2e3).finally(() => exit(130));
+        return;
+      }
+      exit(130);
+    }
     controller.abort();
+    log(c("yellow", "\n  ! Stopping \u2014 finishing the leads in hand. Press Ctrl-C again to quit at once (rows already written stay in the file)."));
+  };
+  const writerRef = {};
+  const pusherRef = {};
+  process.on("SIGINT", onSig);
+  let existing = [];
+  if ((args.append || args.resume) && !toStdout && existsSync3(out)) {
+    try {
+      existing = rowsToLeads(await readRows(out));
+    } catch (err) {
+      log(c("yellow", `  ! couldn't read "${out}" (${err.message}); starting it fresh`));
+    }
+  }
+  let master;
+  if (args.dedupeAcross && existsSync3(args.dedupeAcross)) {
+    try {
+      master = rowsToLeads(await readRows(args.dedupeAcross));
+    } catch (err) {
+      log(c("yellow", `  ! couldn't read --dedupe-across "${args.dedupeAcross}" (${err.message}); keeping all`));
+    }
+  }
+  const dedupeBy = args.dedupe ?? "smart";
+  const inMaster = master?.length ? (l) => subtractLeads([l], master, dedupeBy).length === 0 : void 0;
+  const resumeRows = args.resume && !isBatch ? existing : [];
+  if (resumeRows.length) log(`  ${c("cyan", "\u25F7")} ${c("dim", `resuming \u2014 ${resumeRows.length} leads already in ${out}; skipping those listings`)}`);
+  const liveFormat = toStdout ? args.format === "csv" || args.format === "ndjson" : true;
+  let writer;
+  const outExisted = !toStdout && existsSync3(out);
+  const dropEmpty = () => {
+    if (!writer || toStdout) return;
+    if (outExisted) writer.finish([...existing]);
+    else {
+      writer.finish([]);
+      try {
+        unlinkSync2(out);
+      } catch {
+      }
+    }
+  };
+  if (args.live && liveFormat && !(toStdout && args.split)) {
+    try {
+      writer = createLiveWriter({
+        file: out,
+        format: args.format,
+        fields,
+        dedupe: dedupeBy,
+        seed: existing,
+        ...args.sheet ? { sheetName: args.sheet } : {},
+        ...toStdout ? { stdout } : {},
+        onWriteError: (e) => log(c("yellow", `  ! couldn't write ${out} (${e.message}) \u2014 is it open in another app? Rows are kept and written as soon as it's free.`))
+      });
+      writerRef.current = writer;
+      if (!toStdout) log(`  ${c("cyan", "\u25F7")} ${c("dim", `writing live \u2192 ${out}`)}`);
+    } catch (err) {
+      log(c("yellow", `  ! live output off: ${err.message}`));
+    }
+  }
+  const goal = args.target ?? (isBatch ? args.total : void 0) ?? (isBatch ? void 0 : args.limit);
+  const pusher = pushCfg ? startPusher(pushCfg, toStdout ? "stdout" : out, {
+    ...args.type ? { type: args.type } : args.query ? { type: args.query } : {},
+    ...args.city ? { city: args.city } : {},
+    ...args.area ? { area: args.area } : {},
+    ...goal !== void 0 ? { target: goal } : {}
+  }) : void 0;
+  pusherRef.current = pusher;
+  const finishPush = async (list, timeoutMs) => {
+    const p = pusherRef.current;
+    pusherRef.current = void 0;
+    await endPush(p, computeStats(list), timeoutMs);
+  };
+  const startedAt = Date.now();
+  let fresh0 = 0;
+  const onResult = (lead) => {
+    if (inMaster?.(lead)) return;
+    if (writer && !writer.add(lead)) return;
+    pusher?.push(lead);
+    fresh0++;
+    const have = resumeRows.length + fresh0;
+    const mins = (Date.now() - startedAt) / 6e4;
+    const rate = mins > 0.05 ? fresh0 / mins : 0;
+    const left = goal !== void 0 ? Math.max(0, goal - have) : 0;
+    const eta = rate > 0 && left > 0 ? `, ~${Math.ceil(left / rate)} min left` : "";
+    const bits = [lead.phone, lead.website?.replace(/^https?:\/\/(www\.)?/, "").replace(/\/$/, ""), lead.email].filter(Boolean).join(" \xB7 ");
+    log(`  ${c("green", "\u271A")} ${c("bold", goal !== void 0 ? `${have}/${goal}` : String(have))} ${lead.name ?? "(no name)"}${bits ? c("dim", ` \u2014 ${bits}`) : ""}${rate ? c("dim", `  (${rate.toFixed(1)}/min${eta})`) : ""}`);
   };
-  process.once("SIGINT", onSig);
   const opts = {
     type: args.type ?? "",
     query: args.query ?? "",
@@ -2176,10 +2820,17 @@ ${c("yellow", "!")} This opens a browser and searches Google Maps. Continue? ${c
     verifyEmails: args.verifyEmails,
     jitter: args.jitter,
     signal: controller.signal,
-    onProgress: (m) => log(`  ${c("cyan", "\u25F7")} ${c("dim", m)}`)
+    onProgress: (m) => log(`  ${c("cyan", "\u25F7")} ${c("dim", m)}`),
+    onResult
   };
+  if (resumeRows.length) {
+    const names = new Set(resumeRows.map((l) => l.name?.trim().toLowerCase()).filter(Boolean));
+    const urls = new Set(resumeRows.map((l) => l.mapsUrl).filter(Boolean));
+    opts.skipListing = (l) => urls.has(l.href) || !!l.name && names.has(l.name.trim().toLowerCase());
+  }
+  if (args.target !== void 0 && (resumeRows.length || inMaster)) opts.remaining = () => args.target - resumeRows.length - fresh0;
   if (hasFilters) opts.filters = filters;
-  if (args.dedupe) opts.dedupe = args.dedupe;
+  opts.dedupe = dedupeBy;
   if (nearPoint) opts.near = { lat: nearPoint.lat, lng: nearPoint.lng };
   if (radiusM !== void 0) opts.radiusM = radiusM;
   if (args.sort) opts.sort = args.sort;
@@ -2239,13 +2890,25 @@ ${c("yellow", "!")} This opens a browser and searches Google Maps. Continue? ${c
       leads = await scrapeLeads(opts);
     }
   } catch (err) {
+    if (writer && writer.added) {
+      writer.flush();
+      log(c("yellow", `
+  ! ${err.message}`));
+      log(`  ${c("green", "\u2714")} ${c("bold", String(writer.count))} leads are saved in ${c("cyan", out)}. Run the same command with ${c("bold", "--resume")} to continue.
+`);
+      await finishPush([...writer.leads], 3e3);
+      exit(controller.signal.aborted ? 130 : 1);
+      return;
+    }
     log(c("red", `
 \u2717 ${err.message}`));
+    await finishPush([], 3e3);
     exit(1);
     return;
   } finally {
     process.removeListener("SIGINT", onSig);
   }
+  const stoppedEarly = controller.signal.aborted;
   if (sweptShort) {
     log(c("yellow", `
   ! The map ran out of new results at ${leads.length} \u2014 that is everything Google lists here.`));
@@ -2256,44 +2919,39 @@ ${c("yellow", "!")} This opens a browser and searches Google Maps. Continue? ${c
     log(c("dim", `    To really get ${args.limit}, ask for a total: --target ${args.limit} \u2014 it sweeps every area you name, then tiles the map.
 `));
   }
-  if (leads.length === 0) {
+  if (leads.length === 0 && !resumeRows.length) {
     log(c("yellow", "\n  No leads collected. Try a broader area, looser filters, or a smaller --limit.\n"));
+    dropEmpty();
     if (cpFile) clearCheckpoint(cpFile);
+    await finishPush([]);
     return;
   }
-  if (args.dedupeAcross && existsSync2(args.dedupeAcross)) {
-    try {
-      const master = rowsToLeads(await readRows(args.dedupeAcross));
-      const before = leads.length;
-      leads = subtractLeads(leads, master, args.dedupe ?? "smart");
-      log(`  ${c("cyan", "\u25F7")} ${c("dim", `dropped ${before - leads.length} already in ${args.dedupeAcross} \u2192 ${leads.length} new`)}`);
-    } catch (err) {
-      log(c("yellow", `  ! couldn't read --dedupe-across "${args.dedupeAcross}" (${err.message}); keeping all`));
-    }
+  if (master) {
+    const before = leads.length;
+    leads = subtractLeads(leads, master, dedupeBy);
+    log(`  ${c("cyan", "\u25F7")} ${c("dim", `dropped ${before - leads.length} already in ${args.dedupeAcross} \u2192 ${leads.length} new`)}`);
     if (leads.length === 0) {
       log(c("yellow", "\n  Nothing new \u2014 every lead was already in the master file.\n"));
+      dropEmpty();
       if (cpFile) clearCheckpoint(cpFile);
+      await finishPush([]);
       return;
     }
   }
   let fresh = leads.length;
-  if (args.append && !toStdout && existsSync2(out)) {
-    try {
-      const existing = rowsToLeads(await readRows(out));
-      const before = existing.length;
-      const merged = dedupeLeads([...existing, ...leads], args.dedupe ?? "smart");
-      fresh = merged.length - before;
-      log(`  ${c("cyan", "\u25F7")} ${c("dim", `merged with ${before} existing \u2192 ${merged.length} total (${fresh} new)`)}`);
-      leads = merged;
-    } catch (err) {
-      log(c("yellow", `  ! couldn't read "${out}" to append (${err.message}); overwriting instead`));
-    }
+  if ((args.append || resumeRows.length) && !toStdout && existing.length) {
+    const before = existing.length;
+    const merged = dedupeLeads([...existing, ...leads], dedupeBy);
+    fresh = merged.length - before;
+    log(`  ${c("cyan", "\u25F7")} ${c("dim", `merged with ${before} existing \u2192 ${merged.length} total (${fresh} new)`)}`);
+    leads = merged;
+    if (args.target !== void 0 && resumeRows.length) leads = leads.slice(0, Math.max(args.target, before));
   }
   if (args.enrichOut) {
     const inputs = leadsToEnrichInput(leads);
     const nd = inputs.map((o) => JSON.stringify(o)).join("\n") + (inputs.length ? "\n" : "");
     const enrichPath = resolve2(args.enrichOut);
-    writeFileSync2(enrichPath, nd);
+    writeFileSync3(enrichPath, nd);
     log(`  ${c("cyan", "\u25F7")} ${c("dim", `wrote ${inputs.length} enrich input${inputs.length === 1 ? "" : "s"} \u2192 ${enrichPath} (feed to lacspace-enrich)`)}`);
   }
   const printSummary = () => {
@@ -2307,11 +2965,14 @@ ${c("yellow", "!")} This opens a browser and searches Google Maps. Continue? ${c
   if (args.sheet) serOpts.sheetName = args.sheet;
   const { data, binary } = serialize(leads, args.format, fields, serOpts);
   if (toStdout) {
-    stdout.write(binary ? Buffer.from(data) : data);
-    if (!binary) stdout.write("\n");
+    if (!writer) {
+      stdout.write(binary ? Buffer.from(data) : data);
+      if (!binary) stdout.write("\n");
+    }
     log(`
   ${c("green", "\u2714")} ${c("bold", String(leads.length))} leads written to stdout ${c("dim", `(${args.format})`)}
 `);
+    await finishPush(leads);
     printSummary();
     return;
   }
@@ -2328,13 +2989,14 @@ ${c("yellow", "!")} This opens a browser and searches Google Maps. Continue? ${c
       for (const [group, rows] of groups) {
         const file = `${stem}-${groupSlug(group)}${ext}`;
         const part = serialize(rows, args.format, fields, serOpts);
-        writeFileSync2(file, part.binary ? Buffer.from(part.data) : part.data);
+        writeFileSync3(file, part.binary ? Buffer.from(part.data) : part.data);
         log(`  ${c("green", "\u2714")} ${c("bold", String(rows.length))} leads \u2192 ${c("cyan", file)}`);
       }
     }
   }
-  writeFileSync2(out, binary ? Buffer.from(data) : data);
-  if (cpFile) clearCheckpoint(cpFile);
+  if (writer) writer.finish(leads);
+  else writeFileSync3(out, binary ? Buffer.from(data) : data);
+  if (cpFile && !stoppedEarly) clearCheckpoint(cpFile);
   const s = computeStats(leads);
   log(`
   ${c("green", "\u2714")} Saved ${c("bold", String(leads.length))} leads \u2192 ${c("cyan", out)}${args.append && fresh !== leads.length ? c("dim", ` (${fresh} new)`) : ""}`);
@@ -2344,6 +3006,8 @@ ${c("yellow", "!")} This opens a browser and searches Google Maps. Continue? ${c
   if (args.socials) parts.push(`${s.withSocial} with a social link`);
   if (s.avgRating !== void 0) parts.push(`avg \u2605 ${s.avgRating}`);
   log(`    ${c("dim", parts.join(" \xB7 "))}`);
+  if (stoppedEarly) log(c("yellow", `  ! Stopped early. Run the same command with --resume to carry on from these ${leads.length}.`));
+  await finishPush(leads);
   printSummary();
   log("");
 }