linkedin-secret-sauce 0.12.0 → 0.12.2

package/dist/enrichment/providers/construct.js

@@ -10,6 +10,7 @@ exports.createConstructProvider = createConstructProvider;
 const mx_1 = require("../verification/mx");
 const personal_domains_1 = require("../utils/personal-domains");
 const validation_1 = require("../utils/validation");
+const candidate_parser_1 = require("../utils/candidate-parser");
 /**
  * Build all email pattern candidates for a person
  *
@@ -19,11 +20,11 @@ const validation_1 = require("../utils/validation");
  * 3. f.lastname, flastname, etc.
  */
 function buildCandidates(input) {
-    const domain = String(input.domain || '').toLowerCase();
-    const first = (0, validation_1.cleanNamePart)(input.first || '');
-    const last = (0, validation_1.cleanNamePart)(input.last || '');
-    const fl = first ? first[0] : '';
-    const ll = last ? last[0] : '';
+    const domain = String(input.domain || "").toLowerCase();
+    const first = (0, validation_1.cleanNamePart)(input.first || "");
+    const last = (0, validation_1.cleanNamePart)(input.last || "");
+    const fl = first ? first[0] : "";
+    const ll = last ? last[0] : "";
     const locals = [];
     // Simple first name pattern (very common, especially for small companies/startups)
     if (first)
@@ -59,28 +60,6 @@ function buildCandidates(input) {
     }
     return emails;
 }
-/**
- * Extract name components from candidate
- */
-function extractNames(candidate) {
-    const firstName = candidate.firstName ||
-        candidate.first_name ||
-        candidate.first ||
-        candidate.name?.split(' ')?.[0] ||
-        '';
-    const lastName = candidate.lastName ||
-        candidate.last_name ||
-        candidate.last ||
-        candidate.name?.split(' ')?.slice(1).join(' ') ||
-        '';
-    return { first: firstName, last: lastName };
-}
-/**
- * Extract domain from candidate
- */
-function extractDomain(candidate) {
-    return candidate.domain || candidate.companyDomain || candidate.company_domain || '';
-}
 /**
  * Create the construct provider function
  */
