linkedin-secret-sauce 0.7.2 → 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, type LinkedInContact, type MatchResult, type MatchOptions, type LinkedInEnrichmentResult, type LinkedInEnrichmentOptions, } 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/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.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.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");
@@ -287,3 +287,6 @@ Object.defineProperty(exports, "parseLinkedInSearchResponse", { enumerable: true
 Object.defineProperty(exports, "enrichLinkedInContact", { enumerable: true, get: function () { return matching_1.enrichLinkedInContact; } });
 Object.defineProperty(exports, "enrichLinkedInContactsBatch", { enumerable: true, get: function () { return matching_1.enrichLinkedInContactsBatch; } });
 Object.defineProperty(exports, "createLinkedInEnricher", { enumerable: true, get: function () { return matching_1.createLinkedInEnricher; } });
+// 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; } });

package/dist/enrichment/matching.d.ts

@@ -4,7 +4,7 @@
  * Matches contacts between LinkedIn Sales Navigator and SmartProspect
  * to find the same person across both platforms.
  */
-import type { SmartProspectContact, SmartProspectConfig, SmartProspectFetchResponse } from './types';
+import type { SmartProspectContact, SmartProspectConfig, SmartProspectFetchResponse, LddConfig } from './types';
 import { type SmartProspectClient } from './providers/smartprospect';
 /**
  * LinkedIn Sales Navigator contact (simplified from API response)
@@ -239,3 +239,140 @@ 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
+ */
+export interface EmailResult {
+    /** The email address */
+    email: string;
+    /** Which provider found this email */
+    source: EmailSource;
+    /** Confidence score (0-100) */
+    confidence: number;
+    /** Email type classification */
+    type: 'business' | 'personal' | 'unknown';
+    /** Whether the email was verified */
+    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>;
+}
+/**
+ * Result from unified email lookup
+ */
+export interface GetEmailsResult {
+    /** Whether lookup was successful (found at least one email) */
+    success: boolean;
+    /** All found emails, sorted by confidence (highest first) */
+    emails: EmailResult[];
+    /** Numeric LinkedIn ID extracted from objectUrn */
+    numericLinkedInId: string | null;
+    /** Which providers were queried */
+    providersQueried: EmailSource[];
+    /** Error message if any provider failed */
+    errors?: string[];
+}
+/**
+ * Configuration for unified email lookup
+ */
+export interface GetEmailsConfig {
+    /** LDD configuration (FREE - your ~500M database) */
+    ldd?: LddConfig;
+    /** 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
+ */
+export interface GetEmailsOptions {
+    /** Skip LDD lookup (default: false) */
+    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
+ *
+ * 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
+ * import { getEmailsForLinkedInContact } from 'linkedin-secret-sauce';
+ *
+ * // From your LinkedIn Sales Nav search result
+ * const contact = {
+ *   objectUrn: 'urn:li:member:307567',  // Stable ID for LDD
+ *   firstName: 'Jim',
+ *   lastName: 'DeMaio',
+ *   currentPositions: [{
+ *     companyName: 'Acme Corp',
+ *     companyUrnResolutionResult: { website: 'acme.com' }
+ *   }]
+ * };
+ *
+ * const result = await getEmailsForLinkedInContact(contact, {
+ *   ldd: {
+ *     apiUrl: process.env.LDD_API_URL,
+ *     apiToken: process.env.LDD_API_TOKEN,
+ *   },
+ *   smartprospect: {
+ *     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: 'j.demaio@acme.com', source: 'smartprospect', confidence: 85, type: 'business' },
+ *   // ]
+ * }
+ * ```
+ */
+export declare function getEmailsForLinkedInContact(contact: LinkedInContact, config: GetEmailsConfig, options?: GetEmailsOptions): Promise<GetEmailsResult>;
+/**
+ * Get emails for multiple LinkedIn contacts in batch
+ *
+ * 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: 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;
@@ -15,6 +48,8 @@ exports.parseLinkedInSearchResponse = parseLinkedInSearchResponse;
 exports.enrichLinkedInContact = enrichLinkedInContact;
 exports.enrichLinkedInContactsBatch = enrichLinkedInContactsBatch;
 exports.createLinkedInEnricher = createLinkedInEnricher;
+exports.getEmailsForLinkedInContact = getEmailsForLinkedInContact;
+exports.getEmailsForLinkedInContactsBatch = getEmailsForLinkedInContactsBatch;
 const smartprospect_1 = require("./providers/smartprospect");
 const ldd_1 = require("./providers/ldd");
 // =============================================================================
@@ -624,3 +659,320 @@ function createLinkedInEnricher(smartProspectConfig, defaultOptions = {}) {
         },
     };
 }
+/**
+ * Get emails for a LinkedIn contact - UNIFIED FUNCTION
+ *
+ * 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
+ * import { getEmailsForLinkedInContact } from 'linkedin-secret-sauce';
+ *
+ * // From your LinkedIn Sales Nav search result
+ * const contact = {
+ *   objectUrn: 'urn:li:member:307567',  // Stable ID for LDD
+ *   firstName: 'Jim',
+ *   lastName: 'DeMaio',
+ *   currentPositions: [{
+ *     companyName: 'Acme Corp',
+ *     companyUrnResolutionResult: { website: 'acme.com' }
+ *   }]
+ * };
+ *
+ * const result = await getEmailsForLinkedInContact(contact, {
+ *   ldd: {
+ *     apiUrl: process.env.LDD_API_URL,
+ *     apiToken: process.env.LDD_API_TOKEN,
+ *   },
+ *   smartprospect: {
+ *     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: 'j.demaio@acme.com', source: 'smartprospect', confidence: 85, type: 'business' },
+ *   // ]
+ * }
+ * ```
+ */
+async function getEmailsForLinkedInContact(contact, config, 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);
+        }
+    };
+    // ==========================================================================
+    // 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');
+        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;
+    // ==========================================================================
+    // Phase 2: Email pattern guessing with MX verification (FREE)
+    // ==========================================================================
+    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 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,
+                });
+            }
+        }
+    }
+    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) {
+                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) {
+            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.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,
+                });
+            }
+        }
+    }
+    catch (err) {
+        result.errors?.push(`Pattern: ${err instanceof Error ? err.message : 'Unknown error'}`);
+    }
+}
+/**
+ * Get emails for multiple LinkedIn contacts in batch
+ *
+ * Processes contacts with controlled concurrency to balance speed and rate limits.
+ */
+async function getEmailsForLinkedInContactsBatch(contacts, config, options = {}) {
+    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));
+        }
+    }
+    return results;
+}

package/package.json

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