fullstackgtm 0.40.0 → 0.42.0

package/dist/connector.js

@@ -227,7 +227,41 @@ export async function applyPatchPlan(connector, plan, options) {
             }
         }
     }
+    // Bulk fast-path: route independent, approved create_record CONTACT ops
+    // through the connector's batch API (batched resolve-first read + batched
+    // writes) instead of one round-trip per record. Only ops that are safe to
+    // batch are eligible — every other op (grouped, needs an override, carries a
+    // company association, conflicted, or any non-create op) stays on the serial
+    // path below, so the safety contract is unchanged. Results are merged in by
+    // id; the serial loop short-circuits anything already resolved here.
+    const batched = new Map();
+    if (connector.applyCreateContactsBatch && !guardFailure) {
+        const eligible = plan.operations.filter((operation) => approved.has(operation.id) &&
+            operation.operation === "create_record" &&
+            operation.objectType === "contact" &&
+            options.valueOverrides?.[operation.id] === undefined &&
+            !requiresHumanInput(operation.afterValue) &&
+            !operation.groupId &&
+            !operation.afterValue?.associateCompanyName &&
+            !conflicts.has(operation.id) &&
+            !irreversibleStale.has(operation.id) &&
+            !(staleByFilter && staleByFilter.has(operation.objectId)));
+        // Only worth the batch machinery for more than a couple of creates.
+        if (eligible.length > 2) {
+            const batchResults = await connector.applyCreateContactsBatch(eligible);
+            for (const result of batchResults)
+                batched.set(result.operationId, result);
+        }
+    }
     for (const operation of plan.operations) {
+        const batchedResult = batched.get(operation.id);
+        if (batchedResult) {
+            results.push(batchedResult);
+            attempted += 1;
+            if (batchedResult.status === "applied")
+                applied += 1;
+            continue;
+        }
         if (!approved.has(operation.id)) {
             results.push({
                 operationId: operation.id,

package/dist/connectors/atsBoards.d.ts

@@ -0,0 +1,60 @@
+/**
+ * ATS job-board adapters for the `signals` layer — the free, no-auth example of
+ * "watch an account for hiring motion." Each public board JSON endpoint turns a
+ * company's board token into a list of open roles; the signals layer maps each
+ * role to a `job` signal whose `quote` is the role title plus a JD snippet that
+ * VERBATIM contains a configured keyword (so the downstream judge/drafter can
+ * gate a why-now on something a human can verify).
+ *
+ * Mirrors the `prospectSources.ts` raw-fetch idiom exactly: zero runtime deps
+ * (global fetch only, injectable for tests), a base-url override per provider,
+ * and a per-request `try { } catch { continue }` so one provider's outage never
+ * sinks a multi-source fetch. No SDK, no key.
+ *
+ * Governance: read-only. These adapters fetch public board JSON and return open
+ * roles. They write nothing — the signals layer (and only with `--save`) is the
+ * one that persists, and it never touches the CRM.
+ */
+export type AtsBoardSource = "greenhouse" | "lever" | "ashby";
+/** One open role, normalized across the three providers. */
+export type AtsJob = {
+    /** Role title, verbatim from the board. */
+    title: string;
+    /**
+     * A short JD snippet. When `keywords` are supplied, this is a window around
+     * the first matching keyword (kept verbatim so the keyword survives into the
+     * evidence quote); otherwise it is the leading slice of the description.
+     */
+    jdSnippet: string;
+    /** Canonical posting URL (the signal's sourceUrl). */
+    url: string;
+    /**
+     * Stable per-role identity within a board (provider id when present, else the
+     * title). Used by the reposted-role heuristic to tell "same role, gone, back"
+     * from "two roles that happen to share a title".
+     */
+    firstSeenKey: string;
+};
+type FetchImpl = typeof fetch;
+/**
+ * Fetch open roles for one board. Network failures (offline, non-2xx, malformed
+ * JSON) yield `[]` rather than throwing, matching the per-source resilience of
+ * the prospect sources — a single board's outage must not abort a watchlist run.
+ */
+export declare function fetchAtsJobs(opts: {
+    source: AtsBoardSource;
+    boardToken: string;
+    accountDomain: string;
+    keywords?: string[];
+    fetchImpl?: FetchImpl;
+    apiBaseUrl?: string;
+}): Promise<AtsJob[]>;
+/**
+ * Pick a verbatim JD snippet. If a keyword matches the description (case-
+ * insensitive), return a window centered on the first match — kept verbatim so
+ * the keyword text survives into the signal quote and the evidence gate holds.
+ * With no keywords (or no match), fall back to the leading slice. Returns "" for
+ * an empty description so the caller can decide whether the role still qualifies.
+ */
+export declare function snippetFor(description: string, keywords: string[]): string;
+export {};

package/dist/connectors/atsBoards.js

@@ -0,0 +1,179 @@
+/**
+ * ATS job-board adapters for the `signals` layer — the free, no-auth example of
+ * "watch an account for hiring motion." Each public board JSON endpoint turns a
+ * company's board token into a list of open roles; the signals layer maps each
+ * role to a `job` signal whose `quote` is the role title plus a JD snippet that
+ * VERBATIM contains a configured keyword (so the downstream judge/drafter can
+ * gate a why-now on something a human can verify).
+ *
+ * Mirrors the `prospectSources.ts` raw-fetch idiom exactly: zero runtime deps
+ * (global fetch only, injectable for tests), a base-url override per provider,
+ * and a per-request `try { } catch { continue }` so one provider's outage never
+ * sinks a multi-source fetch. No SDK, no key.
+ *
+ * Governance: read-only. These adapters fetch public board JSON and return open
+ * roles. They write nothing — the signals layer (and only with `--save`) is the
+ * one that persists, and it never touches the CRM.
+ */
+const DEFAULT_BASE_URLS = {
+    greenhouse: "https://boards-api.greenhouse.io",
+    lever: "https://api.lever.co",
+    ashby: "https://api.ashbyhq.com",
+};
+/** JD snippet length — long enough to carry a verbatim keyword window. */
+const SNIPPET_LEN = 240;
+/**
+ * Fetch open roles for one board. Network failures (offline, non-2xx, malformed
+ * JSON) yield `[]` rather than throwing, matching the per-source resilience of
+ * the prospect sources — a single board's outage must not abort a watchlist run.
+ */
+export async function fetchAtsJobs(opts) {
+    const fetchImpl = opts.fetchImpl ?? fetch;
+    const base = (opts.apiBaseUrl ?? DEFAULT_BASE_URLS[opts.source]).replace(/\/$/, "");
+    const token = opts.boardToken.trim();
+    if (!token)
+        return [];
+    const keywords = opts.keywords ?? [];
+    try {
+        if (opts.source === "greenhouse") {
+            return await fetchGreenhouse(fetchImpl, base, token, keywords);
+        }
+        if (opts.source === "lever") {
+            return await fetchLever(fetchImpl, base, token, keywords);
+        }
+        return await fetchAshby(fetchImpl, base, token, keywords);
+    }
+    catch {
+        // Offline / 5xx / malformed payload: an empty board, never a crash.
+        return [];
+    }
+}
+// ---------------------------------------------------------------------------
+// Greenhouse — GET /v1/boards/<token>/jobs?content=true
+async function fetchGreenhouse(fetchImpl, base, token, keywords) {
+    const response = await fetchImpl(`${base}/v1/boards/${encodeURIComponent(token)}/jobs?content=true`, {
+        headers: { Accept: "application/json" },
+    });
+    if (!response.ok)
+        return [];
+    const data = (await response.json());
+    const out = [];
+    for (const job of data.jobs ?? []) {
+        const title = strOrEmpty(job.title);
+        if (!title)
+            continue;
+        const description = decodeHtmlish(strOrEmpty(job.content));
+        out.push({
+            title,
+            jdSnippet: snippetFor(description, keywords),
+            url: strOrEmpty(job.absolute_url),
+            firstSeenKey: job.id != null ? String(job.id) : title,
+        });
+    }
+    return out;
+}
+// ---------------------------------------------------------------------------
+// Lever — GET /v0/postings/<token>?mode=json (returns a bare array)
+async function fetchLever(fetchImpl, base, token, keywords) {
+    const response = await fetchImpl(`${base}/v0/postings/${encodeURIComponent(token)}?mode=json`, {
+        headers: { Accept: "application/json" },
+    });
+    if (!response.ok)
+        return [];
+    const data = (await response.json());
+    const out = [];
+    for (const posting of Array.isArray(data) ? data : []) {
+        const title = strOrEmpty(posting.text);
+        if (!title)
+            continue;
+        const description = strOrEmpty(posting.descriptionPlain) || decodeHtmlish(strOrEmpty(posting.description));
+        out.push({
+            title,
+            jdSnippet: snippetFor(description, keywords),
+            url: strOrEmpty(posting.hostedUrl),
+            firstSeenKey: strOrEmpty(posting.id) || title,
+        });
+    }
+    return out;
+}
+// ---------------------------------------------------------------------------
+// Ashby — POST /posting-api/job-board/<token> with { jobBoardName }
+async function fetchAshby(fetchImpl, base, token, keywords) {
+    const response = await fetchImpl(`${base}/posting-api/job-board/${encodeURIComponent(token)}`, {
+        method: "POST",
+        headers: { "Content-Type": "application/json", Accept: "application/json" },
+        body: JSON.stringify({ jobBoardName: token, includeCompensation: false }),
+    });
+    if (!response.ok)
+        return [];
+    const data = (await response.json());
+    const out = [];
+    for (const job of data.jobs ?? []) {
+        const title = strOrEmpty(job.title);
+        if (!title)
+            continue;
+        const description = strOrEmpty(job.descriptionPlain) || decodeHtmlish(strOrEmpty(job.descriptionHtml));
+        out.push({
+            title,
+            jdSnippet: snippetFor(description, keywords),
+            url: strOrEmpty(job.jobUrl) || strOrEmpty(job.applyUrl),
+            firstSeenKey: strOrEmpty(job.id) || title,
+        });
+    }
+    return out;
+}
+// ---------------------------------------------------------------------------
+// Snippet selection: a verbatim window around the first matching keyword.
+/**
+ * Pick a verbatim JD snippet. If a keyword matches the description (case-
+ * insensitive), return a window centered on the first match — kept verbatim so
+ * the keyword text survives into the signal quote and the evidence gate holds.
+ * With no keywords (or no match), fall back to the leading slice. Returns "" for
+ * an empty description so the caller can decide whether the role still qualifies.
+ */
+export function snippetFor(description, keywords) {
+    const text = description.trim();
+    if (!text)
+        return "";
+    for (const keyword of keywords) {
+        const needle = keyword.trim();
+        if (!needle)
+            continue;
+        const idx = text.toLowerCase().indexOf(needle.toLowerCase());
+        if (idx === -1)
+            continue;
+        const pad = Math.max(0, Math.floor((SNIPPET_LEN - needle.length) / 2));
+        let start = Math.max(0, idx - pad);
+        let end = Math.min(text.length, idx + needle.length + pad);
+        // Snap to word boundaries so the window doesn't start/end mid-word, but
+        // never past the keyword itself (the verbatim span must stay intact).
+        while (start > 0 && /\S/.test(text[start - 1]) && start < idx)
+            start += 1;
+        while (end < text.length && /\S/.test(text[end]) && end > idx + needle.length)
+            end -= 1;
+        return text.slice(start, end).trim();
+    }
+    return text.slice(0, SNIPPET_LEN).trim();
+}
+/**
+ * Minimal HTML-ish cleanup for board `content`/`description` HTML: drop tags and
+ * decode the handful of entities Greenhouse/Ashby emit. Dependency-free; good
+ * enough to surface a readable, keyword-matchable snippet (the quote does not
+ * need to be byte-perfect HTML, only verbatim text the keyword appears in).
+ */
+function decodeHtmlish(raw) {
+    return raw
+        .replace(/<\s*br\s*\/?\s*>/gi, " ")
+        .replace(/<\/?[^>]+>/g, " ")
+        .replace(/&amp;/g, "&")
+        .replace(/&lt;/g, "<")
+        .replace(/&gt;/g, ">")
+        .replace(/&quot;/g, '"')
+        .replace(/&#39;|&apos;/g, "'")
+        .replace(/&nbsp;/g, " ")
+        .replace(/\s+/g, " ")
+        .trim();
+}
+function strOrEmpty(value) {
+    return typeof value === "string" ? value.trim() : "";
+}

package/dist/connectors/hubspot.js

@@ -555,6 +555,129 @@ export function createHubspotConnector(options) {
             providerData: { id: contactId, created: true },
         };
     }
+    /** Bulk resolve-first lookup: which match values already exist (value→id). */
+    async function searchContactsByValues(property, values) {
+        const found = new Map();
+        for (let i = 0; i < values.length; i += 100) {
+            const chunk = values.slice(i, i + 100);
+            const data = await request(`/crm/v3/objects/contacts/search`, {
+                method: "POST",
+                body: JSON.stringify({
+                    filterGroups: [{ filters: [{ propertyName: property, operator: "IN", values: chunk }] }],
+                    properties: [property],
+                    limit: 100,
+                }),
+            });
+            for (const rec of (data?.results ?? [])) {
+                const v = rec?.properties?.[property];
+                if (typeof v === "string" && rec.id)
+                    found.set(v.toLowerCase(), String(rec.id));
+            }
+        }
+        return found;
+    }
+    /**
+     * Batch create_record for contacts: bulk resolve-first (search IN), then
+     * bulk-create the genuine misses (batch/create, 100/call) — two API calls per
+     * ~100 leads instead of two per lead. On a batch-create rejection (e.g. an
+     * email collision HubSpot 409s the whole batch over), it falls back to
+     * per-record createRecord for that chunk, so one bad row never sinks the rest
+     * and resolve-first is preserved. Returns one result per input op.
+     */
+    async function applyCreateContactsBatch(operations) {
+        const byId = new Map();
+        // Group by the HubSpot search property (matchKey is usually uniform across a
+        // plan, but a mixed plan stays correct this way).
+        const groups = new Map();
+        for (const op of operations) {
+            const matchKey = op.afterValue?.matchKey || "email";
+            const searchProperty = HUBSPOT_DEFAULT_FIELD_MAPPINGS.contacts[matchKey] ?? matchKey;
+            let arr = groups.get(searchProperty);
+            if (!arr)
+                groups.set(searchProperty, (arr = []));
+            arr.push(op);
+        }
+        for (const [searchProperty, ops] of groups) {
+            const wanted = ops
+                .map((op) => String(op.afterValue.matchValue ?? "").trim())
+                .filter(Boolean);
+            const existing = await searchContactsByValues(searchProperty, [...new Set(wanted.map((v) => v.toLowerCase()))]);
+            const toCreate = [];
+            const seenInBatch = new Set();
+            for (const op of ops) {
+                const payload = op.afterValue;
+                const matchKey = payload.matchKey || "email";
+                const matchValue = String(payload.matchValue ?? "").trim();
+                if (!matchValue) {
+                    byId.set(op.id, { operationId: op.id, status: "skipped", detail: "create_record needs a non-empty matchValue to resolve-first." });
+                    continue;
+                }
+                const lower = matchValue.toLowerCase();
+                const dedupeKey = `${matchKey}:${lower}`;
+                const already = createdContactsByMatch.get(dedupeKey);
+                if (already) {
+                    byId.set(op.id, { operationId: op.id, status: "skipped", detail: `Contact ${matchKey}=${matchValue} already created earlier in this run; not duplicating.`, providerData: { id: already, existing: true } });
+                    continue;
+                }
+                const existingId = existing.get(lower);
+                if (existingId) {
+                    createdContactsByMatch.set(dedupeKey, existingId);
+                    byId.set(op.id, { operationId: op.id, status: "skipped", detail: `Contact ${matchKey}=${matchValue} already exists (${existingId}); resolve-first declined to create.`, providerData: { id: existingId, existing: true } });
+                    continue;
+                }
+                if (seenInBatch.has(lower)) {
+                    byId.set(op.id, { operationId: op.id, status: "skipped", detail: `Contact ${matchKey}=${matchValue} duplicated within this batch; not duplicating.` });
+                    continue;
+                }
+                seenInBatch.add(lower);
+                toCreate.push(op);
+            }
+            for (let i = 0; i < toCreate.length; i += 100) {
+                const chunk = toCreate.slice(i, i + 100);
+                const inputs = chunk.map((op) => {
+                    const payload = op.afterValue;
+                    const properties = { ...payload.properties };
+                    if (payload.ownerId && !properties.hubspot_owner_id)
+                        properties.hubspot_owner_id = String(payload.ownerId);
+                    properties.hs_object_source_detail_2 = `fullstackgtm acquire (${op.id})`;
+                    return { properties };
+                });
+                try {
+                    const data = await request(`/crm/v3/objects/contacts/batch/create`, {
+                        method: "POST",
+                        body: JSON.stringify({ inputs }),
+                    });
+                    const created = (data?.results ?? []);
+                    const idByValue = new Map();
+                    for (const rec of created) {
+                        const v = rec?.properties?.[searchProperty];
+                        if (typeof v === "string" && rec.id)
+                            idByValue.set(v.toLowerCase(), String(rec.id));
+                    }
+                    for (const op of chunk) {
+                        const payload = op.afterValue;
+                        const matchKey = payload.matchKey || "email";
+                        const matchValue = String(payload.matchValue).trim();
+                        const id = idByValue.get(matchValue.toLowerCase());
+                        if (id) {
+                            createdContactsByMatch.set(`${matchKey}:${matchValue.toLowerCase()}`, id);
+                            byId.set(op.id, { operationId: op.id, status: "applied", detail: `Created contact ${matchKey}=${matchValue} (${id}).`, providerData: { id, created: true } });
+                        }
+                        else {
+                            // Result didn't echo this value — resolve it per-record to be safe.
+                            byId.set(op.id, await createRecord(op));
+                        }
+                    }
+                }
+                catch {
+                    // Whole-chunk rejection (e.g. a collision). Isolate per record.
+                    for (const op of chunk)
+                        byId.set(op.id, await createRecord(op));
+                }
+            }
+        }
+        return operations.map((op) => byId.get(op.id) ?? { operationId: op.id, status: "skipped", detail: "create_record was not processed." });
+    }
     async function createTask(operation) {
         const associationTypeId = TASK_ASSOCIATION_TYPE_IDS[operation.objectType];
         if (associationTypeId === undefined) {
@@ -801,6 +924,7 @@ export function createHubspotConnector(options) {
         fetchSnapshot,
         fetchChanges,
         applyOperation,
+        applyCreateContactsBatch,
         readField,
     };
 }

package/dist/connectors/prospectSources.d.ts

@@ -56,11 +56,6 @@ export declare function fetchPipe0CrustdataProspects(opts: {
     apiBaseUrl?: string;
     fetchImpl?: FetchImpl;
 }): Promise<Prospect[]>;
-/**
- * Resolve real work emails for people via pipe0's waterfall. Input rows need a
- * full name + a company domain (or name). Returns the prospects with `email`
- * filled where the waterfall found one; rows with no hit are returned unchanged.
- */
 export declare function pipe0ResolveWorkEmails(opts: {
     apiKey: string;
     prospects: Prospect[];
@@ -70,6 +65,11 @@ export declare function pipe0ResolveWorkEmails(opts: {
      *  batch rate-limit (a throttled chunk returns work_email status "failed"
      *  for every row, so one big batch is all-or-nothing). Default 3. */
     chunkSize?: number;
+    /** Chunks resolved in parallel, bounded to respect pipe0's rate limit. Default
+     *  3 — paired with pipe0Post's backoff this cuts wall-clock from O(n) serial
+     *  calls without throttling away coverage (higher defaults tanked the hit-rate
+     *  at scale). */
+    concurrency?: number;
 }): Promise<Prospect[]>;
 /** Bare registrable host from a URL or domain string ("https://www.x.com/a" → "x.com"). */
 export declare function hostFromUrl(url: string | undefined): string | undefined;
@@ -87,6 +87,8 @@ export declare function pipe0ResolveCompanyDomains(opts: {
     apiBaseUrl?: string;
     fetchImpl?: FetchImpl;
     chunkSize?: number;
+    /** Chunks resolved in parallel (bounded). Default 3. */
+    concurrency?: number;
 }): Promise<Prospect[]>;
 /**
  * Stable identity keys for a prospect (prefixed by kind). A match on ANY key

package/dist/connectors/prospectSources.js

@@ -98,44 +98,83 @@ function normalizeLinkedin(value) {
  * full name + a company domain (or name). Returns the prospects with `email`
  * filled where the waterfall found one; rows with no hit are returned unchanged.
  */
+const sleep = (ms) => new Promise((resolve) => setTimeout(resolve, ms));
+/** Run `count` async tasks with at most `limit` in flight. Order-independent. */
+async function runWithConcurrency(count, limit, worker) {
+    const out = new Array(count);
+    let next = 0;
+    const runners = Array.from({ length: Math.max(1, Math.min(limit, count || 1)) }, async () => {
+        for (let i = next++; i < count; i = next++)
+            out[i] = await worker(i);
+    });
+    await Promise.all(runners);
+    return out;
+}
+/**
+ * POST a pipe0 sync run with exponential backoff on transient failure
+ * (throttle/5xx/network). pipe0's waterfall throttles under burst — a 429'd
+ * chunk returns all-failed — so concurrency must be paired with real backoff,
+ * not a single retry, or coverage collapses at scale (a parallel run without
+ * this dropped the work-email hit-rate from ~79% to ~17%). Retries 500ms →
+ * 1s → 2s → 4s (capped) so a throttled chunk lands on a later attempt instead
+ * of being lost.
+ */
+async function pipe0Post(fetchImpl, base, apiKey, payload, maxAttempts = 5) {
+    for (let attempt = 0; attempt < maxAttempts; attempt++) {
+        try {
+            const response = await fetchImpl(`${base}/v1/pipes/run/sync`, {
+                method: "POST",
+                headers: { Authorization: `Bearer ${apiKey}`, "Content-Type": "application/json" },
+                body: JSON.stringify(payload),
+            });
+            if (response.ok)
+                return (await response.json());
+            // non-ok (429/5xx) — fall through to backoff + retry
+        }
+        catch {
+            // network error — fall through to backoff + retry
+        }
+        if (attempt < maxAttempts - 1)
+            await sleep(Math.min(8000, 500 * 2 ** attempt));
+    }
+    return undefined; // still failing after backoff — caller keeps the other chunks
+}
 export async function pipe0ResolveWorkEmails(opts) {
     const fetchImpl = opts.fetchImpl ?? fetch;
     const base = (opts.apiBaseUrl ?? "https://api.pipe0.com").replace(/\/$/, "");
     const chunkSize = Math.max(1, opts.chunkSize ?? 3);
+    const concurrency = Math.max(1, opts.concurrency ?? 3);
     // Only rows with the waterfall's required inputs (name + company_domain|name).
     const resolvable = opts.prospects.filter((p) => p.fullName && (p.companyDomain || p.companyName));
     if (resolvable.length === 0)
         return opts.prospects;
-    const emailByKey = new Map();
-    for (let i = 0; i < resolvable.length; i += chunkSize) {
-        const chunk = resolvable.slice(i, i + chunkSize);
-        const input = chunk.map((p) => ({
+    const chunks = [];
+    for (let i = 0; i < resolvable.length; i += chunkSize)
+        chunks.push(resolvable.slice(i, i + chunkSize));
+    const perChunk = await runWithConcurrency(chunks.length, concurrency, async (ci) => {
+        const input = chunks[ci].map((p) => ({
             name: p.fullName,
             ...(p.companyDomain ? { company_domain: p.companyDomain } : { company_name: p.companyName }),
         }));
-        let body;
-        try {
-            const response = await fetchImpl(`${base}/v1/pipes/run/sync`, {
-                method: "POST",
-                headers: { Authorization: `Bearer ${opts.apiKey}`, "Content-Type": "application/json" },
-                body: JSON.stringify({ pipes: [{ pipe_id: "person:workemail:waterfall@1" }], input }),
-            });
-            if (!response.ok)
-                continue; // throttled/5xx chunk — skip, keep the rest
-            body = (await response.json());
-        }
-        catch {
-            continue; // network hiccup on one chunk must not sink the whole run
-        }
-        for (const recordId of body.order ?? []) {
+        const body = await pipe0Post(fetchImpl, base, opts.apiKey, {
+            pipes: [{ pipe_id: "person:workemail:waterfall@1" }],
+            input,
+        });
+        const entries = [];
+        for (const recordId of body?.order ?? []) {
             const fields = body.records?.[recordId]?.fields ?? {};
             const email = fields.work_email?.status === "completed" ? fieldValue(fields.work_email) : undefined;
             if (email) {
                 const domain = fieldValue(fields.company_domain) ?? fieldValue(fields.company_name);
-                emailByKey.set(personKey(fieldValue(fields.name), domain), email);
+                entries.push([personKey(fieldValue(fields.name), domain), email]);
             }
         }
-    }
+        return entries;
+    });
+    const emailByKey = new Map();
+    for (const entries of perChunk)
+        for (const [k, v] of entries)
+            emailByKey.set(k, v);
     return opts.prospects.map((p) => {
         const email = emailByKey.get(personKey(p.fullName, p.companyDomain ?? p.companyName));
         return email ? { ...p, email } : p;
@@ -169,6 +208,7 @@ export async function pipe0ResolveCompanyDomains(opts) {
     const fetchImpl = opts.fetchImpl ?? fetch;
     const base = (opts.apiBaseUrl ?? "https://api.pipe0.com").replace(/\/$/, "");
     const chunkSize = Math.max(1, opts.chunkSize ?? 5);
+    const concurrency = Math.max(1, opts.concurrency ?? 3);
     const uniqueNames = [
         ...new Set(opts.prospects
             .filter((p) => !p.companyDomain && p.companyName)
@@ -177,33 +217,28 @@ export async function pipe0ResolveCompanyDomains(opts) {
     ];
     if (uniqueNames.length === 0)
         return opts.prospects;
-    const domainByName = new Map();
-    for (let i = 0; i < uniqueNames.length; i += chunkSize) {
-        const chunk = uniqueNames.slice(i, i + chunkSize);
-        try {
-            const response = await fetchImpl(`${base}/v1/pipes/run/sync`, {
-                method: "POST",
-                headers: { Authorization: `Bearer ${opts.apiKey}`, "Content-Type": "application/json" },
-                body: JSON.stringify({
-                    pipes: [{ pipe_id: "company:identity@1" }],
-                    input: chunk.map((company_name) => ({ company_name })),
-                }),
-            });
-            if (!response.ok)
-                continue;
-            const body = (await response.json());
-            for (const recordId of body.order ?? []) {
-                const fields = body.records?.[recordId]?.fields ?? {};
-                const name = fieldValue(fields.company_name) ?? fieldValue(fields.cleaned_company_name);
-                const domain = hostFromUrl(fieldValue(fields.company_website_url));
-                if (name && domain)
-                    domainByName.set(name.trim().toLowerCase(), domain);
-            }
-        }
-        catch {
-            continue;
+    const chunks = [];
+    for (let i = 0; i < uniqueNames.length; i += chunkSize)
+        chunks.push(uniqueNames.slice(i, i + chunkSize));
+    const perChunk = await runWithConcurrency(chunks.length, concurrency, async (ci) => {
+        const body = await pipe0Post(fetchImpl, base, opts.apiKey, {
+            pipes: [{ pipe_id: "company:identity@1" }],
+            input: chunks[ci].map((company_name) => ({ company_name })),
+        });
+        const entries = [];
+        for (const recordId of body?.order ?? []) {
+            const fields = body.records?.[recordId]?.fields ?? {};
+            const name = fieldValue(fields.company_name) ?? fieldValue(fields.cleaned_company_name);
+            const domain = hostFromUrl(fieldValue(fields.company_website_url));
+            if (name && domain)
+                entries.push([name.trim().toLowerCase(), domain]);
         }
-    }
+        return entries;
+    });
+    const domainByName = new Map();
+    for (const entries of perChunk)
+        for (const [k, v] of entries)
+            domainByName.set(k, v);
     return opts.prospects.map((p) => {
         if (p.companyDomain || !p.companyName)
             return p;