@@ -89,8 +68,8 @@ function createConstructProvider(config) {
     const timeoutMs = config?.timeoutMs ?? 5000;
     const smtpVerifyDelayMs = config?.smtpVerifyDelayMs ?? 2000; // Delay between SMTP checks
     async function fetchEmail(candidate) {
-        const { first, last } = extractNames(candidate);
-        const domain = extractDomain(candidate);
+        const { firstName: first, lastName: last } = (0, candidate_parser_1.extractName)(candidate);
+        const { domain } = (0, candidate_parser_1.extractCompany)(candidate);
         // Skip if missing required fields
         if (!first || !domain) {
             return null;
@@ -102,7 +81,9 @@ function createConstructProvider(config) {
         const candidates = buildCandidates({ first, last, domain });
         const max = Math.min(candidates.length, maxAttempts);
         // First, check if domain is catch-all
-        const catchAllResult = await (0, mx_1.checkDomainCatchAll)(domain, { timeoutMs: 10000 });
+        const catchAllResult = await (0, mx_1.checkDomainCatchAll)(domain, {
+            timeoutMs: 10000,
+        });
         const isCatchAll = catchAllResult.isCatchAll;
         // Collect ALL valid email patterns (not just first match)
         const validEmails = [];
@@ -116,7 +97,7 @@ function createConstructProvider(config) {
                 const email = emailsToVerify[i];
                 // If we already found a valid email, skip the rest
                 if (validEmails.length > 0) {
-                    attemptedPatterns.push({ email, status: 'skipped' });
+                    attemptedPatterns.push({ email, status: "skipped" });
                     continue;
                 }
                 // Add delay between checks (except first one)
@@ -124,18 +105,21 @@ function createConstructProvider(config) {
                     await new Promise((resolve) => setTimeout(resolve, smtpVerifyDelayMs));
                 }
                 // Verify single email
-                const results = await (0, mx_1.verifyEmailsExist)([email], { delayMs: 0, timeoutMs });
+                const results = await (0, mx_1.verifyEmailsExist)([email], {
+                    delayMs: 0,
+                    timeoutMs,
+                });
                 const result = results[0];
                 if (result.exists === true) {
                     // Email confirmed to exist!
-                    attemptedPatterns.push({ email, status: 'exists' });
+                    attemptedPatterns.push({ email, status: "exists" });
                     validEmails.push({
                         email: result.email,
                         verified: true,
                         confidence: 95, // High confidence - SMTP verified
                         isCatchAll: false,
                         metadata: {
-                            pattern: result.email.split('@')[0],
+                            pattern: result.email.split("@")[0],
                             mxRecords: catchAllResult.mxRecords,
                             smtpVerified: true,
                             attemptedPatterns, // Include what was tried
@@ -145,10 +129,10 @@ function createConstructProvider(config) {
                     break;
                 }
                 else if (result.exists === false) {
-                    attemptedPatterns.push({ email, status: 'not_found' });
+                    attemptedPatterns.push({ email, status: "not_found" });
                 }
                 else {
-                    attemptedPatterns.push({ email, status: 'unknown' });
+                    attemptedPatterns.push({ email, status: "unknown" });
                 }
             }
             // If no valid email found, include attempted patterns in metadata
@@ -168,7 +152,7 @@ function createConstructProvider(config) {
                         confidence: verification.confidence,
                         isCatchAll: isCatchAll ?? undefined,
                         metadata: {
-                            pattern: email.split('@')[0],
+                            pattern: email.split("@")[0],
                             mxRecords: verification.mxRecords,
                             smtpVerified: false,
                         },
@@ -184,6 +168,6 @@ function createConstructProvider(config) {
         return { emails: validEmails };
     }
     // Mark provider name for orchestrator
-    fetchEmail.__name = 'construct';
+    fetchEmail.__name = "construct";
     return fetchEmail;
 }

package/dist/enrichment/providers/cosiall.d.ts

@@ -0,0 +1,27 @@
+/**
+ * Cosiall Profile Emails Provider
+ *
+ * Lookups against the Cosiall FlexIQ Profile Emails API.
+ * This is FREE and returns all known emails for a LinkedIn profile.
+ *
+ * Lookup priority:
+ * 1. objectUrn (most precise - "urn:li:member:129147375")
+ * 2. linkedInUrl (URL like "https://www.linkedin.com/in/john-doe/")
+ * 3. vanity (username extracted from URL or direct field)
+ */
+import type { EnrichmentCandidate, ProviderMultiResult, ProviderResult } from "../types";
+/**
+ * Cosiall provider configuration
+ * No configuration needed - uses Cosiall API credentials from global config
+ */
+export interface CosiallConfig {
+    /** Whether to enable the provider (default: true) */
+    enabled?: boolean;
+}
+/**
+ * Create the Cosiall provider function
+ *
+ * Returns all emails found for a LinkedIn profile.
+ * Since this is a free service, it should always be executed.
+ */
+export declare function createCosiallProvider(config?: CosiallConfig): (candidate: EnrichmentCandidate) => Promise<ProviderResult | ProviderMultiResult | null>;

package/dist/enrichment/providers/cosiall.js

@@ -0,0 +1,109 @@
+"use strict";
+/**
+ * Cosiall Profile Emails Provider
+ *
+ * Lookups against the Cosiall FlexIQ Profile Emails API.
+ * This is FREE and returns all known emails for a LinkedIn profile.
+ *
+ * Lookup priority:
+ * 1. objectUrn (most precise - "urn:li:member:129147375")
+ * 2. linkedInUrl (URL like "https://www.linkedin.com/in/john-doe/")
+ * 3. vanity (username extracted from URL or direct field)
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createCosiallProvider = createCosiallProvider;
+const cosiall_client_1 = require("../../cosiall-client");
+const validation_1 = require("../utils/validation");
+const noop_provider_1 = require("../utils/noop-provider");
+/**
+ * Extract objectUrn from candidate
+ */
+function extractObjectUrn(candidate) {
+    const objectUrn = candidate.objectUrn || candidate.object_urn;
+    if (objectUrn && objectUrn.startsWith("urn:li:")) {
+        return objectUrn;
+    }
+    return null;
+}
+/**
+ * Extract LinkedIn URL from candidate
+ */
+function extractLinkedInUrl(candidate) {
+    const url = candidate.linkedinUrl || candidate.linkedin_url;
+    if (url && url.includes("linkedin.com")) {
+        return url;
+    }
+    return null;
+}
+/**
+ * Extract vanity (username) from candidate
+ */
+function extractVanity(candidate) {
+    // Direct username field
+    const directUsername = candidate.linkedinUsername || candidate.linkedin_username;
+    if (directUsername) {
+        return directUsername;
+    }
+    // Extract from URL
+    const url = candidate.linkedinUrl || candidate.linkedin_url;
+    if (url) {
+        const extracted = (0, validation_1.extractLinkedInUsername)(url);
+        if (extracted) {
+            return extracted;
+        }
+    }
+    return null;
+}
+/**
+ * Create the Cosiall provider function
+ *
+ * Returns all emails found for a LinkedIn profile.
+ * Since this is a free service, it should always be executed.
+ */
+function createCosiallProvider(config) {
+    // Check if explicitly disabled
+    if (config?.enabled === false) {
+        return (0, noop_provider_1.createNoOpProvider)("cosiall");
+    }
+    async function fetchEmail(candidate) {
+        // Extract lookup parameters in priority order
+        const objectUrn = extractObjectUrn(candidate);
+        const linkedInUrl = extractLinkedInUrl(candidate);
+        const vanity = extractVanity(candidate);
+        // Must have at least one lookup parameter
+        if (!objectUrn && !linkedInUrl && !vanity) {
+            return null;
+        }
+        try {
+            const result = await (0, cosiall_client_1.fetchProfileEmailsFromCosiall)({
+                objectUrn: objectUrn || undefined,
+                linkedInUrl: linkedInUrl || undefined,
+                vanity: vanity || undefined,
+            });
+            // No emails found
+            if (!result.emails || result.emails.length === 0) {
+                return null;
+            }
+            // Build multi-result with all emails
+            const emails = result.emails.map((email) => ({
+                email,
+                verified: true, // Cosiall data is from LinkedIn profiles
+                confidence: 85, // Good confidence - these are profile-associated emails
+                metadata: {
+                    profileId: result.profileId,
+                    objectUrn: result.objectUrn,
+                    linkedInUrl: result.linkedInUrl,
+                    source: "cosiall",
+                },
+            }));
+            return { emails };
+        }
+        catch {
+            // Silently fail - provider failures shouldn't stop the enrichment flow
+            return null;
+        }
+    }
+    // Mark provider name for orchestrator
+    fetchEmail.__name = "cosiall";
+    return fetchEmail;
+}

package/dist/enrichment/providers/dropcontact.d.ts

@@ -1,16 +1,22 @@
 /**
  * Dropcontact Provider
  *
- * Dropcontact API for email finding.
- * This is a placeholder implementation - full implementation would call the Dropcontact API.
+ * Dropcontact API for email finding and enrichment.
+ * Uses the batch enrichment API with polling for results.
+ *
+ * API Flow:
+ * 1. POST /batch to submit contacts for enrichment
+ * 2. GET /batch/{request_id} to poll for results
+ *
+ * Features:
+ * - Email finding from name + company/website
+ * - Email verification (deliverable/undeliverable)
+ * - GDPR compliant (EU-based)
+ *
+ * @see https://developer.dropcontact.com/
  */
-import type { EnrichmentCandidate, ProviderResult, DropcontactConfig } from '../types';
+import type { EnrichmentCandidate, ProviderResult, DropcontactConfig } from "../types";
 /**
  * Create the Dropcontact provider function
- *
- * Note: This is a placeholder. Full implementation would:
- * 1. POST to https://api.dropcontact.io/batch with contacts
- * 2. Poll for results
- * 3. Return enriched email with verification status
  */
-export declare function createDropcontactProvider(config: DropcontactConfig): (_candidate: EnrichmentCandidate) => Promise<ProviderResult | null>;
+export declare function createDropcontactProvider(config: DropcontactConfig): (candidate: EnrichmentCandidate) => Promise<ProviderResult | null>;

package/dist/enrichment/providers/dropcontact.js

@@ -2,36 +2,205 @@
 /**
  * Dropcontact Provider
  *
- * Dropcontact API for email finding.
- * This is a placeholder implementation - full implementation would call the Dropcontact API.
+ * Dropcontact API for email finding and enrichment.
+ * Uses the batch enrichment API with polling for results.
+ *
+ * API Flow:
+ * 1. POST /batch to submit contacts for enrichment
+ * 2. GET /batch/{request_id} to poll for results
+ *
+ * Features:
+ * - Email finding from name + company/website
+ * - Email verification (deliverable/undeliverable)
+ * - GDPR compliant (EU-based)
+ *
+ * @see https://developer.dropcontact.com/
  */
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.createDropcontactProvider = createDropcontactProvider;
+const http_retry_1 = require("../utils/http-retry");
+const noop_provider_1 = require("../utils/noop-provider");
+const API_BASE = "https://api.dropcontact.io";
+/**
+ * Extract inputs from candidate for Dropcontact API
+ */
+function extractInputs(candidate) {
+    const name = candidate.name || candidate.fullName || candidate.full_name;
+    const first = candidate.first ||
+        candidate.first_name ||
+        candidate.firstName ||
+        name?.split?.(" ")?.[0];
+    const last = candidate.last ||
+        candidate.last_name ||
+        candidate.lastName ||
+        name?.split?.(" ")?.slice(1).join(" ") ||
+        undefined;
+    const domain = candidate.domain ||
+        candidate.companyDomain ||
+        candidate.company_domain ||
+        undefined;
+    const company = candidate.company ||
+        candidate.currentCompany ||
+        candidate.organization ||
+        candidate.org ||
+        undefined;
+    const linkedin = candidate.linkedinUrl ||
+        candidate.linkedin_url ||
+        (candidate.linkedinHandle
+            ? `https://www.linkedin.com/in/${candidate.linkedinHandle}`
+            : undefined) ||
+        (candidate.linkedin_handle
+            ? `https://www.linkedin.com/in/${candidate.linkedin_handle}`
+            : undefined) ||
+        undefined;
+    return {
+        first_name: first,
+        last_name: last,
+        full_name: name,
+        company: company,
+        website: domain,
+        linkedin: linkedin,
+    };
+}
 /**
  * Create the Dropcontact provider function
- *
- * Note: This is a placeholder. Full implementation would:
- * 1. POST to https://api.dropcontact.io/batch with contacts
- * 2. Poll for results
- * 3. Return enriched email with verification status
  */
 function createDropcontactProvider(config) {
     const { apiKey } = config;
     if (!apiKey) {
-        // Return a no-op provider if not configured
-        const noopProvider = async () => null;
-        noopProvider.__name = 'dropcontact';
-        return noopProvider;
+        return (0, noop_provider_1.createNoOpProvider)("dropcontact");
+    }
+    /**
+     * Submit a batch request to Dropcontact
+     */
+    async function submitBatch(contacts) {
+        const body = {
+            data: contacts,
+            siren: false, // We don't need French company registration numbers
+            language: "en",
+        };
+        try {
+            const response = await (0, http_retry_1.postWithRetry)(`${API_BASE}/batch`, body, { "X-Access-Token": apiKey }, { retries: 2, backoffMs: 500, timeoutMs: 30000 });
+            if (response.error) {
+                return null;
+            }
+            return response.request_id || null;
+        }
+        catch {
+            return null;
+        }
+    }
+    /**
+     * Poll for batch results with exponential backoff
+     */
+    async function pollResults(requestId, maxAttempts = 10, initialDelayMs = 2000) {
+        let delayMs = initialDelayMs;
+        for (let attempt = 0; attempt < maxAttempts; attempt++) {
+            await (0, http_retry_1.delay)(delayMs);
+            try {
+                const response = await (0, http_retry_1.getWithRetry)(`${API_BASE}/batch/${requestId}`, { "X-Access-Token": apiKey }, { retries: 1, backoffMs: 500, timeoutMs: 30000 });
+                // Check if processing is complete
+                if (response.error) {
+                    return null;
+                }
+                // If we have data and status is finished (or we got data back), return it
+                if (response.data && response.data.length > 0) {
+                    // Check if still processing
+                    if (response.status === "pending") {
+                        // Increase delay for next poll (max 10 seconds)
+                        delayMs = Math.min(delayMs * 1.5, 10000);
+                        continue;
+                    }
+                    return response.data;
+                }
+                // If explicitly finished but no data
+                if (response.status === "finished") {
+                    return response.data || null;
+                }
+                // Still processing, increase delay
+                delayMs = Math.min(delayMs * 1.5, 10000);
+            }
+            catch {
+                // Network error, retry with backoff
+                delayMs = Math.min(delayMs * 2, 10000);
+            }
+        }
+        return null; // Timeout after max attempts
     }
-    async function fetchEmail(_candidate) {
-        // TODO: Implement Dropcontact API integration
-        // API: POST https://api.dropcontact.io/batch
-        // Headers: X-Access-Token: {apiKey}
-        // Body: { data: [{ first_name, last_name, company, website }], siren: false, language: "en" }
-        // For now, return null (skip this provider)
-        return null;
+    /**
+     * Fetch email for a candidate
+     */
+    async function fetchEmail(candidate) {
+        const contact = extractInputs(candidate);
+        // Need at least a name and company/website to search
+        const hasName = (0, http_retry_1.truthy)(contact.first_name) || (0, http_retry_1.truthy)(contact.full_name);
+        const hasCompanyInfo = (0, http_retry_1.truthy)(contact.company) || (0, http_retry_1.truthy)(contact.website);
+        const hasLinkedIn = (0, http_retry_1.truthy)(contact.linkedin);
+        if (!hasName && !hasLinkedIn) {
+            return null; // Need at least name or LinkedIn URL
+        }
+        if (!hasCompanyInfo && !hasLinkedIn) {
+            return null; // Need company info or LinkedIn URL
+        }
+        // Submit single contact as batch
+        const requestId = await submitBatch([contact]);
+        if (!requestId) {
+            return null;
+        }
+        // Poll for results
+        const results = await pollResults(requestId);
+        if (!results || results.length === 0) {
+            return null;
+        }
+        // Extract email from first result
+        const enriched = results[0];
+        if (!enriched.email || enriched.email.length === 0) {
+            return null;
+        }
+        // Find the best email (prefer valid ones)
+        let bestEmail = null;
+        for (const emailObj of enriched.email) {
+            if (!emailObj.email)
+                continue;
+            // Prefer valid emails
+            if (emailObj.qualification === "valid") {
+                bestEmail = emailObj;
+                break;
+            }
+            // Take catch-all if no valid found yet
+            if (!bestEmail ||
+                (bestEmail.qualification !== "valid" &&
+                    emailObj.qualification === "catch_all")) {
+                bestEmail = emailObj;
+            }
+            // Take any email if nothing else
+            if (!bestEmail) {
+                bestEmail = emailObj;
+            }
+        }
+        if (!bestEmail || !bestEmail.email) {
+            return null;
+        }
+        // Map qualification to verified status
+        const verified = (0, http_retry_1.mapVerifiedStatus)(bestEmail.qualification);
+        // Confidence based on qualification
+        let score = 50;
+        if (bestEmail.qualification === "valid") {
+            score = 95;
+        }
+        else if (bestEmail.qualification === "catch_all") {
+            score = 60;
+        }
+        else if (bestEmail.qualification === "invalid") {
+            score = 10;
+        }
+        return {
+            email: bestEmail.email,
+            verified,
+            score,
+        };
     }
     // Mark provider name for orchestrator
-    fetchEmail.__name = 'dropcontact';
+    fetchEmail.__name = "dropcontact";
     return fetchEmail;
 }

package/dist/enrichment/providers/hunter.d.ts

@@ -2,7 +2,14 @@
  * Hunter.io Provider
  *
  * Hunter.io public API for email finding.
- * Uses email-finder endpoint with name+domain, falls back to domain-search.
+ *
+ * Supports three modes (in order of preference):
+ * 1. linkedin_handle - Most accurate, uses LinkedIn vanity/handle
+ * 2. domain + first_name + last_name - Standard email finder
+ * 3. company + first_name + last_name - When domain is unknown
+ * 4. domain-search fallback - Returns multiple emails for a domain
+ *
+ * @see https://hunter.io/api-documentation/v2#email-finder
  */
 import type { EnrichmentCandidate, ProviderResult, ProviderMultiResult, HunterConfig } from "../types";
 /**

package/dist/enrichment/providers/hunter.js

@@ -3,31 +3,35 @@
  * Hunter.io Provider
  *
  * Hunter.io public API for email finding.
- * Uses email-finder endpoint with name+domain, falls back to domain-search.
+ *
+ * Supports three modes (in order of preference):
+ * 1. linkedin_handle - Most accurate, uses LinkedIn vanity/handle
+ * 2. domain + first_name + last_name - Standard email finder
+ * 3. company + first_name + last_name - When domain is unknown
+ * 4. domain-search fallback - Returns multiple emails for a domain
+ *
+ * @see https://hunter.io/api-documentation/v2#email-finder
  */
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.createHunterProvider = createHunterProvider;
 const http_retry_1 = require("../utils/http-retry");
+const candidate_parser_1 = require("../utils/candidate-parser");
+const noop_provider_1 = require("../utils/noop-provider");
 const API_BASE = "https://api.hunter.io/v2";
 /**
- * Extract name and domain from candidate
+ * Extract Hunter-specific inputs from candidate using shared parser
  */
-function extractInputs(candidate) {
-    const name = candidate.name || candidate.fullName || candidate.full_name;
-    const first = candidate.first ||
-        candidate.first_name ||
-        candidate.firstName ||
-        name?.split?.(" ")?.[0];
-    const last = candidate.last ||
-        candidate.last_name ||
-        candidate.lastName ||
-        name?.split?.(" ")?.slice(1).join(" ") ||
-        undefined;
-    const domain = candidate.domain ||
-        candidate.companyDomain ||
-        candidate.company_domain ||
-        undefined;
-    return { first, last, domain };
+function extractHunterInputs(candidate) {
+    const { firstName, lastName } = (0, candidate_parser_1.extractName)(candidate);
+    const { company, domain } = (0, candidate_parser_1.extractCompany)(candidate);
+    const { username: linkedinHandle } = (0, candidate_parser_1.extractLinkedIn)(candidate);
+    return {
+        first: firstName || undefined,
+        last: lastName || undefined,
+        domain: domain ?? undefined,
+        company: company ?? undefined,
+        linkedinHandle: linkedinHandle ?? undefined,
+    };
 }
 /**
  * Create the Hunter provider function
@@ -35,17 +39,23 @@ function extractInputs(candidate) {
 function createHunterProvider(config) {
     const { apiKey } = config;
     if (!apiKey) {
-        // Return a no-op provider if not configured
-        const noopProvider = async () => null;
-        noopProvider.__name = "hunter";
-        return noopProvider;
+        return (0, noop_provider_1.createNoOpProvider)("hunter");
     }
     async function fetchEmail(candidate) {
-        const { first, last, domain } = extractInputs(candidate);
+        const { first, last, domain, company, linkedinHandle } = extractHunterInputs(candidate);
         let url = null;
         let isEmailFinder = false;
-        // Use email-finder if we have name components
-        if ((0, http_retry_1.truthy)(first) && (0, http_retry_1.truthy)(last) && (0, http_retry_1.truthy)(domain)) {
+        // Priority 1: Use linkedin_handle if available (most accurate)
+        if ((0, http_retry_1.truthy)(linkedinHandle)) {
+            const qs = new URLSearchParams({
+                api_key: String(apiKey),
+                linkedin_handle: String(linkedinHandle),
+            });
+            url = `${API_BASE}/email-finder?${qs.toString()}`;
+            isEmailFinder = true;
+        }
+        // Priority 2: Use domain + name (standard email finder)
+        else if ((0, http_retry_1.truthy)(first) && (0, http_retry_1.truthy)(last) && (0, http_retry_1.truthy)(domain)) {
             const qs = new URLSearchParams({
                 api_key: String(apiKey),
                 domain: String(domain),
@@ -55,7 +65,18 @@ function createHunterProvider(config) {
             url = `${API_BASE}/email-finder?${qs.toString()}`;
             isEmailFinder = true;
         }
-        // Fall back to domain-search if only domain available (can return multiple)
+        // Priority 3: Use company + name (when domain unknown)
+        else if ((0, http_retry_1.truthy)(first) && (0, http_retry_1.truthy)(last) && (0, http_retry_1.truthy)(company)) {
+            const qs = new URLSearchParams({
+                api_key: String(apiKey),
+                company: String(company),
+                first_name: String(first),
+                last_name: String(last),
+            });
+            url = `${API_BASE}/email-finder?${qs.toString()}`;
+            isEmailFinder = true;
+        }
+        // Priority 4: Fall back to domain-search if only domain available (can return multiple)
         else if ((0, http_retry_1.truthy)(domain)) {
             const qs = new URLSearchParams({
                 api_key: String(apiKey),
@@ -65,10 +86,13 @@ function createHunterProvider(config) {
             url = `${API_BASE}/domain-search?${qs.toString()}`;
         }
         else {
-            return null; // Can't search without domain
+            return null; // Can't search without domain, company, or linkedin_handle
         }
         try {
-            const json = await (0, http_retry_1.getWithRetry)(url, undefined, { retries: 1, backoffMs: 100 });
+            const json = await (0, http_retry_1.getWithRetry)(url, undefined, {
+                retries: 1,
+                backoffMs: 100,
+            });
             // Parse email-finder response shape (single result)
             if (isEmailFinder) {
                 const ef = (json && (json.data || json.result));