linkedin-secret-sauce 0.8.0 → 0.10.0

package/dist/enrichment/index.d.ts

@@ -44,4 +44,4 @@ export { extractNumericLinkedInId } from "./providers/ldd";
 export { createSmartProspectClient, type SmartProspectClient, type SmartProspectLocationOptions, } from "./providers/smartprospect";
 export { enrichBusinessEmail, enrichBatch, enrichAllEmails, enrichAllBatch } from "./orchestrator";
 export { getSmartLeadToken, getSmartLeadUser, clearSmartLeadToken, clearAllSmartLeadTokens, getSmartLeadTokenCacheStats, enableFileCache, disableFileCache, isFileCacheEnabled, clearFileCache, type SmartLeadCredentials, type SmartLeadAuthConfig, type SmartLeadUser, type SmartLeadLoginResponse, } from "./auth";
-export { calculateMatchConfidence, classifyMatchQuality, findBestMatch, matchContacts, buildSmartProspectFiltersFromLinkedIn, parseLinkedInSearchResponse, enrichLinkedInContact, enrichLinkedInContactsBatch, createLinkedInEnricher, getEmailsForLinkedInContact, getEmailsForLinkedInContactsBatch, type LinkedInContact, type MatchResult, type MatchOptions, type LinkedInEnrichmentResult, type LinkedInEnrichmentOptions, type EmailResult, type GetEmailsResult, type GetEmailsConfig, type GetEmailsOptions, } from "./matching";
+export { calculateMatchConfidence, classifyMatchQuality, findBestMatch, matchContacts, buildSmartProspectFiltersFromLinkedIn, parseLinkedInSearchResponse, enrichLinkedInContact, enrichLinkedInContactsBatch, createLinkedInEnricher, getEmailsForLinkedInContact, getEmailsForLinkedInContactsBatch, salesLeadToContact, type LinkedInContact, type MatchResult, type MatchOptions, type LinkedInEnrichmentResult, type LinkedInEnrichmentOptions, type EmailSource, type EmailResult, type GetEmailsResult, type GetEmailsConfig, type GetEmailsOptions, } from "./matching";

package/dist/enrichment/index.js

