linkedin-secret-sauce 0.8.0 → 0.9.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, 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/matching.d.ts

@@ -239,6 +239,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' | 'pattern' | 'hunter' | 'apollo';
 /**
  * Email result from unified lookup
  */
@@ -246,7 +250,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 +259,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 +275,28 @@ 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[];
+    /** 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) */
+    companyDomain?: string;
+    /** Hunter configuration (PAID - last resort) */
+    hunter?: {
+        apiKey: string;
+    };
+    /** Apollo configuration (PAID - last resort) */
+    apollo?: {
+        apiKey: string;
+    };
 }
 /**
  * Options for unified email lookup
@@ -290,19 +306,24 @@ export interface GetEmailsOptions {
     skipLdd?: boolean;
     /** Skip SmartProspect lookup (default: false) */
     skipSmartProspect?: boolean;
+    /** Skip email pattern guessing (default: false) */
+    skipPatternGuessing?: 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 +331,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,13 +349,15 @@ 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' },
  *   // ]
  * }
  * ```
@@ -340,11 +366,13 @@ export declare function getEmailsForLinkedInContact(contact: LinkedInContact, co
 /**
  * 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.
  */
 export declare function getEmailsForLinkedInContactsBatch(contacts: LinkedInContact[], config: GetEmailsConfig, options?: GetEmailsOptions & {
-    /** Delay between requests in ms (default: 200) */
+    /** 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,6 +5,39 @@
  * 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.calculateMatchConfidence = calculateMatchConfidence;
 exports.classifyMatchQuality = classifyMatchQuality;
@@ -629,11 +662,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 +673,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 +691,286 @@ 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;
+    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
+    const companyDomain = 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);
+        }
     };
     // ==========================================================================
-    // 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,
-                    });
-                }
-                result.success = true;
-            }
-        }
-        catch (err) {
-            // LDD failed, continue to SmartProspect
-            result.error = `LDD error: ${err instanceof Error ? err.message : 'Unknown error'}`;
-        }
+        freeProviderPromises.push(queryLdd(contact, config.ldd, numericLinkedInId, addEmail, result));
     }
+    // SmartProspect lookup (FREE for FlexIQ)
+    if (!skipSmartProspect && config.smartprospect) {
+        result.providersQueried.push('smartprospect');
+        freeProviderPromises.push(querySmartProspect(contact, config.smartprospect, minMatchConfidence, includeCompany, addEmail, result));
+    }
+    // Wait for both free providers
+    await Promise.all(freeProviderPromises);
+    // Check if we have good enough results
+    const bestConfidence = result.emails.length > 0
+        ? Math.max(...result.emails.map(e => e.confidence))
+        : 0;
     // ==========================================================================
-    // Step 2: Fall back to SmartProspect if LDD didn't find emails (PAID)
+    // Phase 2: Email pattern guessing with MX verification (FREE)
     // ==========================================================================
-    if (!result.success && !skipSmartProspect && config.smartprospect) {
-        result.providersQueried.push('smartprospect');
+    if (!skipPatternGuessing && companyDomain && bestConfidence < 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,
+        pattern: 2,
+        hunter: 3,
+        apollo: 4,
+    };
+    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) {
+        // Extract domain from URL
         try {
-            const client = (0, smartprospect_1.createSmartProspectClient)(config.smartprospect);
-            if (!client) {
-                result.error = 'Failed to create SmartProspect client';
-                return result;
+            const url = website.startsWith('http') ? website : `https://${website}`;
+            return new URL(url).hostname.replace(/^www\./, '');
+        }
+        catch {
+            // If URL parsing fails, try as-is
+            return website.replace(/^(https?:\/\/)?(www\.)?/, '').split('/')[0];
+        }
+    }
+    return 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
+ */
+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;
+        }
+        // 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; // 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; // No good match, but not an error
+        }
+        // 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,
+                        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'}`;
+    }
+    catch (err) {
+        result.errors?.push(`SmartProspect: ${err instanceof Error ? err.message : 'Unknown error'}`);
+    }
+}
+/**
+ * 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.
  */
 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) {
+    const { delayMs = 100, concurrency = 3, onProgress, ...lookupOptions } = options;
+    const results = new Array(contacts.length);
+    let completed = 0;
+    // Process in batches with concurrency limit
+    for (let i = 0; i < contacts.length; i += concurrency) {
+        const batch = contacts.slice(i, i + concurrency);
+        const batchPromises = batch.map(async (contact, batchIndex) => {
+            const result = await getEmailsForLinkedInContact(contact, config, lookupOptions);
+            const globalIndex = i + batchIndex;
+            results[globalIndex] = result;
+            completed++;
+            if (onProgress) {
+                onProgress(completed, contacts.length, result);
+            }
+            return result;
+        });
+        await Promise.all(batchPromises);
+        // Delay between batches (except for last batch)
+        if (i + concurrency < contacts.length && delayMs > 0) {
             await new Promise((r) => setTimeout(r, delayMs));
         }
     }

package/package.json

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