@@ -42,7 +42,7 @@ var __exportStar = (this && this.__exportStar) || function(m, exports) {
     for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.getEmailsForLinkedInContactsBatch = exports.getEmailsForLinkedInContact = exports.createLinkedInEnricher = exports.enrichLinkedInContactsBatch = exports.enrichLinkedInContact = exports.parseLinkedInSearchResponse = exports.buildSmartProspectFiltersFromLinkedIn = exports.matchContacts = exports.findBestMatch = exports.classifyMatchQuality = exports.calculateMatchConfidence = exports.clearFileCache = exports.isFileCacheEnabled = exports.disableFileCache = exports.enableFileCache = exports.getSmartLeadTokenCacheStats = exports.clearAllSmartLeadTokens = exports.clearSmartLeadToken = exports.getSmartLeadUser = exports.getSmartLeadToken = exports.enrichAllBatch = exports.enrichAllEmails = exports.enrichBatch = exports.enrichBusinessEmail = exports.createSmartProspectClient = exports.extractNumericLinkedInId = exports.createDropcontactProvider = exports.createApolloProvider = exports.createHunterProvider = exports.createSmartProspectProvider = exports.createLddProvider = exports.createConstructProvider = exports.verifyEmailMx = exports.extractLinkedInUsername = exports.hostnameFromUrl = exports.cleanNamePart = exports.asciiFold = exports.isRoleAccount = exports.isValidEmailSyntax = exports.DISPOSABLE_DOMAINS = exports.isDisposableDomain = exports.isDisposableEmail = exports.PERSONAL_DOMAINS = exports.isPersonalDomain = exports.isBusinessEmail = exports.isPersonalEmail = void 0;
+exports.salesLeadToContact = exports.getEmailsForLinkedInContactsBatch = exports.getEmailsForLinkedInContact = exports.createLinkedInEnricher = exports.enrichLinkedInContactsBatch = exports.enrichLinkedInContact = exports.parseLinkedInSearchResponse = exports.buildSmartProspectFiltersFromLinkedIn = exports.matchContacts = exports.findBestMatch = exports.classifyMatchQuality = exports.calculateMatchConfidence = exports.clearFileCache = exports.isFileCacheEnabled = exports.disableFileCache = exports.enableFileCache = exports.getSmartLeadTokenCacheStats = exports.clearAllSmartLeadTokens = exports.clearSmartLeadToken = exports.getSmartLeadUser = exports.getSmartLeadToken = exports.enrichAllBatch = exports.enrichAllEmails = exports.enrichBatch = exports.enrichBusinessEmail = exports.createSmartProspectClient = exports.extractNumericLinkedInId = exports.createDropcontactProvider = exports.createApolloProvider = exports.createHunterProvider = exports.createSmartProspectProvider = exports.createLddProvider = exports.createConstructProvider = exports.verifyEmailMx = exports.extractLinkedInUsername = exports.hostnameFromUrl = exports.cleanNamePart = exports.asciiFold = exports.isRoleAccount = exports.isValidEmailSyntax = exports.DISPOSABLE_DOMAINS = exports.isDisposableDomain = exports.isDisposableEmail = exports.PERSONAL_DOMAINS = exports.isPersonalDomain = exports.isBusinessEmail = exports.isPersonalEmail = void 0;
 exports.createEnrichmentClient = createEnrichmentClient;
 const orchestrator_1 = require("./orchestrator");
 const construct_1 = require("./providers/construct");
@@ -290,3 +290,5 @@ Object.defineProperty(exports, "createLinkedInEnricher", { enumerable: true, get
 // UNIFIED email lookup (recommended for most use cases)
 Object.defineProperty(exports, "getEmailsForLinkedInContact", { enumerable: true, get: function () { return matching_1.getEmailsForLinkedInContact; } });
 Object.defineProperty(exports, "getEmailsForLinkedInContactsBatch", { enumerable: true, get: function () { return matching_1.getEmailsForLinkedInContactsBatch; } });
+// Conversion utility for Sales Nav entities
+Object.defineProperty(exports, "salesLeadToContact", { enumerable: true, get: function () { return matching_1.salesLeadToContact; } });

package/dist/enrichment/matching.d.ts

@@ -5,6 +5,7 @@
  * to find the same person across both platforms.
  */
 import type { SmartProspectContact, SmartProspectConfig, SmartProspectFetchResponse, LddConfig } from './types';
+import type { SalesLeadSearchResult } from '../types';
 import { type SmartProspectClient } from './providers/smartprospect';
 /**
  * LinkedIn Sales Navigator contact (simplified from API response)
@@ -39,6 +40,21 @@ export interface LinkedInContact {
         }>;
     };
 }
+/**
+ * Convert a Sales Navigator search result to LinkedInContact format.
+ * This allows consumers to pass raw Sales Nav entities directly.
+ *
+ * @param lead - Raw Sales Navigator lead search result
+ * @returns LinkedInContact compatible with email lookup functions
+ *
+ * @example
+ * ```typescript
+ * const searchResults = await searchSalesLeads('CEO', { filters });
+ * const contact = salesLeadToContact(searchResults.items[0]);
+ * const emails = await getEmailsForLinkedInContact(contact, config);
+ * ```
+ */
+export declare function salesLeadToContact(lead: SalesLeadSearchResult): LinkedInContact;
 /**
  * Match result with confidence score
  */
@@ -239,6 +255,10 @@ export declare function createLinkedInEnricher(smartProspectConfig: SmartProspec
     /** Fetch email for a specific SmartProspect contact ID (COSTS CREDITS) */
     fetchEmail: (contactId: string) => Promise<SmartProspectFetchResponse>;
 } | null;
+/**
+ * Email source - where the email was found
+ */
+export type EmailSource = 'ldd' | 'smartprospect' | 'linkedin' | 'pattern' | 'hunter' | 'apollo';
 /**
  * Email result from unified lookup
  */
@@ -246,7 +266,7 @@ export interface EmailResult {
     /** The email address */
     email: string;
     /** Which provider found this email */
-    source: 'ldd' | 'smartprospect';
+    source: EmailSource;
     /** Confidence score (0-100) */
     confidence: number;
     /** Email type classification */
@@ -255,6 +275,8 @@ export interface EmailResult {
     verified: boolean;
     /** Email deliverability score (0-1) for SmartProspect emails */
     deliverability?: number;
+    /** Whether this is a catch-all domain */
+    isCatchAll?: boolean;
     /** Additional metadata */
     metadata?: Record<string, unknown>;
 }
@@ -269,18 +291,38 @@ export interface GetEmailsResult {
     /** Numeric LinkedIn ID extracted from objectUrn */
     numericLinkedInId: string | null;
     /** Which providers were queried */
-    providersQueried: ('ldd' | 'smartprospect')[];
-    /** Error message if failed */
-    error?: string;
+    providersQueried: EmailSource[];
+    /** Company domain discovered during lookup (from SmartProspect if not in LinkedIn data) */
+    discoveredCompanyDomain?: string;
+    /** Error message if any provider failed */
+    errors?: string[];
 }
 /**
  * Configuration for unified email lookup
  */
 export interface GetEmailsConfig {
-    /** LDD configuration (optional but recommended - FREE) */
+    /** LDD configuration (FREE - your ~500M database) */
     ldd?: LddConfig;
-    /** SmartProspect configuration (optional - PAID fallback) */
+    /** SmartProspect configuration (FREE for FlexIQ - already paying monthly) */
     smartprospect?: SmartProspectConfig;
+    /** Company domain for email pattern guessing (optional - if not provided, will try to discover) */
+    companyDomain?: string;
+    /**
+     * LinkedIn company lookup function (for fetching company website when not available).
+     * Pass getCompanyById from linkedin-api to enable this.
+     * This is a LAST RESORT since it uses LinkedIn API quota.
+     */
+    linkedInCompanyLookup?: (companyId: string) => Promise<{
+        websiteUrl?: string;
+    } | null>;
+    /** Hunter configuration (PAID - last resort) */
+    hunter?: {
+        apiKey: string;
+    };
+    /** Apollo configuration (PAID - last resort) */
+    apollo?: {
+        apiKey: string;
+    };
 }
 /**
  * Options for unified email lookup
@@ -290,19 +332,26 @@ export interface GetEmailsOptions {
     skipLdd?: boolean;
     /** Skip SmartProspect lookup (default: false) */
     skipSmartProspect?: boolean;
+    /** Skip email pattern guessing (default: false) */
+    skipPatternGuessing?: boolean;
+    /** Skip LinkedIn company lookup for domain discovery (default: false) */
+    skipLinkedInCompanyLookup?: boolean;
+    /** Skip paid providers Hunter/Apollo (default: false) */
+    skipPaidProviders?: boolean;
     /** Minimum match confidence for SmartProspect (default: 60) */
     minMatchConfidence?: number;
+    /** Minimum confidence to skip paid providers (default: 80) */
+    paidProviderThreshold?: number;
     /** Include company in SmartProspect search (default: true) */
     includeCompany?: boolean;
 }
 /**
  * Get emails for a LinkedIn contact - UNIFIED FUNCTION
  *
- * This is the main function consumers should use. It:
- * 1. Extracts the numeric LinkedIn ID from objectUrn (stable identifier)
- * 2. Tries LDD first (FREE, uses numeric ID for reliable lookup)
- * 3. Falls back to SmartProspect if LDD has no results (PAID)
- * 4. Returns ALL emails with unified scoring
+ * Strategy (optimized for FlexIQ):
+ * 1. Query LDD + SmartProspect in PARALLEL (both FREE for you)
+ * 2. Try email pattern guessing with MX verification (FREE)
+ * 3. Only use Hunter/Apollo if confidence is below threshold (PAID - last resort)
  *
  * @example
  * ```ts
@@ -310,10 +359,13 @@ export interface GetEmailsOptions {
  *
  * // From your LinkedIn Sales Nav search result
  * const contact = {
- *   objectUrn: 'urn:li:member:307567',  // IMPORTANT: Include this!
+ *   objectUrn: 'urn:li:member:307567',  // Stable ID for LDD
  *   firstName: 'Jim',
  *   lastName: 'DeMaio',
- *   currentPositions: [{ companyName: 'Acme Corp', title: 'CEO' }]
+ *   currentPositions: [{
+ *     companyName: 'Acme Corp',
+ *     companyUrnResolutionResult: { website: 'acme.com' }
+ *   }]
  * };
  *
  * const result = await getEmailsForLinkedInContact(contact, {
@@ -325,26 +377,31 @@ export interface GetEmailsOptions {
  *     email: process.env.SMARTLEAD_EMAIL,
  *     password: process.env.SMARTLEAD_PASSWORD,
  *   },
+ *   // companyDomain extracted automatically from currentPositions
  * });
  *
  * if (result.success) {
+ *   console.log('Providers queried:', result.providersQueried);
  *   console.log('Found emails:', result.emails);
  *   // [
  *   //   { email: 'jim@acme.com', source: 'ldd', confidence: 95, type: 'business' },
- *   //   { email: 'jim@gmail.com', source: 'ldd', confidence: 70, type: 'personal' }
+ *   //   { email: 'j.demaio@acme.com', source: 'smartprospect', confidence: 85, type: 'business' },
  *   // ]
  * }
  * ```
  */
-export declare function getEmailsForLinkedInContact(contact: LinkedInContact, config: GetEmailsConfig, options?: GetEmailsOptions): Promise<GetEmailsResult>;
+export declare function getEmailsForLinkedInContact(contactOrLead: LinkedInContact | SalesLeadSearchResult, config: GetEmailsConfig, options?: GetEmailsOptions): Promise<GetEmailsResult>;
 /**
  * Get emails for multiple LinkedIn contacts in batch
  *
- * Processes contacts sequentially to avoid rate limits.
+ * Processes contacts with controlled concurrency to balance speed and rate limits.
+ * Accepts either LinkedInContact[] or SalesLeadSearchResult[] directly from Sales Nav search.
  */
-export declare function getEmailsForLinkedInContactsBatch(contacts: LinkedInContact[], config: GetEmailsConfig, options?: GetEmailsOptions & {
-    /** Delay between requests in ms (default: 200) */
+export declare function getEmailsForLinkedInContactsBatch(contactsOrLeads: (LinkedInContact | SalesLeadSearchResult)[], config: GetEmailsConfig, options?: GetEmailsOptions & {
+    /** Delay between requests in ms (default: 100) */
     delayMs?: number;
+    /** Max concurrent lookups (default: 3) */
+    concurrency?: number;
     /** Callback for progress updates */
     onProgress?: (completed: number, total: number, result: GetEmailsResult) => void;
 }): Promise<GetEmailsResult[]>;

package/dist/enrichment/matching.js

@@ -5,7 +5,41 @@
  * Matches contacts between LinkedIn Sales Navigator and SmartProspect
  * to find the same person across both platforms.
  */
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
 Object.defineProperty(exports, "__esModule", { value: true });
+exports.salesLeadToContact = salesLeadToContact;
 exports.calculateMatchConfidence = calculateMatchConfidence;
 exports.classifyMatchQuality = classifyMatchQuality;
 exports.findBestMatch = findBestMatch;
@@ -19,6 +53,64 @@ exports.getEmailsForLinkedInContact = getEmailsForLinkedInContact;
 exports.getEmailsForLinkedInContactsBatch = getEmailsForLinkedInContactsBatch;
 const smartprospect_1 = require("./providers/smartprospect");
 const ldd_1 = require("./providers/ldd");
+/**
+ * Convert a Sales Navigator search result to LinkedInContact format.
+ * This allows consumers to pass raw Sales Nav entities directly.
+ *
+ * @param lead - Raw Sales Navigator lead search result
+ * @returns LinkedInContact compatible with email lookup functions
+ *
+ * @example
+ * ```typescript
+ * const searchResults = await searchSalesLeads('CEO', { filters });
+ * const contact = salesLeadToContact(searchResults.items[0]);
+ * const emails = await getEmailsForLinkedInContact(contact, config);
+ * ```
+ */
+function salesLeadToContact(lead) {
+    // Use firstName/lastName directly from Sales Nav - they're already separate fields
+    // This preserves exact names as shown on LinkedIn (important for SmartProspect matching)
+    const firstName = lead.firstName || '';
+    const lastName = lead.lastName || '';
+    return {
+        objectUrn: lead.objectUrn,
+        entityUrn: lead.salesProfileUrn,
+        firstName,
+        lastName,
+        fullName: lead.fullName || lead.name,
+        geoRegion: lead.geoRegion || lead.locationText,
+        currentPositions: lead.currentPositions?.map((pos) => ({
+            companyName: pos.companyName,
+            title: pos.title,
+            companyUrn: pos.companyUrn,
+            // Note: Sales Nav search does NOT return website in companyUrnResolutionResult
+            // We use LinkedIn Company Lookup to get website from companyUrn
+            companyUrnResolutionResult: pos.companyUrnResolutionResult
+                ? {
+                    name: pos.companyUrnResolutionResult.name,
+                    industry: pos.companyUrnResolutionResult.industry,
+                    location: pos.companyUrnResolutionResult.location,
+                }
+                : undefined,
+        })),
+    };
+}
+/**
+ * Type guard to check if input is a SalesLeadSearchResult
+ */
+function isSalesLeadSearchResult(input) {
+    // SalesLeadSearchResult has 'name' but not 'firstName'
+    return 'name' in input && !('firstName' in input);
+}
+/**
+ * Normalize input to LinkedInContact - accepts either format
+ */
+function normalizeToContact(input) {
+    if (isSalesLeadSearchResult(input)) {
+        return salesLeadToContact(input);
+    }
+    return input;
+}
 // =============================================================================
 // Utility Functions
 // =============================================================================
@@ -629,11 +721,10 @@ function createLinkedInEnricher(smartProspectConfig, defaultOptions = {}) {
 /**
  * Get emails for a LinkedIn contact - UNIFIED FUNCTION
  *
- * This is the main function consumers should use. It:
- * 1. Extracts the numeric LinkedIn ID from objectUrn (stable identifier)
- * 2. Tries LDD first (FREE, uses numeric ID for reliable lookup)
- * 3. Falls back to SmartProspect if LDD has no results (PAID)
- * 4. Returns ALL emails with unified scoring
+ * Strategy (optimized for FlexIQ):
+ * 1. Query LDD + SmartProspect in PARALLEL (both FREE for you)
+ * 2. Try email pattern guessing with MX verification (FREE)
+ * 3. Only use Hunter/Apollo if confidence is below threshold (PAID - last resort)
  *
  * @example
  * ```ts
@@ -641,10 +732,13 @@ function createLinkedInEnricher(smartProspectConfig, defaultOptions = {}) {
  *
  * // From your LinkedIn Sales Nav search result
  * const contact = {
- *   objectUrn: 'urn:li:member:307567',  // IMPORTANT: Include this!
+ *   objectUrn: 'urn:li:member:307567',  // Stable ID for LDD
  *   firstName: 'Jim',
  *   lastName: 'DeMaio',
- *   currentPositions: [{ companyName: 'Acme Corp', title: 'CEO' }]
+ *   currentPositions: [{
+ *     companyName: 'Acme Corp',
+ *     companyUrnResolutionResult: { website: 'acme.com' }
+ *   }]
  * };
  *
  * const result = await getEmailsForLinkedInContact(contact, {
@@ -656,164 +750,366 @@ function createLinkedInEnricher(smartProspectConfig, defaultOptions = {}) {
  *     email: process.env.SMARTLEAD_EMAIL,
  *     password: process.env.SMARTLEAD_PASSWORD,
  *   },
+ *   // companyDomain extracted automatically from currentPositions
  * });
  *
  * if (result.success) {
+ *   console.log('Providers queried:', result.providersQueried);
  *   console.log('Found emails:', result.emails);
  *   // [
  *   //   { email: 'jim@acme.com', source: 'ldd', confidence: 95, type: 'business' },
- *   //   { email: 'jim@gmail.com', source: 'ldd', confidence: 70, type: 'personal' }
+ *   //   { email: 'j.demaio@acme.com', source: 'smartprospect', confidence: 85, type: 'business' },
  *   // ]
  * }
  * ```
  */
-async function getEmailsForLinkedInContact(contact, config, options = {}) {
-    const { skipLdd = false, skipSmartProspect = false, minMatchConfidence = 60, includeCompany = true, } = options;
+async function getEmailsForLinkedInContact(contactOrLead, config, options = {}) {
+    // Normalize input - accept either LinkedInContact or raw SalesLeadSearchResult
+    const contact = normalizeToContact(contactOrLead);
+    const { skipLdd = false, skipSmartProspect = false, skipPatternGuessing = false, skipPaidProviders = false, minMatchConfidence = 60, paidProviderThreshold = 80, includeCompany = true, } = options;
     // Extract numeric ID from objectUrn
     const numericLinkedInId = (0, ldd_1.extractNumericLinkedInId)(contact.objectUrn);
+    // Extract company domain from contact (LinkedIn data - often missing)
+    const linkedInCompanyDomain = config.companyDomain || extractCompanyDomain(contact);
     const result = {
         success: false,
         emails: [],
         numericLinkedInId,
         providersQueried: [],
+        errors: [],
+    };
+    // Track seen emails to deduplicate
+    const seenEmails = new Set();
+    const addEmail = (emailResult) => {
+        const lower = emailResult.email.toLowerCase();
+        if (!seenEmails.has(lower)) {
+            seenEmails.add(lower);
+            result.emails.push(emailResult);
+        }
     };
+    // Track company domain discovered from SmartProspect (since LinkedIn doesn't provide it)
+    let discoveredCompanyDomain = null;
     // ==========================================================================
-    // Step 1: Try LDD first (FREE)
+    // Phase 1: FREE providers in PARALLEL (LDD + SmartProspect)
     // ==========================================================================
+    const freeProviderPromises = [];
+    // LDD lookup (FREE)
     if (!skipLdd && config.ldd?.apiUrl && config.ldd?.apiToken) {
         result.providersQueried.push('ldd');
-        try {
-            const lddProvider = (0, ldd_1.createLddProvider)(config.ldd);
-            const lddResult = await lddProvider({
-                numericLinkedInId: numericLinkedInId || undefined,
-                linkedinUsername: undefined, // Let LDD provider extract from contact if needed
-                firstName: contact.firstName,
-                lastName: contact.lastName,
-            });
-            if (lddResult && 'emails' in lddResult && lddResult.emails.length > 0) {
-                // LDD found emails!
-                for (const emailData of lddResult.emails) {
-                    result.emails.push({
-                        email: emailData.email,
-                        source: 'ldd',
-                        confidence: emailData.confidence ?? 90,
-                        type: emailData.metadata?.emailTypeClassified || 'unknown',
-                        verified: emailData.verified ?? true,
-                        metadata: emailData.metadata,
-                    });
+        freeProviderPromises.push(queryLdd(contact, config.ldd, numericLinkedInId, addEmail, result));
+    }
+    // SmartProspect lookup (FREE for FlexIQ)
+    // This also extracts company domain for pattern guessing
+    if (!skipSmartProspect && config.smartprospect) {
+        result.providersQueried.push('smartprospect');
+        freeProviderPromises.push(querySmartProspect(contact, config.smartprospect, minMatchConfidence, includeCompany, addEmail, result)
+            .then((domain) => {
+            if (domain) {
+                discoveredCompanyDomain = domain;
+            }
+        }));
+    }
+    // Wait for both free providers
+    await Promise.all(freeProviderPromises);
+    // Check if we have good enough results already
+    const bestConfidenceAfterFreeProviders = result.emails.length > 0
+        ? Math.max(...result.emails.map(e => e.confidence))
+        : 0;
+    // ==========================================================================
+    // Phase 2: Domain Discovery (if needed for pattern guessing)
+    // ==========================================================================
+    // Priority: LinkedIn contact data > SmartProspect > LinkedIn Company API
+    let companyDomain = linkedInCompanyDomain || discoveredCompanyDomain;
+    // If no domain yet and pattern guessing is enabled, try LinkedIn company lookup
+    if (!companyDomain &&
+        !skipPatternGuessing &&
+        !options.skipLinkedInCompanyLookup &&
+        config.linkedInCompanyLookup &&
+        bestConfidenceAfterFreeProviders < paidProviderThreshold) {
+        // Extract company ID from companyUrn
+        const companyUrn = contact.currentPositions?.[0]?.companyUrn;
+        if (companyUrn) {
+            const companyId = extractCompanyIdFromUrn(companyUrn);
+            if (companyId) {
+                result.providersQueried.push('linkedin');
+                try {
+                    const company = await config.linkedInCompanyLookup(companyId);
+                    if (company?.websiteUrl) {
+                        companyDomain = extractDomainFromUrl(company.websiteUrl);
+                        if (companyDomain) {
+                            discoveredCompanyDomain = companyDomain;
+                        }
+                    }
+                }
+                catch (err) {
+                    result.errors?.push(`LinkedIn: ${err instanceof Error ? err.message : 'Company lookup failed'}`);
                 }
-                result.success = true;
             }
         }
-        catch (err) {
-            // LDD failed, continue to SmartProspect
-            result.error = `LDD error: ${err instanceof Error ? err.message : 'Unknown error'}`;
-        }
+    }
+    // Store discovered domain in result for visibility
+    if (discoveredCompanyDomain && !linkedInCompanyDomain) {
+        result.discoveredCompanyDomain = discoveredCompanyDomain;
     }
     // ==========================================================================
-    // Step 2: Fall back to SmartProspect if LDD didn't find emails (PAID)
+    // Phase 3: Email pattern guessing with MX verification (FREE)
     // ==========================================================================
-    if (!result.success && !skipSmartProspect && config.smartprospect) {
-        result.providersQueried.push('smartprospect');
-        try {
-            const client = (0, smartprospect_1.createSmartProspectClient)(config.smartprospect);
-            if (!client) {
-                result.error = 'Failed to create SmartProspect client';
-                return result;
+    if (!skipPatternGuessing && companyDomain && bestConfidenceAfterFreeProviders < paidProviderThreshold) {
+        result.providersQueried.push('pattern');
+        await queryPatternGuessing(contact, companyDomain, addEmail, result);
+    }
+    // Recalculate best confidence
+    const finalBestConfidence = result.emails.length > 0
+        ? Math.max(...result.emails.map(e => e.confidence))
+        : 0;
+    // ==========================================================================
+    // Phase 3: PAID providers as last resort (Hunter/Apollo)
+    // ==========================================================================
+    if (!skipPaidProviders && finalBestConfidence < paidProviderThreshold) {
+        // Only use paid providers if we have low confidence or no results
+        // TODO: Implement Hunter and Apollo providers when needed
+        // For now, just mark that we would have queried them
+        if (config.hunter?.apiKey || config.apollo?.apiKey) {
+            // result.providersQueried.push('hunter');
+            // result.providersQueried.push('apollo');
+            // await queryPaidProviders(contact, config, addEmail, result);
+        }
+    }
+    // Sort emails by confidence (highest first), then by source priority
+    const sourcePriority = {
+        ldd: 0, // Highest priority - your own data
+        smartprospect: 1,
+        linkedin: 2, // LinkedIn company lookup (for domain discovery, doesn't provide emails)
+        pattern: 3,
+        hunter: 4,
+        apollo: 5,
+    };
+    result.emails.sort((a, b) => {
+        if (b.confidence !== a.confidence) {
+            return b.confidence - a.confidence;
+        }
+        return sourcePriority[a.source] - sourcePriority[b.source];
+    });
+    result.success = result.emails.length > 0;
+    // Clean up errors array if empty
+    if (result.errors && result.errors.length === 0) {
+        delete result.errors;
+    }
+    return result;
+}
+/**
+ * Extract company domain from LinkedIn contact
+ */
+function extractCompanyDomain(contact) {
+    const pos = contact.currentPositions?.[0];
+    if (!pos)
+        return null;
+    // Try to get website from company resolution
+    const website = pos.companyUrnResolutionResult?.website;
+    if (website) {
+        return extractDomainFromUrl(website);
+    }
+    return null;
+}
+/**
+ * Extract domain from a URL string
+ */
+function extractDomainFromUrl(url) {
+    if (!url)
+        return null;
+    try {
+        const fullUrl = url.startsWith('http') ? url : `https://${url}`;
+        return new URL(fullUrl).hostname.replace(/^www\./, '').toLowerCase();
+    }
+    catch {
+        // If URL parsing fails, try simple extraction
+        return url.replace(/^(https?:\/\/)?(www\.)?/, '').split('/')[0].toLowerCase() || null;
+    }
+}
+/**
+ * Extract company ID from a Sales Navigator company URN
+ * e.g., "urn:li:fs_salesCompany:108063139" → "108063139"
+ */
+function extractCompanyIdFromUrn(companyUrn) {
+    if (!companyUrn)
+        return null;
+    // Handle various URN formats
+    const match = companyUrn.match(/(\d+)$/);
+    return match ? match[1] : null;
+}
+/**
+ * Query LDD provider
+ */
+async function queryLdd(contact, lddConfig, numericLinkedInId, addEmail, result) {
+    try {
+        const lddProvider = (0, ldd_1.createLddProvider)(lddConfig);
+        const lddResult = await lddProvider({
+            numericLinkedInId: numericLinkedInId || undefined,
+            firstName: contact.firstName,
+            lastName: contact.lastName,
+        });
+        if (lddResult && 'emails' in lddResult && lddResult.emails.length > 0) {
+            for (const emailData of lddResult.emails) {
+                addEmail({
+                    email: emailData.email,
+                    source: 'ldd',
+                    confidence: emailData.confidence ?? 90,
+                    type: emailData.metadata?.emailTypeClassified || 'unknown',
+                    verified: emailData.verified ?? true,
+                    metadata: emailData.metadata,
+                });
             }
-            // Build search filters
-            const filters = buildSmartProspectFiltersFromLinkedIn(contact);
-            const searchFilters = {
-                firstName: filters.firstName,
-                lastName: filters.lastName,
-                limit: 25,
-            };
+        }
+    }
+    catch (err) {
+        result.errors?.push(`LDD: ${err instanceof Error ? err.message : 'Unknown error'}`);
+    }
+}
+/**
+ * Query SmartProspect provider
+ * Returns the company domain if found (for pattern guessing fallback)
+ */
+async function querySmartProspect(contact, smartProspectConfig, minMatchConfidence, includeCompany, addEmail, result) {
+    try {
+        const client = (0, smartprospect_1.createSmartProspectClient)(smartProspectConfig);
+        if (!client) {
+            result.errors?.push('SmartProspect: Failed to create client');
+            return null;
+        }
+        // Build search filters
+        const filters = buildSmartProspectFiltersFromLinkedIn(contact);
+        const searchFilters = {
+            firstName: filters.firstName,
+            lastName: filters.lastName,
+            limit: 25,
+        };
+        if (includeCompany && filters.companyName) {
+            searchFilters.companyName = filters.companyName;
+        }
+        // Search for matching contacts
+        let searchResponse = await client.search(searchFilters);
+        // Try broader search if no results
+        if (!searchResponse.success || searchResponse.data.list.length === 0) {
             if (includeCompany && filters.companyName) {
-                searchFilters.companyName = filters.companyName;
-            }
-            // Search for matching contacts
-            const searchResponse = await client.search(searchFilters);
-            if (!searchResponse.success || searchResponse.data.list.length === 0) {
-                // Try broader search without company
-                if (includeCompany && filters.companyName) {
-                    const broaderResponse = await client.search({
-                        firstName: filters.firstName,
-                        lastName: filters.lastName,
-                        limit: 25,
-                    });
-                    if (broaderResponse.success && broaderResponse.data.list.length > 0) {
-                        searchResponse.data.list = broaderResponse.data.list;
-                    }
+                const broaderResponse = await client.search({
+                    firstName: filters.firstName,
+                    lastName: filters.lastName,
+                    limit: 25,
+                });
+                if (broaderResponse.success && broaderResponse.data.list.length > 0) {
+                    searchResponse = broaderResponse;
                 }
             }
-            if (searchResponse.data.list.length === 0) {
-                result.error = result.error
-                    ? `${result.error}; SmartProspect: No candidates found`
-                    : 'SmartProspect: No candidates found';
-                return result;
-            }
-            // Find best match
-            const matchResult = findBestMatch(contact, searchResponse.data.list, {
-                minConfidence: minMatchConfidence,
-                fuzzyNames: true,
-                fuzzyCompany: true,
-            });
-            if (!matchResult) {
-                result.error = result.error
-                    ? `${result.error}; SmartProspect: No match above ${minMatchConfidence}% confidence`
-                    : `SmartProspect: No match above ${minMatchConfidence}% confidence`;
-                return result;
-            }
-            // Fetch email for matched contact (COSTS CREDITS)
-            const fetchResponse = await client.fetch([matchResult.smartProspectContact.id]);
-            if (fetchResponse.success && fetchResponse.data.list.length > 0) {
-                const enrichedContact = fetchResponse.data.list[0];
-                if (enrichedContact.email) {
-                    result.emails.push({
-                        email: enrichedContact.email,
-                        source: 'smartprospect',
-                        confidence: matchResult.confidence,
-                        type: 'business', // SmartProspect returns business emails
-                        verified: enrichedContact.verificationStatus === 'verified',
-                        deliverability: enrichedContact.emailDeliverability,
-                        metadata: {
-                            matchQuality: matchResult.quality,
-                            matchedFields: matchResult.matchedFields,
-                            smartProspectId: enrichedContact.id,
-                            company: enrichedContact.company?.name,
-                            title: enrichedContact.title,
-                        },
-                    });
-                    result.success = true;
-                }
+        }
+        if (searchResponse.data.list.length === 0) {
+            return null; // No candidates found, but not an error
+        }
+        // Find best match
+        const matchResult = findBestMatch(contact, searchResponse.data.list, {
+            minConfidence: minMatchConfidence,
+            fuzzyNames: true,
+            fuzzyCompany: true,
+        });
+        if (!matchResult) {
+            return null; // No good match, but not an error
+        }
+        // Extract company domain from matched contact (SmartProspect provides this!)
+        const companyWebsite = matchResult.smartProspectContact.company?.website;
+        let discoveredDomain = null;
+        if (companyWebsite) {
+            // Clean up the domain (remove protocol, www, trailing slashes)
+            discoveredDomain = companyWebsite
+                .replace(/^(https?:\/\/)?(www\.)?/, '')
+                .split('/')[0]
+                .toLowerCase();
+        }
+        // Fetch email for matched contact
+        const fetchResponse = await client.fetch([matchResult.smartProspectContact.id]);
+        if (fetchResponse.success && fetchResponse.data.list.length > 0) {
+            const enrichedContact = fetchResponse.data.list[0];
+            if (enrichedContact.email) {
+                addEmail({
+                    email: enrichedContact.email,
+                    source: 'smartprospect',
+                    confidence: matchResult.confidence,
+                    type: 'business',
+                    verified: enrichedContact.verificationStatus === 'verified',
+                    deliverability: enrichedContact.emailDeliverability,
+                    metadata: {
+                        matchQuality: matchResult.quality,
+                        matchedFields: matchResult.matchedFields,
+                        smartProspectId: enrichedContact.id,
+                        company: enrichedContact.company?.name,
+                        companyWebsite: companyWebsite,
+                        title: enrichedContact.title,
+                    },
+                });
             }
         }
-        catch (err) {
-            result.error = result.error
-                ? `${result.error}; SmartProspect error: ${err instanceof Error ? err.message : 'Unknown error'}`
-                : `SmartProspect error: ${err instanceof Error ? err.message : 'Unknown error'}`;
+        return discoveredDomain;
+    }
+    catch (err) {
+        result.errors?.push(`SmartProspect: ${err instanceof Error ? err.message : 'Unknown error'}`);
+        return null;
+    }
+}
+/**
+ * Query pattern guessing with MX verification
+ */
+async function queryPatternGuessing(contact, companyDomain, addEmail, result) {
+    try {
+        // Import construct provider dynamically to avoid circular deps
+        const { createConstructProvider } = await Promise.resolve().then(() => __importStar(require('./providers/construct')));
+        const constructProvider = createConstructProvider({ maxAttempts: 6, timeoutMs: 3000 });
+        const constructResult = await constructProvider({
+            firstName: contact.firstName,
+            lastName: contact.lastName,
+            domain: companyDomain,
+        });
+        if (constructResult && 'emails' in constructResult && constructResult.emails.length > 0) {
+            for (const emailData of constructResult.emails) {
+                addEmail({
+                    email: emailData.email,
+                    source: 'pattern',
+                    confidence: emailData.confidence ?? 50,
+                    type: 'business',
+                    verified: emailData.verified ?? false,
+                    isCatchAll: emailData.isCatchAll,
+                    metadata: emailData.metadata,
+                });
+            }
         }
     }
-    // Sort emails by confidence (highest first)
-    result.emails.sort((a, b) => b.confidence - a.confidence);
-    return result;
+    catch (err) {
+        result.errors?.push(`Pattern: ${err instanceof Error ? err.message : 'Unknown error'}`);
+    }
 }
 /**
  * Get emails for multiple LinkedIn contacts in batch
  *
- * Processes contacts sequentially to avoid rate limits.
+ * Processes contacts with controlled concurrency to balance speed and rate limits.
+ * Accepts either LinkedInContact[] or SalesLeadSearchResult[] directly from Sales Nav search.
  */
-async function getEmailsForLinkedInContactsBatch(contacts, config, options = {}) {
-    const { delayMs = 200, onProgress, ...lookupOptions } = options;
-    const results = [];
-    for (let i = 0; i < contacts.length; i++) {
-        const result = await getEmailsForLinkedInContact(contacts[i], config, lookupOptions);
-        results.push(result);
-        if (onProgress) {
-            onProgress(i + 1, contacts.length, result);
-        }
-        // Delay between requests (except for last one)
-        if (i < contacts.length - 1 && delayMs > 0) {
+async function getEmailsForLinkedInContactsBatch(contactsOrLeads, config, options = {}) {
+    const { delayMs = 100, concurrency = 3, onProgress, ...lookupOptions } = options;
+    const results = new Array(contactsOrLeads.length);
+    let completed = 0;
+    // Process in batches with concurrency limit
+    for (let i = 0; i < contactsOrLeads.length; i += concurrency) {
+        const batch = contactsOrLeads.slice(i, i + concurrency);
+        const batchPromises = batch.map(async (contactOrLead, batchIndex) => {
+            const result = await getEmailsForLinkedInContact(contactOrLead, config, lookupOptions);
+            const globalIndex = i + batchIndex;
+            results[globalIndex] = result;
+            completed++;
+            if (onProgress) {
+                onProgress(completed, contactsOrLeads.length, result);
+            }
+            return result;
+        });
+        await Promise.all(batchPromises);
+        // Delay between batches (except for last batch)
+        if (i + concurrency < contactsOrLeads.length && delayMs > 0) {
             await new Promise((r) => setTimeout(r, delayMs));
         }
     }

package/dist/parsers/company-parser.js

@@ -42,7 +42,7 @@ function parseCompany(raw) {
             data?.universalName ||
             r?.universalName),
         name: (miniCompany?.name || data?.name || r?.name),
-        websiteUrl: (data?.websiteUrl || r?.websiteUrl),
+        websiteUrl: (data?.websiteUrl || data?.website || r?.websiteUrl || r?.website),
         description: (data?.description || r?.description),
         sizeLabel: (typeof data?.employeeCountRange === "string"
             ? data.employeeCountRange

package/dist/types.d.ts

@@ -119,6 +119,9 @@ export interface LinkedInSpotlightBadge {
     }>;
 }
 export interface SalesLeadSearchResult {
+    firstName?: string;
+    lastName?: string;
+    fullName?: string;
     name?: string;
     headline?: string;
     imageUrl?: string;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "linkedin-secret-sauce",
-  "version": "0.8.0",
+  "version": "0.10.0",
   "description": "Private LinkedIn Sales Navigator client with automatic cookie management",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",