salesprompter-cli 0.1.43 → 0.1.45

package/dist/cli.js

@@ -1,6 +1,7 @@
 #!/usr/bin/env node
 import { spawn } from "node:child_process";
 import { access, appendFile, mkdir, readFile, readdir, stat, writeFile } from "node:fs/promises";
+import { createServer } from "node:http";
 import { createRequire } from "node:module";
 import os from "node:os";
 import path from "node:path";
@@ -26,10 +27,10 @@ import { InstantlySyncProvider } from "./instantly.js";
 import { backfillLinkedInCompanies } from "./linkedin-companies.js";
 import { parseLinkedInCompanyPage } from "./linkedin-companies.js";
 import { crawlLinkedInProductCategory } from "./linkedin-products.js";
-import { claimValidatedSalesNavigatorSessionCookieForCli, createLinkedInSessionSupabaseClient, resolveConfiguredEnvValue } from "./linkedin-session.js";
+import { claimLinkedInSessionCookieForCli, claimValidatedSalesNavigatorSessionCookieForCli, createLinkedInSessionSupabaseClient, recordLinkedInSessionCookieAudit, resolveConfiguredEnvValue } from "./linkedin-session.js";
 import { buildLeadlistsFunnelQueries } from "./leadlists-funnel.js";
 import { readJsonFile, splitCsv, writeJsonFile, writeTextFile } from "./io.js";
-import { buildSalesNavigatorCrawlPreview, createSalesNavigatorCrawlSeed, DEFAULT_SALES_NAVIGATOR_ACCOUNT_CRAWL_DIMENSIONS, DEFAULT_SALES_NAVIGATOR_CRAWL_DIMENSIONS, buildSalesNavigatorPeopleSearchUrl, buildSalesNavigatorPeopleSlice, deriveSalesNavigatorTitleQuerySeeds, executeSalesNavigatorAdaptiveCrawl, expandSalesNavigatorCrawlAttempt, SalesNavigatorCrawlStopError, SalesNavigatorSliceTooBroadError } from "./sales-navigator.js";
+import { buildSalesNavigatorCrawlPreview, buildSalesNavigatorAccountQuery, createSalesNavigatorCrawlSeed, DEFAULT_SALES_NAVIGATOR_ACCOUNT_CRAWL_DIMENSIONS, DEFAULT_SALES_NAVIGATOR_CRAWL_DIMENSIONS, buildSalesNavigatorPeopleSearchUrl, buildSalesNavigatorPeopleSlice, deriveSalesNavigatorTitleQuerySeeds, executeSalesNavigatorAdaptiveCrawl, expandSalesNavigatorCrawlAttempt, SalesNavigatorCrawlStopError, SalesNavigatorSliceTooBroadError } from "./sales-navigator.js";
 import { buildSalesNavigatorHistoricalBackfillPlan, ensureSalesNavigatorPeopleCount, resolveSalesNavigatorHistoricalBackfillConfig, resolveSalesNavigatorHistoricalBackfillResumeState, resolveSalesNavigatorHistoricalBackfillOrgId, salesNavigatorHistoricalBackfillDefaults } from "./salesnav-backfill.js";
 const require = createRequire(import.meta.url);
 const { version: packageVersion } = require("../package.json");
@@ -123,6 +124,92 @@ const LinkedInCompanyBackfillStatusResponseSchema = z.object({
     failureCode: z.string().nullable().optional(),
     failureMessage: z.string().nullable().optional()
 });
+const AffiliateCampaignLaunchResponseSchema = z.object({
+    status: z.enum(["ok", "partial"]),
+    dryRun: z.boolean(),
+    product: z.object({
+        domain: z.string().min(1),
+        affiliateLink: z.string().url()
+    }),
+    audience: z.object({
+        sourceType: z.enum(["sales_navigator_people", "linkedin_content"]),
+        linkedInUrl: z.string().url(),
+        maxResults: z.number().int().positive(),
+        peoplePreview: z.array(z.record(z.string(), z.unknown())).optional(),
+        postsPreview: z.array(z.record(z.string(), z.unknown())).optional()
+    }),
+    extraction: z
+        .object({
+        provider: z.string().min(1),
+        monitorId: z.string().min(1).optional(),
+        agentId: z.string().min(1).optional(),
+        containerId: z.string().min(1).optional()
+    })
+        .passthrough()
+        .optional(),
+    previewUrl: z.string().nullable().optional(),
+    next: z.string().optional()
+});
+const AffiliateCampaignLocalResultSchema = z
+    .object({
+    profileUrl: z.string().min(1),
+})
+    .passthrough();
+const DatabaseTimestampSchema = z.string().min(1);
+const AffiliateOutreachRunSchema = z.object({
+    id: z.string().uuid(),
+    audience_run_id: z.string().uuid(),
+    organization_id: z.string().min(1),
+    status: z.enum(["preparing", "ready", "active", "failed"]),
+    provider: z.literal("instantly"),
+    instantly_campaign_id: z.string().min(1).nullable(),
+    instantly_campaign_name: z.string().min(1).nullable(),
+    sequence: z.array(z.object({
+        step: z.number().int().positive(),
+        subject: z.string(),
+        body: z.string(),
+        rationale: z.string(),
+        delayDays: z.number().int().nonnegative(),
+        variants: z
+            .array(z.object({
+            subject: z.string(),
+            body: z.string()
+        }))
+            .min(1)
+            .max(3)
+            .optional()
+    })),
+    enriched_leads: z.array(z.object({
+        rowIndex: z.number().int().nonnegative(),
+        fullName: z.string().min(1),
+        firstName: z.string().min(1),
+        lastName: z.string().min(1),
+        jobTitle: z.string().nullable(),
+        companyName: z.string().min(1),
+        companyDomain: z.string().min(1),
+        location: z.string().nullable(),
+        profileUrl: z.string().nullable(),
+        email: z.string().email(),
+        emailScore: z.number().min(0).max(100),
+        acceptAll: z.boolean(),
+        emailSource: z.enum(["hunter", "phantombuster"]).optional()
+    })),
+    stats: z.record(z.string(), z.unknown()),
+    settings: z.record(z.string(), z.unknown()),
+    error_message: z.string().nullable(),
+    activated_at: DatabaseTimestampSchema.nullable(),
+    created_at: DatabaseTimestampSchema,
+    updated_at: DatabaseTimestampSchema
+});
+const AffiliateOutreachResponseSchema = z.object({
+    status: z.literal("ok"),
+    outreach: AffiliateOutreachRunSchema
+});
+const AffiliateOutreachEnrichStartResponseSchema = z.object({
+    status: z.literal("accepted"),
+    audienceRunId: z.string().uuid(),
+    workflowRunId: z.string().min(1)
+});
 const SalesNavigatorLocalImportResponseSchema = z.object({
     status: z.literal("ok"),
     runId: z.string().min(1),
@@ -398,7 +485,15 @@ const cliPacks = [
         slug: "outreach",
         title: "Outreach",
         summary: "Prepare and sync qualified leads into downstream systems.",
-        commands: ["sync:outreach", "sync:crm"],
+        commands: [
+            "affiliate:run",
+            "affiliate:status",
+            "affiliate:enrich",
+            "affiliate:activate",
+            "affiliate:launch",
+            "sync:outreach",
+            "sync:crm"
+        ],
         installStatus: "included"
     }
 ];
@@ -443,6 +538,11 @@ const helpVisibleCommandNames = new Set([
     "leads:enrich",
     "leads:score",
     "leads:pipeline",
+    "affiliate:run",
+    "affiliate:status",
+    "affiliate:enrich",
+    "affiliate:activate",
+    "affiliate:launch",
     "sync:crm",
     "sync:outreach",
     "linkedin-companies:backfill",
@@ -1300,9 +1400,74 @@ function normalizeLinkedInDirectLookupCookieHeader(cookie) {
     }
     return `li_at=${trimmed}`;
 }
+function mergeLinkedInCookieHeader(cookieHeader, setCookieHeaders) {
+    const cookies = new Map();
+    for (const part of cookieHeader.split(";")) {
+        const separatorIndex = part.indexOf("=");
+        if (separatorIndex <= 0) {
+            continue;
+        }
+        cookies.set(part.slice(0, separatorIndex).trim(), part.slice(separatorIndex + 1).trim());
+    }
+    for (const setCookieHeader of setCookieHeaders) {
+        const firstPart = setCookieHeader.split(";", 1)[0] ?? "";
+        const separatorIndex = firstPart.indexOf("=");
+        if (separatorIndex <= 0) {
+            continue;
+        }
+        cookies.set(firstPart.slice(0, separatorIndex).trim(), firstPart.slice(separatorIndex + 1).trim());
+    }
+    return [...cookies.entries()]
+        .map(([name, value]) => `${name}=${value}`)
+        .join("; ");
+}
+async function bootstrapLinkedInAccountSearchConfig(params) {
+    const cookie = normalizeLinkedInDirectLookupCookieHeader(params.sessionCookie);
+    const existingCsrfToken = params.csrfToken || deriveCsrfTokenFromCookie(cookie);
+    if (existingCsrfToken) {
+        return {
+            csrfToken: existingCsrfToken,
+            identity: params.identity,
+            cookie,
+            userAgent: params.userAgent,
+        };
+    }
+    const response = await fetch(params.queryUrl, {
+        redirect: "manual",
+        headers: {
+            accept: "text/html,application/xhtml+xml",
+            cookie,
+            "user-agent": params.userAgent,
+        },
+    });
+    if (response.status === 429 || response.status === 999) {
+        throw new Error("Sales Navigator is rate-limited while bootstrapping the Account Search API session.");
+    }
+    if (response.status >= 300 && response.status < 400) {
+        await response.arrayBuffer();
+        return null;
+    }
+    const headersWithSetCookie = response.headers;
+    const setCookieHeaders = headersWithSetCookie.getSetCookie?.() ??
+        (response.headers.get("set-cookie")
+            ? [response.headers.get("set-cookie")]
+            : []);
+    const refreshedCookie = mergeLinkedInCookieHeader(cookie, setCookieHeaders);
+    await response.arrayBuffer();
+    const csrfToken = deriveCsrfTokenFromCookie(refreshedCookie);
+    if (!csrfToken) {
+        return null;
+    }
+    return {
+        csrfToken,
+        identity: params.identity,
+        cookie: refreshedCookie,
+        userAgent: params.userAgent,
+    };
+}
 function parseLocalLinkedInExtensionTokenLog(content) {
     const matches = [
-        ...content.matchAll(/\{"csrfToken":"([^"]+)","extractedFrom":"sales-api\/salesApiLeadSearch"[\s\S]*?"linkedInIdentity":"([^"]+)"[\s\S]*?"sessionCookie":"([\s\S]*?)","syncStatus":"(success|captured)"[\s\S]*?"userAgent":"([^"]+)"\}/g)
+        ...content.matchAll(/\{"csrfToken":"([^"]+)","extractedFrom":"sales-api\/salesApi(?:Lead|Account)Search"[\s\S]*?"linkedInIdentity":"([^"]+)"[\s\S]*?"sessionCookie":"([\s\S]*?)","syncStatus":"(success|captured)"[\s\S]*?"userAgent":"([^"]+)"\}/g)
     ];
     const last = matches.at(-1);
     if (!last) {
@@ -1331,6 +1496,21 @@ async function readLocalLinkedInExtensionTokenLog(filePath) {
         return null;
     }
 }
+async function sortPathsByMostRecentlyModified(paths) {
+    const candidates = await Promise.all(paths.map(async (filePath) => {
+        try {
+            const fileStat = await stat(filePath);
+            return { filePath, modifiedAtMs: fileStat.mtimeMs };
+        }
+        catch {
+            return { filePath, modifiedAtMs: 0 };
+        }
+    }));
+    return candidates
+        .sort((left, right) => right.modifiedAtMs - left.modifiedAtMs ||
+        right.filePath.localeCompare(left.filePath))
+        .map((candidate) => candidate.filePath);
+}
 async function listChromeExtensionTokenLogCandidates() {
     const overrideFile = normalizeLookupWhitespace(process.env.SALESPROMPTER_LINKEDIN_EXTENSION_TOKENS_LOG_PATH);
     if (overrideFile) {
@@ -1340,11 +1520,9 @@ async function listChromeExtensionTokenLogCandidates() {
     if (overrideDir) {
         try {
             const files = await readdir(overrideDir);
-            return files
+            return sortPathsByMostRecentlyModified(files
                 .filter((file) => file.endsWith(".log") || file.endsWith(".ldb"))
-                .map((file) => path.join(overrideDir, file))
-                .sort()
-                .reverse();
+                .map((file) => path.join(overrideDir, file)));
         }
         catch {
             return [];
@@ -1382,7 +1560,7 @@ async function listChromeExtensionTokenLogCandidates() {
                     continue;
                 }
                 for (const file of files) {
-                    if (!file.endsWith(".log")) {
+                    if (!file.endsWith(".log") && !file.endsWith(".ldb")) {
                         continue;
                     }
                     paths.push(path.join(extensionDir, file));
@@ -1390,7 +1568,7 @@ async function listChromeExtensionTokenLogCandidates() {
             }
         }
     }
-    return paths.sort().reverse();
+    return sortPathsByMostRecentlyModified(paths);
 }
 async function readLocalLinkedInExtensionDirectLookupConfig() {
     const candidates = await listChromeExtensionTokenLogCandidates();
@@ -1464,11 +1642,12 @@ async function readStoredLinkedInDirectLookupConfig() {
         return null;
     }
     const lookupResult = await supabase
-        .from("linkedin_session_cookies")
+        .from("salesprompter_linkedin_session_cookies")
         .select("metadata")
         .eq("session_cookie_sha256", claimed.sessionCookieSha256)
         .maybeSingle();
-    if (lookupResult.error && !/linkedin_session_cookies/.test(lookupResult.error.message)) {
+    if (lookupResult.error &&
+        !/salesprompter_linkedin_session_cookies/.test(lookupResult.error.message)) {
         throw new Error(`Failed to read stored LinkedIn session metadata: ${lookupResult.error.message}`);
     }
     const metadata = lookupResult.data?.metadata;
@@ -1488,7 +1667,195 @@ async function readStoredLinkedInDirectLookupConfig() {
         userAgent
     };
 }
+async function readStoredLinkedInAccountSearchConfig(queryUrl) {
+    const supabase = createLinkedInSessionSupabaseClient();
+    if (!supabase) {
+        return null;
+    }
+    let lastFailure = "No Account Search API-capable LinkedIn session was available.";
+    const configuredAttempts = Number(process.env.SALESPROMPTER_ACCOUNT_SEARCH_SESSION_ATTEMPTS);
+    const maxAttempts = Number.isFinite(configuredAttempts) && configuredAttempts > 0
+        ? Math.min(64, Math.trunc(configuredAttempts))
+        : 24;
+    for (let attempt = 1; attempt <= maxAttempts; attempt += 1) {
+        const claimed = await claimLinkedInSessionCookieForCli({
+            source: "cli_account_search",
+            supabase,
+        });
+        if (!claimed) {
+            return null;
+        }
+        const lookupResult = await supabase
+            .from("salesprompter_linkedin_session_cookies")
+            .select("metadata")
+            .eq("session_cookie_sha256", claimed.sessionCookieSha256)
+            .maybeSingle();
+        if (lookupResult.error) {
+            throw new Error(`Failed to read stored LinkedIn Account Search metadata: ${lookupResult.error.message}`);
+        }
+        const metadata = lookupResult.data?.metadata;
+        const identity = extractStoredLinkedInLookupValue(metadata, "linkedInIdentity");
+        const csrfToken = extractStoredLinkedInLookupValue(metadata, "csrfToken") ||
+            deriveCsrfTokenFromCookie(claimed.sessionCookie);
+        const userAgent = process.env.SALESPROMPTER_LINKEDIN_USER_AGENT?.trim() ||
+            extractStoredLinkedInLookupValue(metadata, "userAgent") ||
+            "Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/146.0.0.0 Safari/537.36";
+        let config = null;
+        try {
+            config = await bootstrapLinkedInAccountSearchConfig({
+                queryUrl,
+                sessionCookie: claimed.sessionCookie,
+                identity,
+                csrfToken,
+                userAgent,
+            });
+        }
+        catch (error) {
+            const message = error instanceof Error ? error.message : String(error);
+            if (/rate-limit/i.test(message)) {
+                throw error;
+            }
+            lastFailure = message;
+            await recordLinkedInSessionCookieAudit(supabase, {
+                sessionCookieSha256: claimed.sessionCookieSha256,
+                source: "cli_account_search_api_preflight",
+                feedStatus: null,
+                salesNavigatorStatus: "error",
+                recruiterStatus: null,
+                productClass: "sales_navigator",
+                isActive: true,
+                inactiveReason: null,
+                validationError: message,
+                details: {
+                    attemptNumber: attempt,
+                    capability: "account_search_api_bootstrap",
+                },
+            });
+            continue;
+        }
+        if (!config) {
+            lastFailure =
+                "Stored LinkedIn session could not bootstrap Account Search credentials.";
+            await recordLinkedInSessionCookieAudit(supabase, {
+                sessionCookieSha256: claimed.sessionCookieSha256,
+                source: "cli_account_search_api_preflight",
+                feedStatus: null,
+                salesNavigatorStatus: "error",
+                recruiterStatus: null,
+                productClass: "sales_navigator",
+                isActive: false,
+                inactiveReason: "salesnav_account_search_bootstrap_failed",
+                validationError: "salesnav_account_search_bootstrap_failed",
+                details: {
+                    attemptNumber: attempt,
+                    hasStoredIdentity: Boolean(identity),
+                    hasStoredCsrfToken: Boolean(csrfToken),
+                },
+            });
+            continue;
+        }
+        const probe = await probeLinkedInAccountSearchConfig(queryUrl, config);
+        if (probe.status === "ok") {
+            await recordLinkedInSessionCookieAudit(supabase, {
+                sessionCookieSha256: claimed.sessionCookieSha256,
+                source: "cli_account_search_api_preflight",
+                feedStatus: null,
+                salesNavigatorStatus: "ok",
+                recruiterStatus: null,
+                productClass: "sales_navigator",
+                isActive: true,
+                inactiveReason: null,
+                validationError: null,
+                details: {
+                    attemptNumber: attempt,
+                    statusCode: probe.statusCode,
+                    capability: "account_search_api",
+                },
+            });
+            return config;
+        }
+        lastFailure =
+            probe.validationError ??
+                `Sales Navigator Account Search preflight returned ${probe.status}.`;
+        if (probe.status === "rate_limited") {
+            await recordLinkedInSessionCookieAudit(supabase, {
+                sessionCookieSha256: claimed.sessionCookieSha256,
+                source: "cli_account_search_api_preflight",
+                feedStatus: null,
+                salesNavigatorStatus: "rate_limited",
+                recruiterStatus: null,
+                productClass: "sales_navigator",
+                isActive: true,
+                inactiveReason: null,
+                validationError: probe.validationError,
+                details: {
+                    attemptNumber: attempt,
+                    statusCode: probe.statusCode,
+                    capability: "account_search_api",
+                },
+            });
+            throw new Error("Sales Navigator Account Search API is rate-limited. The CLI stopped without retrying this session.");
+        }
+        if (probe.status === "sales_seat_required") {
+            await recordLinkedInSessionCookieAudit(supabase, {
+                sessionCookieSha256: claimed.sessionCookieSha256,
+                source: "cli_account_search_api_preflight",
+                feedStatus: null,
+                salesNavigatorStatus: "upsell",
+                recruiterStatus: null,
+                productClass: null,
+                isActive: false,
+                inactiveReason: "salesnav_account_search_seat_required",
+                validationError: probe.validationError,
+                details: {
+                    attemptNumber: attempt,
+                    statusCode: probe.statusCode,
+                    capability: "account_search_api",
+                },
+            });
+            continue;
+        }
+        if (probe.status === "unauthorized" || probe.status === "forbidden") {
+            await recordLinkedInSessionCookieAudit(supabase, {
+                sessionCookieSha256: claimed.sessionCookieSha256,
+                source: "cli_account_search_api_preflight",
+                feedStatus: null,
+                salesNavigatorStatus: "logged_out",
+                recruiterStatus: null,
+                productClass: "sales_navigator",
+                isActive: false,
+                inactiveReason: "salesnav_account_search_unauthorized",
+                validationError: probe.validationError,
+                details: {
+                    attemptNumber: attempt,
+                    statusCode: probe.statusCode,
+                    capability: "account_search_api",
+                },
+            });
+            continue;
+        }
+        await recordLinkedInSessionCookieAudit(supabase, {
+            sessionCookieSha256: claimed.sessionCookieSha256,
+            source: "cli_account_search_api_preflight",
+            feedStatus: null,
+            salesNavigatorStatus: "error",
+            recruiterStatus: null,
+            productClass: "sales_navigator",
+            isActive: true,
+            inactiveReason: null,
+            validationError: probe.validationError,
+            details: {
+                attemptNumber: attempt,
+                statusCode: probe.statusCode,
+                capability: "account_search_api",
+                probeStatus: probe.status,
+            },
+        });
+    }
+    throw new Error(lastFailure);
+}
 let cachedLinkedInDirectLookupConfig = null;
+let cachedLinkedInAccountSearchConfig = null;
 async function readLinkedInDirectLookupConfig() {
     if (cachedLinkedInDirectLookupConfig) {
         return cachedLinkedInDirectLookupConfig;
@@ -1519,6 +1886,46 @@ async function readLinkedInDirectLookupConfig() {
     }
     throw new Error("Missing LinkedIn direct lookup session. Set LINKEDIN_CSRF_TOKEN, LINKEDIN_X_LI_IDENTITY, and LINKEDIN_SALES_NAV_COOKIE, or connect the Salesprompter Chrome extension to sync your LinkedIn session to salesprompter.ai.");
 }
+async function readLinkedInAccountSearchConfig(queryUrl) {
+    if (cachedLinkedInAccountSearchConfig) {
+        return cachedLinkedInAccountSearchConfig;
+    }
+    const envConfig = readLinkedInDirectLookupEnvConfig();
+    if (envConfig) {
+        const probe = await probeLinkedInAccountSearchConfig(queryUrl, envConfig);
+        assertLinkedInAccountSearchConfigProbe(probe);
+        cachedLinkedInAccountSearchConfig = envConfig;
+        return envConfig;
+    }
+    let storedError = null;
+    try {
+        const storedConfig = await readStoredLinkedInAccountSearchConfig(queryUrl);
+        if (storedConfig) {
+            cachedLinkedInAccountSearchConfig = storedConfig;
+            return storedConfig;
+        }
+    }
+    catch (error) {
+        storedError = error;
+        if (isExplicitLinkedInSessionVaultEnabled() ||
+            /rate-limit/i.test(error instanceof Error ? error.message : String(error))) {
+            throw error;
+        }
+    }
+    if (!shouldDisableLinkedInDirectLookupAutodiscovery()) {
+        const localExtensionConfig = await readLocalLinkedInExtensionDirectLookupConfig();
+        if (localExtensionConfig) {
+            const probe = await probeLinkedInAccountSearchConfig(queryUrl, localExtensionConfig);
+            assertLinkedInAccountSearchConfigProbe(probe);
+            cachedLinkedInAccountSearchConfig = localExtensionConfig;
+            return localExtensionConfig;
+        }
+    }
+    if (storedError) {
+        throw storedError;
+    }
+    throw new Error("Missing LinkedIn Account Search API session. Connect the Salesprompter Chrome extension or configure the Salesprompter session vault.");
+}
 function generateLinkedInSessionId() {
     return Array.from({ length: 22 }, () => "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789".charAt(Math.floor(Math.random() * 62))).join("");
 }
@@ -2198,6 +2605,203 @@ function normalizeLocalSalesNavigatorAccounts(responseBody, queryUrl) {
     }
     return accounts;
 }
+async function readLocalSalesNavigatorRawAccountInput(params) {
+    const filePath = path.resolve(params.filePath);
+    const content = await readFile(filePath, "utf8");
+    const accounts = [];
+    const seenAccounts = new Set();
+    const requestUrls = new Set();
+    let parsedLines = 0;
+    let parsedElements = 0;
+    let invalidElements = 0;
+    let duplicateAccounts = 0;
+    let filteredAccounts = 0;
+    const addElement = (element, requestUrl) => {
+        parsedElements += 1;
+        if (typeof element !== "object" || element === null || Array.isArray(element)) {
+            invalidElements += 1;
+            return;
+        }
+        const account = normalizeLocalSalesNavigatorAccount(element, requestUrl);
+        if (!account) {
+            invalidElements += 1;
+            return;
+        }
+        if (seenAccounts.has(account.accountKey)) {
+            duplicateAccounts += 1;
+            return;
+        }
+        seenAccounts.add(account.accountKey);
+        if (!salesNavigatorAccountMatchesLocationFilter(account, params.accountLocationFilter)) {
+            filteredAccounts += 1;
+            return;
+        }
+        accounts.push(account);
+    };
+    const lines = content.split(/\r?\n/);
+    for (let index = 0; index < lines.length; index += 1) {
+        const line = lines[index]?.trim() ?? "";
+        if (!line) {
+            continue;
+        }
+        parsedLines += 1;
+        let value;
+        try {
+            value = JSON.parse(line);
+        }
+        catch (error) {
+            throw new Error(`Raw Sales Navigator account input has invalid JSON on line ${index + 1}: ${error instanceof Error ? error.message : String(error)}`);
+        }
+        if (typeof value !== "object" || value === null || Array.isArray(value)) {
+            invalidElements += 1;
+            continue;
+        }
+        const record = value;
+        const requestUrlCandidate = [
+            record.queryUrl,
+            record.requestUrl,
+            record.slicedQueryUrl,
+        ].find((candidate) => typeof candidate === "string" && candidate.trim().length > 0);
+        const requestUrl = requestUrlCandidate?.trim() ?? params.sourceQueryUrl;
+        requestUrls.add(requestUrl);
+        if (Array.isArray(record.elements)) {
+            for (const element of record.elements) {
+                addElement(element, requestUrl);
+            }
+            continue;
+        }
+        if ("element" in record) {
+            addElement(record.element, requestUrl);
+            continue;
+        }
+        if ("account" in record) {
+            addElement(record.account, requestUrl);
+            continue;
+        }
+        if (record.type === "metadata") {
+            continue;
+        }
+        addElement(record, requestUrl);
+    }
+    const totalResults = params.reportedTotal ?? accounts.length;
+    const missingFromReported = Math.max(0, totalResults - accounts.length);
+    const complete = missingFromReported === 0;
+    return {
+        fetchResult: {
+            accounts,
+            filteredAccounts,
+            totalResults,
+            fetchedPages: requestUrls.size,
+            sourceQueryUrl: params.sourceQueryUrl,
+            pacing: {
+                startOffset: 0,
+                delayMinMs: 0,
+                delayMaxMs: 0,
+                totalDelayMs: 0,
+                retryCount: 0,
+                stop: {
+                    reason: complete
+                        ? "reported_total_reached"
+                        : "raw_results_incomplete",
+                    startOffset: 0,
+                    pageSize: accounts.length,
+                    lastSuccessfulStart: accounts.length > 0 ? 0 : null,
+                    lastSuccessfulCount: accounts.length,
+                    lastSuccessfulAdded: accounts.length,
+                    stoppedAtStart: accounts.length,
+                    stoppedAtCount: 0,
+                    nextStart: accounts.length,
+                    fetchedAccounts: accounts.length,
+                    reportedTotal: totalResults,
+                    missingFromReported,
+                },
+            },
+        },
+        stats: {
+            filePath,
+            parsedLines,
+            parsedElements,
+            invalidElements,
+            duplicateAccounts,
+            distinctRequestUrls: requestUrls.size,
+        },
+    };
+}
+function decodeSalesNavigatorQueryTextValue(value) {
+    let decoded = value.trim();
+    for (let index = 0; index < 3; index += 1) {
+        try {
+            const next = decodeURIComponent(decoded);
+            if (next === decoded) {
+                break;
+            }
+            decoded = next;
+        }
+        catch {
+            break;
+        }
+    }
+    return decoded.replaceAll("+", " ").replace(/\s+/g, " ").trim();
+}
+function extractIncludedSalesNavigatorFilterTexts(searchUrl, filterType) {
+    const decodedQuery = decodeSalesNavigatorQueryParam(searchUrl);
+    if (!decodedQuery) {
+        return [];
+    }
+    const values = [];
+    const seen = new Set();
+    const filterPattern = new RegExp(`type:${filterType},values:List\\((.*?)\\)\\)`, "g");
+    for (const filterMatch of decodedQuery.matchAll(filterPattern)) {
+        const block = filterMatch[1] ?? "";
+        for (const valueMatch of block.matchAll(/text:([^,)]+),selectionType:INCLUDED/g)) {
+            const text = decodeSalesNavigatorQueryTextValue(valueMatch[1] ?? "");
+            const key = normalizeLooseMatchText(text);
+            if (text && !seen.has(key)) {
+                seen.add(key);
+                values.push(text);
+            }
+        }
+    }
+    return values;
+}
+function buildSalesNavigatorAccountLocationFilter(searchUrl) {
+    const regionTexts = extractIncludedSalesNavigatorFilterTexts(searchUrl, "REGION");
+    const requiredTerms = regionTexts
+        .flatMap((text) => normalizeLooseMatchText(text).split(" "))
+        .filter((term) => term.length >= 3 &&
+        ![
+            "area",
+            "metro",
+            "metropolitan",
+            "region",
+            "greater",
+            "united",
+            "states",
+            "kingdom",
+            "germany",
+            "deutschland",
+            "europe",
+        ].includes(term));
+    if (regionTexts.length === 0 || requiredTerms.length === 0) {
+        return null;
+    }
+    return {
+        regionTexts,
+        requiredTerms: [...new Set(requiredTerms)],
+    };
+}
+function salesNavigatorAccountMatchesLocationFilter(account, filter) {
+    if (!filter || filter.requiredTerms.length === 0) {
+        return true;
+    }
+    const visibleLocation = typeof account.location === "string"
+        ? normalizeLooseMatchText(account.location)
+        : "";
+    if (!visibleLocation) {
+        return true;
+    }
+    return filter.requiredTerms.some((term) => visibleLocation.includes(term));
+}
 function buildLinkedInCompanyLookupVariants(params) {
     const variants = [];
     const seen = new Set();
@@ -5300,6 +5904,19 @@ function isMissingSupabaseTableError(code, message) {
     const normalized = message.toLowerCase();
     return code === "42P01" || normalized.includes("does not exist");
 }
+function createSalesNavigatorSupabaseFetch(env = process.env) {
+    const configuredTimeoutMs = Number(env.SALESPROMPTER_SALESNAV_SUPABASE_TIMEOUT_MS);
+    const timeoutMs = Number.isFinite(configuredTimeoutMs) && configuredTimeoutMs >= 500
+        ? Math.min(30_000, Math.trunc(configuredTimeoutMs))
+        : 2_500;
+    return (input, init) => {
+        const timeoutSignal = AbortSignal.timeout(timeoutMs);
+        const signal = init?.signal
+            ? AbortSignal.any([init.signal, timeoutSignal])
+            : timeoutSignal;
+        return fetch(input, { ...init, signal });
+    };
+}
 async function createSalesNavigatorCrawlEventStore(options) {
     const config = (() => {
         try {
@@ -5317,7 +5934,10 @@ async function createSalesNavigatorCrawlEventStore(options) {
         auth: {
             persistSession: false,
             autoRefreshToken: false
-        }
+        },
+        global: {
+            fetch: createSalesNavigatorSupabaseFetch(process.env),
+        },
     });
     let writable = true;
     return {
@@ -5341,6 +5961,7 @@ async function createSalesNavigatorCrawlEventStore(options) {
                 writable = false;
                 return;
             }
+            writable = false;
             throw new Error(`Failed to write crawl event to Supabase: ${error.message}`);
         },
         listRecentForJob: async (jobId, limit) => {
@@ -5913,6 +6534,90 @@ async function fetchCliJson(session, request, schema) {
         return schema.parse(parsed);
     });
 }
+async function launchAffiliateCampaignViaApp(session, payload) {
+    const { value } = await fetchCliJson(session, (currentSession) => fetch(`${currentSession.apiBaseUrl}/api/cli/affiliate-campaigns`, {
+        method: "POST",
+        headers: {
+            "Content-Type": "application/json",
+            Authorization: `Bearer ${currentSession.accessToken}`
+        },
+        body: JSON.stringify(payload)
+    }), AffiliateCampaignLaunchResponseSchema);
+    return value;
+}
+async function prepareAffiliateOutreachViaApp(session, payload) {
+    const { value } = await fetchCliJson(session, (currentSession) => fetch(`${currentSession.apiBaseUrl}/api/cli/affiliate-outreach`, {
+        method: "POST",
+        headers: {
+            "Content-Type": "application/json",
+            Authorization: `Bearer ${currentSession.accessToken}`
+        },
+        body: JSON.stringify(payload)
+    }), AffiliateOutreachResponseSchema);
+    return value.outreach;
+}
+async function getAffiliateOutreachViaApp(session, audienceRunId) {
+    const { value } = await fetchCliJson(session, (currentSession) => fetch(`${currentSession.apiBaseUrl}/api/cli/affiliate-outreach/${encodeURIComponent(audienceRunId)}`, {
+        headers: {
+            Authorization: `Bearer ${currentSession.accessToken}`
+        }
+    }), AffiliateOutreachResponseSchema);
+    return value.outreach;
+}
+async function activateAffiliateOutreachViaApp(session, audienceRunId) {
+    const { value } = await fetchCliJson(session, (currentSession) => fetch(`${currentSession.apiBaseUrl}/api/cli/affiliate-outreach/${encodeURIComponent(audienceRunId)}/activate`, {
+        method: "POST",
+        headers: {
+            "Content-Type": "application/json",
+            Authorization: `Bearer ${currentSession.accessToken}`
+        },
+        body: JSON.stringify({})
+    }), AffiliateOutreachResponseSchema);
+    return value.outreach;
+}
+async function regenerateAffiliateOutreachSequenceViaApp(session, audienceRunId) {
+    const { value } = await fetchCliJson(session, (currentSession) => fetch(`${currentSession.apiBaseUrl}/api/cli/affiliate-outreach/${encodeURIComponent(audienceRunId)}/sequence`, {
+        method: "POST",
+        headers: {
+            "Content-Type": "application/json",
+            Authorization: `Bearer ${currentSession.accessToken}`
+        },
+        body: JSON.stringify({})
+    }), AffiliateOutreachResponseSchema);
+    return value.outreach;
+}
+async function enrichAffiliateOutreachViaApp(session, audienceRunId) {
+    const before = await getAffiliateOutreachViaApp(session, audienceRunId);
+    const previousAttemptedAt = typeof before.stats.latestTopUp === "object" && before.stats.latestTopUp !== null
+        ? String(before.stats.latestTopUp.attemptedAt ?? "")
+        : "";
+    await fetchCliJson(session, (currentSession) => fetch(`${currentSession.apiBaseUrl}/api/cli/affiliate-outreach/${encodeURIComponent(audienceRunId)}/enrich`, {
+        method: "POST",
+        headers: {
+            "Content-Type": "application/json",
+            Authorization: `Bearer ${currentSession.accessToken}`
+        },
+        body: JSON.stringify({})
+    }), AffiliateOutreachEnrichStartResponseSchema);
+    const deadline = Date.now() + 10 * 60 * 1000;
+    const configuredPollMs = Number(process.env.SALESPROMPTER_AFFILIATE_ENRICH_POLL_MS);
+    const pollMs = Number.isFinite(configuredPollMs) && configuredPollMs > 0
+        ? Math.max(10, Math.trunc(configuredPollMs))
+        : 5_000;
+    while (Date.now() < deadline) {
+        await new Promise((resolve) => setTimeout(resolve, pollMs));
+        const current = await getAffiliateOutreachViaApp(session, audienceRunId);
+        const latestTopUp = typeof current.stats.latestTopUp === "object" &&
+            current.stats.latestTopUp !== null
+            ? current.stats.latestTopUp
+            : null;
+        const attemptedAt = String(latestTopUp?.attemptedAt ?? "");
+        if (attemptedAt && attemptedAt !== previousAttemptedAt) {
+            return current;
+        }
+    }
+    throw new Error("Email recovery is still running after 10 minutes. Check affiliate:status and retry later.");
+}
 async function uploadLinkedInProductsCatalog(session, payload, batchSize = 100, traceId) {
     let imported = 0;
     let upserted = 0;
@@ -6068,12 +6773,15 @@ function normalizeSalesNavigatorApiQueryValue(rawQuery) {
         : withRecentSearchId.replace(/^\(/, "(spellCorrectionEnabled:true,");
 }
 function buildSalesNavigatorApiRequestFromSearchUrl(searchUrl, config, count) {
+    return {
+        url: buildSalesNavigatorLeadApiUrlFromSearchUrl(searchUrl, count),
+        headers: buildLinkedInSalesNavigatorLocalImportHeaders(config),
+    };
+}
+function buildSalesNavigatorLeadApiUrlFromSearchUrl(searchUrl, count) {
     const source = new URL(searchUrl);
     if (source.pathname.includes("/sales-api/salesApiLeadSearch")) {
-        return {
-            url: source.toString(),
-            headers: buildLinkedInSalesNavigatorLocalImportHeaders(config),
-        };
+        return source.toString();
     }
     if (!source.pathname.includes("/sales/search/people")) {
         throw new Error("Automatic Sales Navigator import requires a /sales/search/people URL.");
@@ -6092,10 +6800,7 @@ function buildSalesNavigatorApiRequestFromSearchUrl(searchUrl, config, count) {
         `?q=searchQuery&query=${apiQuery}&start=0&count=${normalizedCount}` +
         `&trackingParam=(sessionId:${rawSessionId})` +
         "&decorationId=com.linkedin.sales.deco.desktop.searchv2.LeadSearchResult-14";
-    return {
-        url: apiUrl,
-        headers: buildLinkedInSalesNavigatorLocalImportHeaders(config),
-    };
+    return apiUrl;
 }
 function extractSalesNavigatorDecorationId(requestUrl, fallbackDecorationId) {
     try {
@@ -6122,15 +6827,12 @@ function buildSalesNavigatorAccountApiUrlFromSearchUrl(searchUrl, count, options
     const baseUrl = compactOptionalText(options.baseUrl) ??
         compactOptionalText(process.env.SALESPROMPTER_LINKEDIN_SALES_API_BASE_URL) ??
         `${source.protocol}//${source.host}`;
-    const rawSessionId = extractRawUrlSearchParam(source, "sessionId") ??
-        encodeURIComponent(generateLinkedInSessionId());
-    const apiQuery = normalizeSalesNavigatorApiQueryValue(rawQuery);
+    const apiQuery = decodeRawSalesNavigatorQueryParam(rawQuery);
     const normalizedCount = Math.max(1, Math.min(100, Math.trunc(count)));
     const decorationId = compactOptionalText(options.decorationId) ??
-        "com.linkedin.sales.deco.desktop.searchv2.AccountSearchResult-14";
+        "com.linkedin.sales.deco.desktop.searchv2.AccountSearchResult-4";
     return (`${baseUrl.replace(/\/+$/, "")}/sales-api/salesApiAccountSearch` +
         `?q=searchQuery&query=${apiQuery}&start=0&count=${normalizedCount}` +
-        `&trackingParam=(sessionId:${rawSessionId})` +
         `&decorationId=${decorationId}`);
 }
 function buildSalesNavigatorAccountApiRequestFromSearchUrl(searchUrl, config, count) {
@@ -6146,17 +6848,127 @@ function buildSalesNavigatorAccountApiRequestFromSearchUrl(searchUrl, config, co
         headers: buildLinkedInSalesNavigatorAccountSearchHeaders(config),
     };
 }
-function buildSalesNavigatorAccountApiRequestFromSearchUrlWithTemplate(searchUrl, templateRequest, count) {
-    const templateUrl = new URL(templateRequest.url);
-    return {
-        url: buildSalesNavigatorAccountApiUrlFromSearchUrl(searchUrl, count, {
-            baseUrl: `${templateUrl.protocol}//${templateUrl.host}`,
-            decorationId: extractSalesNavigatorDecorationId(templateRequest.url, "com.linkedin.sales.deco.desktop.searchv2.AccountSearchResult-14"),
-        }),
-        headers: { ...templateRequest.headers },
-    };
-}
-const SALES_NAVIGATOR_PROFILE_LANGUAGE_VALUES = new Map([
+async function probeLinkedInAccountSearchConfig(searchUrl, config) {
+    const request = buildSalesNavigatorAccountApiRequestFromSearchUrl(searchUrl, config, 1);
+    const controller = new AbortController();
+    const timeout = setTimeout(() => controller.abort(), 8_000);
+    try {
+        const response = await fetch(request.url, {
+            headers: request.headers,
+            signal: controller.signal,
+        });
+        if (response.status === 401) {
+            return {
+                status: "unauthorized",
+                statusCode: response.status,
+                validationError: "salesnav_account_search_http_401",
+            };
+        }
+        if (response.status === 403) {
+            const body = await response.text();
+            let errorCode = "";
+            try {
+                const parsed = JSON.parse(body);
+                errorCode =
+                    typeof parsed.code === "string" ? parsed.code.trim() : "";
+            }
+            catch {
+                errorCode = "";
+            }
+            if (errorCode === "SALES_SEAT_REQUIRED") {
+                return {
+                    status: "sales_seat_required",
+                    statusCode: response.status,
+                    validationError: "salesnav_account_search_sales_seat_required",
+                };
+            }
+            return {
+                status: "forbidden",
+                statusCode: response.status,
+                validationError: "salesnav_account_search_http_403",
+            };
+        }
+        if (response.status === 429 || response.status === 999) {
+            return {
+                status: "rate_limited",
+                statusCode: response.status,
+                validationError: "salesnav_account_search_rate_limited",
+            };
+        }
+        if (!response.ok) {
+            return {
+                status: "error",
+                statusCode: response.status,
+                validationError: `salesnav_account_search_http_${response.status}`,
+            };
+        }
+        const contentType = response.headers.get("content-type") ?? "";
+        const body = await response.text();
+        if (!/json/i.test(contentType) && /^\s*</.test(body)) {
+            return {
+                status: "invalid_response",
+                statusCode: response.status,
+                validationError: "salesnav_account_search_returned_html",
+            };
+        }
+        try {
+            const parsed = JSON.parse(body);
+            if (typeof parsed !== "object" || parsed === null) {
+                throw new Error("response is not an object");
+            }
+        }
+        catch {
+            return {
+                status: "invalid_response",
+                statusCode: response.status,
+                validationError: "salesnav_account_search_invalid_json",
+            };
+        }
+        return {
+            status: "ok",
+            statusCode: response.status,
+            validationError: null,
+        };
+    }
+    catch (error) {
+        return {
+            status: "error",
+            statusCode: null,
+            validationError: error instanceof Error && error.name === "AbortError"
+                ? "salesnav_account_search_timeout"
+                : `salesnav_account_search_request_failed:${error instanceof Error ? error.message : String(error)}`,
+        };
+    }
+    finally {
+        clearTimeout(timeout);
+    }
+}
+function assertLinkedInAccountSearchConfigProbe(probe) {
+    if (probe.status === "ok") {
+        return;
+    }
+    if (probe.status === "rate_limited") {
+        throw new Error("Sales Navigator Account Search API is rate-limited. The CLI stopped without retrying the session.");
+    }
+    if (probe.status === "unauthorized" || probe.status === "forbidden") {
+        throw new Error(`The configured LinkedIn session cannot call the Sales Navigator Account Search API (HTTP ${probe.statusCode}). Refresh the Salesprompter LinkedIn session before retrying.`);
+    }
+    if (probe.status === "sales_seat_required") {
+        throw new Error("The configured LinkedIn session is logged in but does not have a Sales Navigator seat.");
+    }
+    throw new Error(`Sales Navigator Account Search API preflight failed: ${probe.validationError ?? probe.status}`);
+}
+function buildSalesNavigatorAccountApiRequestFromSearchUrlWithTemplate(searchUrl, templateRequest, count) {
+    const templateUrl = new URL(templateRequest.url);
+    return {
+        url: buildSalesNavigatorAccountApiUrlFromSearchUrl(searchUrl, count, {
+            baseUrl: `${templateUrl.protocol}//${templateUrl.host}`,
+            decorationId: extractSalesNavigatorDecorationId(templateRequest.url, "com.linkedin.sales.deco.desktop.searchv2.AccountSearchResult-4"),
+        }),
+        headers: { ...templateRequest.headers },
+    };
+}
+const SALES_NAVIGATOR_PROFILE_LANGUAGE_VALUES = new Map([
     ["de", { id: "de", text: "German", selectionType: "INCLUDED" }],
     ["german", { id: "de", text: "German", selectionType: "INCLUDED" }],
     ["en", { id: "en", text: "English", selectionType: "INCLUDED" }],
@@ -6218,12 +7030,17 @@ const SALES_NAVIGATOR_COMPANY_HEADCOUNT_VALUES = new Map([
     ["11-50", { id: "C", text: "11-50", selectionType: "INCLUDED" }],
     ["51-200", { id: "D", text: "51-200", selectionType: "INCLUDED" }],
     ["201-500", { id: "E", text: "201-500", selectionType: "INCLUDED" }],
-    ["501-1000", { id: "F", text: "501-1000", selectionType: "INCLUDED" }],
-    ["1001-5000", { id: "G", text: "1001-5000", selectionType: "INCLUDED" }],
-    ["5001-10,000", { id: "H", text: "5001-10,000", selectionType: "INCLUDED" }],
-    ["5001-10000", { id: "H", text: "5001-10,000", selectionType: "INCLUDED" }],
-    ["10,000+", { id: "I", text: "10,000+", selectionType: "INCLUDED" }],
-    ["10000+", { id: "I", text: "10,000+", selectionType: "INCLUDED" }],
+    ["501-1000", { id: "F", text: "501-1,000", selectionType: "INCLUDED" }],
+    ["501-1,000", { id: "F", text: "501-1,000", selectionType: "INCLUDED" }],
+    ["1001-5000", { id: "G", text: "1,001-5,000", selectionType: "INCLUDED" }],
+    ["1,001-5,000", { id: "G", text: "1,001-5,000", selectionType: "INCLUDED" }],
+    ["5001-10,000", { id: "H", text: "5,001-10,000", selectionType: "INCLUDED" }],
+    ["5001-10000", { id: "H", text: "5,001-10,000", selectionType: "INCLUDED" }],
+    ["5,001-10,000", { id: "H", text: "5,001-10,000", selectionType: "INCLUDED" }],
+    ["10,000+", { id: "I", text: "10,001+", selectionType: "INCLUDED" }],
+    ["10000+", { id: "I", text: "10,001+", selectionType: "INCLUDED" }],
+    ["10,001+", { id: "I", text: "10,001+", selectionType: "INCLUDED" }],
+    ["10001+", { id: "I", text: "10,001+", selectionType: "INCLUDED" }],
 ]);
 const SALES_NAVIGATOR_TENURE_VALUES = new Map([
     [
@@ -6447,14 +7264,17 @@ function withSalesNavigatorPaging(url, start, count) {
     return `${base}?${params.join("&")}${hash}`;
 }
 function buildLinkedInSalesNavigatorLocalImportHeaders(config) {
-    return {
+    const headers = {
         accept: "*/*",
         "csrf-token": config.csrfToken,
         cookie: config.cookie,
         "user-agent": config.userAgent,
-        "x-li-identity": config.identity,
         "x-restli-protocol-version": "2.0.0",
     };
+    if (config.identity) {
+        headers["x-li-identity"] = config.identity;
+    }
+    return headers;
 }
 function buildLinkedInSalesNavigatorAccountSearchHeaders(config) {
     return {
@@ -6745,10 +7565,18 @@ function extractLocalSalesNavigatorTotalResults(responseBody) {
         return null;
     }
     const record = responseBody;
+    const data = typeof record.data === "object" &&
+        record.data !== null &&
+        !Array.isArray(record.data)
+        ? record.data
+        : null;
     const candidates = [
         record.paging,
+        data?.paging,
         record.metadata,
+        data?.metadata,
         record.searchResultsMetadata,
+        data,
         record,
     ];
     for (const candidate of candidates) {
@@ -6850,6 +7678,781 @@ async function fetchLocalSalesNavigatorRequest(parsedRequest, retryOptions) {
         }
     }
 }
+async function readLocalAccountSearchRelayBody(request) {
+    const chunks = [];
+    let size = 0;
+    for await (const chunk of request) {
+        const buffer = Buffer.isBuffer(chunk) ? chunk : Buffer.from(chunk);
+        size += buffer.length;
+        if (size > 50 * 1024 * 1024) {
+            throw new Error("Browser relay response exceeded 50 MB.");
+        }
+        chunks.push(buffer);
+    }
+    const text = Buffer.concat(chunks).toString("utf8");
+    return text ? JSON.parse(text) : null;
+}
+function writeLocalAccountSearchRelayJson(response, statusCode, payload) {
+    response.writeHead(statusCode, {
+        "content-type": "application/json; charset=utf-8",
+        "cache-control": "no-store",
+        "access-control-allow-origin": "https://www.linkedin.com",
+        "access-control-allow-methods": "GET, POST, OPTIONS",
+        "access-control-allow-headers": "content-type",
+        "access-control-allow-private-network": "true",
+    });
+    response.end(`${JSON.stringify(payload)}\n`);
+}
+async function createLocalAccountSearchBrowserRelay(requestedPort) {
+    let pending = null;
+    let requestSequence = 0;
+    const server = createServer(async (request, response) => {
+        try {
+            const requestUrl = new URL(request.url ?? "/", `http://127.0.0.1:${requestedPort}`);
+            if (request.method === "OPTIONS") {
+                writeLocalAccountSearchRelayJson(response, 204, null);
+                return;
+            }
+            if (request.method === "GET" && requestUrl.pathname === "/health") {
+                writeLocalAccountSearchRelayJson(response, 200, {
+                    status: "ok",
+                    pending: Boolean(pending),
+                });
+                return;
+            }
+            if (request.method === "GET" && requestUrl.pathname === "/next") {
+                writeLocalAccountSearchRelayJson(response, 200, pending
+                    ? {
+                        status: "task",
+                        requestId: pending.requestId,
+                        url: pending.url,
+                    }
+                    : { status: "idle" });
+                return;
+            }
+            if (request.method === "POST" && requestUrl.pathname === "/result") {
+                if (!pending) {
+                    writeLocalAccountSearchRelayJson(response, 409, {
+                        status: "error",
+                        error: "No Account Search relay task is pending.",
+                    });
+                    return;
+                }
+                const value = await readLocalAccountSearchRelayBody(request);
+                if (typeof value !== "object" || value === null || Array.isArray(value)) {
+                    throw new Error("Browser relay result must be a JSON object.");
+                }
+                const record = value;
+                if (record.requestId !== pending.requestId) {
+                    writeLocalAccountSearchRelayJson(response, 409, {
+                        status: "error",
+                        error: "Browser relay request id does not match the pending task.",
+                    });
+                    return;
+                }
+                const status = Number(record.status);
+                const retryAfter = typeof record.retryAfter === "string" ? record.retryAfter : null;
+                const body = record.body;
+                const bodyPreview = JSON.stringify(body ?? null).slice(0, 300);
+                const current = pending;
+                pending = null;
+                if (isSalesNavigatorRateLimitStatus(status, bodyPreview)) {
+                    current.reject(new LocalSalesNavigatorRateLimitError(status, bodyPreview, parseRetryAfterHeader(retryAfter)));
+                    writeLocalAccountSearchRelayJson(response, 200, {
+                        status: "rate_limited",
+                    });
+                    return;
+                }
+                if (!Number.isFinite(status) || status < 200 || status >= 300) {
+                    current.reject(new Error(`Sales Navigator browser relay failed with HTTP ${status}: ${bodyPreview}`));
+                    writeLocalAccountSearchRelayJson(response, 200, {
+                        status: "failed",
+                    });
+                    return;
+                }
+                current.resolve({ body, retryCount: 0, retryDelayMs: 0 });
+                writeLocalAccountSearchRelayJson(response, 200, {
+                    status: "accepted",
+                });
+                return;
+            }
+            writeLocalAccountSearchRelayJson(response, 404, {
+                status: "error",
+                error: "Not found",
+            });
+        }
+        catch (error) {
+            writeLocalAccountSearchRelayJson(response, 500, {
+                status: "error",
+                error: error instanceof Error ? error.message : String(error),
+            });
+        }
+    });
+    await new Promise((resolve, reject) => {
+        server.once("error", reject);
+        server.listen(requestedPort, "127.0.0.1", () => resolve());
+    });
+    const address = server.address();
+    if (!address || typeof address === "string") {
+        await new Promise((resolve) => server.close(() => resolve()));
+        throw new Error("Account Search browser relay failed to bind.");
+    }
+    return {
+        port: address.port,
+        request(url) {
+            if (pending) {
+                throw new Error("Account Search browser relay already has a pending task.");
+            }
+            const parsedUrl = new URL(url);
+            if (!/(^|\.)linkedin\.com$/i.test(parsedUrl.hostname) ||
+                !(parsedUrl.pathname.includes("/sales-api/salesApiAccountSearch") ||
+                    parsedUrl.pathname.includes("/sales-api/salesApiLeadSearch"))) {
+                throw new Error("Browser relay only accepts LinkedIn Account or Lead Search API URLs.");
+            }
+            requestSequence += 1;
+            return new Promise((resolve, reject) => {
+                pending = {
+                    requestId: `sales-nav-search-${requestSequence}`,
+                    url,
+                    resolve,
+                    reject,
+                };
+            });
+        },
+        async close() {
+            if (pending) {
+                pending.reject(new Error("Account Search browser relay closed."));
+                pending = null;
+            }
+            await new Promise((resolve) => server.close(() => resolve()));
+        },
+    };
+}
+const LOCAL_ACCOUNT_SEARCH_COLLECTOR_RESULT_WINDOW = 1600;
+const LOCAL_ACCOUNT_SEARCH_COLLECTOR_COVERAGE_PASS_VERSION = 3;
+const LOCAL_ACCOUNT_SEARCH_COLLECTOR_COVERAGE_PASS = "coverage-complete";
+const LOCAL_ACCOUNT_SEARCH_COLLECTOR_PASSES = [
+    {
+        name: LOCAL_ACCOUNT_SEARCH_COLLECTOR_COVERAGE_PASS,
+        filterTypes: [
+            "COMPANY_HEADCOUNT",
+            "NUM_OF_FOLLOWERS",
+        ],
+    },
+    {
+        name: "headcount-first",
+        filterTypes: [
+            "COMPANY_HEADCOUNT",
+            "NUM_OF_FOLLOWERS",
+            "ANNUAL_REVENUE",
+            "COMPANY_HEADCOUNT_GROWTH",
+        ],
+    },
+    {
+        name: "followers-first",
+        filterTypes: [
+            "NUM_OF_FOLLOWERS",
+            "COMPANY_HEADCOUNT",
+            "ANNUAL_REVENUE",
+            "COMPANY_HEADCOUNT_GROWTH",
+        ],
+    },
+    {
+        name: "revenue-first",
+        filterTypes: [
+            "ANNUAL_REVENUE",
+            "COMPANY_HEADCOUNT",
+            "NUM_OF_FOLLOWERS",
+            "COMPANY_HEADCOUNT_GROWTH",
+        ],
+    },
+];
+const LOCAL_ACCOUNT_SEARCH_COLLECTOR_KEYWORD_TOKENS = [
+    "software",
+    "ai",
+    "technology",
+    "data",
+    "platform",
+    "services",
+    "solutions",
+    "digital",
+    "cloud",
+    "business",
+    "internet",
+    "online",
+    "app",
+    "systems",
+    "company",
+    "management",
+    "development",
+    "network",
+    "security",
+    "automation",
+    "marketing",
+    "financial",
+    "media",
+    "consulting",
+    "health",
+    "mobile",
+    "enterprise",
+    "analytics",
+    "engineering",
+    "global",
+    "design",
+    "web",
+];
+const LOCAL_ACCOUNT_SEARCH_COLLECTOR_GROWTH_DIMENSION = {
+    key: "company-headcount-growth",
+    filterType: "COMPANY_HEADCOUNT_GROWTH",
+    combinableValues: false,
+    values: [
+        { text: "-1,000,000% to -1%", rangeValue: { min: -1_000_000, max: -1 } },
+        { text: "0%", rangeValue: { min: 0, max: 0 } },
+        { text: "1% to 10%", rangeValue: { min: 1, max: 10 } },
+        { text: "11% to 25%", rangeValue: { min: 11, max: 25 } },
+        { text: "26% to 50%", rangeValue: { min: 26, max: 50 } },
+        { text: "51% to 100%", rangeValue: { min: 51, max: 100 } },
+        { text: "101%+", rangeValue: { min: 101, max: 1_000_000 } },
+    ],
+};
+const LOCAL_ACCOUNT_SEARCH_COLLECTOR_BAY_AREA_PARENT_REGION = {
+    id: "90000084",
+    text: "San Francisco Bay Area",
+    selectionType: "INCLUDED",
+};
+const LOCAL_ACCOUNT_SEARCH_COLLECTOR_BAY_AREA_COUNTIES = [
+    {
+        id: "102839053",
+        text: "Alameda County, California, United States",
+        selectionType: "INCLUDED",
+    },
+    {
+        id: "102476922",
+        text: "Contra Costa County, California, United States",
+        selectionType: "INCLUDED",
+    },
+    {
+        id: "104929029",
+        text: "Marin County, California, United States",
+        selectionType: "INCLUDED",
+    },
+    {
+        id: "105546787",
+        text: "Napa County, California, United States",
+        selectionType: "INCLUDED",
+    },
+    {
+        id: "100901743",
+        text: "San Francisco County, California, United States",
+        selectionType: "INCLUDED",
+    },
+    {
+        id: "104739033",
+        text: "San Mateo County, California, United States",
+        selectionType: "INCLUDED",
+    },
+    {
+        id: "105416315",
+        text: "Santa Clara County, California, United States",
+        selectionType: "INCLUDED",
+    },
+    {
+        id: "103079873",
+        text: "Solano County, California, United States",
+        selectionType: "INCLUDED",
+    },
+    {
+        id: "101079764",
+        text: "Sonoma County, California, United States",
+        selectionType: "INCLUDED",
+    },
+];
+const LOCAL_ACCOUNT_SEARCH_COLLECTOR_SAN_FRANCISCO_CITY = {
+    id: "102277331",
+    text: "San Francisco, California, United States",
+    selectionType: "INCLUDED",
+};
+function isLocalAccountSearchCollectorNodeTask(value) {
+    if (typeof value !== "object" || value === null || Array.isArray(value)) {
+        return false;
+    }
+    const task = value;
+    return (task.kind === "node" &&
+        typeof task.id === "string" &&
+        typeof task.pass === "string" &&
+        Array.isArray(task.filters) &&
+        Array.isArray(task.remainingDimensions));
+}
+function localAccountSearchCollectorHasFilterType(filters, filterType) {
+    return filters.some((filter) => filter.type === filterType);
+}
+function buildLocalAccountSearchCollectorDimensionPartitions(dimension) {
+    const partitions = dimension.values.map((value, index) => ({
+        idSuffix: String(index),
+        filter: {
+            type: dimension.filterType,
+            values: [{ ...value }],
+        },
+    }));
+    const residualValues = dimension.values
+        .filter((value) => typeof value.id === "string" && value.id.length > 0)
+        .map((value) => ({
+        ...value,
+        selectionType: "EXCLUDED",
+    }));
+    if (dimension.supportsResidualExclusion !== false &&
+        residualValues.length === dimension.values.length &&
+        residualValues.length > 0) {
+        partitions.push({
+            idSuffix: "residual",
+            filter: {
+                type: dimension.filterType,
+                values: residualValues,
+            },
+        });
+    }
+    return partitions;
+}
+function withLocalAccountSearchCollectorKeywords(searchUrl, keywordExpression) {
+    const url = new URL(searchUrl);
+    const query = url.searchParams.get("query");
+    if (!query) {
+        return null;
+    }
+    let nextQuery;
+    if (/^\(keywords:[\s\S]*?,filters:List\(/.test(query)) {
+        nextQuery = query.replace(/^\(keywords:[\s\S]*?,filters:List\(/, `(keywords:${keywordExpression},filters:List(`);
+    }
+    else if (query.startsWith("(filters:List(")) {
+        nextQuery = `(keywords:${keywordExpression},${query.slice(1)}`;
+    }
+    else {
+        return null;
+    }
+    url.searchParams.set("query", nextQuery);
+    return url.toString();
+}
+function buildLocalAccountSearchCollectorKeywordPartitions(searchUrl, task) {
+    const keywordDepth = Math.max(0, Math.trunc(task.keywordDepth ?? 0));
+    const token = LOCAL_ACCOUNT_SEARCH_COLLECTOR_KEYWORD_TOKENS[keywordDepth];
+    if (!token) {
+        return null;
+    }
+    const keywordClauses = Array.isArray(task.keywordClauses)
+        ? task.keywordClauses.filter((clause) => clause.trim().length > 0)
+        : [];
+    const branches = [token, `NOT ${token}`].map((clause) => {
+        const nextClauses = [...keywordClauses, clause];
+        return {
+            clause,
+            nextClauses,
+            searchUrl: withLocalAccountSearchCollectorKeywords(searchUrl, nextClauses.join(" AND ")),
+        };
+    });
+    if (branches.some((branch) => !branch.searchUrl)) {
+        return null;
+    }
+    return {
+        splitOn: `KEYWORDS_${token}`,
+        partitions: branches.map((branch, index) => ({
+            idSuffix: index === 0 ? token : `not-${token}`,
+            searchUrl: branch.searchUrl,
+            keywordClauses: branch.nextClauses,
+            keywordDepth: keywordDepth + 1,
+        })),
+    };
+}
+function buildLocalAccountSearchCollectorIndustryPartitions(searchUrl) {
+    const url = new URL(searchUrl);
+    const query = url.searchParams.get("query");
+    if (!query) {
+        return null;
+    }
+    const parentIndustryPattern = /\(type:INDUSTRY,values:List\(\(id:6,text:Technology%2C%20Information%20and%20Internet,selectionType:INCLUDED\)\)\)/;
+    if (!parentIndustryPattern.test(query)) {
+        return null;
+    }
+    const industryBlocks = [
+        {
+            idSuffix: "software-development",
+            block: "(type:INDUSTRY,values:List((id:4,text:Software%20Development,selectionType:INCLUDED)))",
+        },
+        {
+            idSuffix: "technology-internet-residual",
+            block: "(type:INDUSTRY,values:List((id:6,text:Technology%2C%20Information%20and%20Internet,selectionType:INCLUDED),(id:4,text:Software%20Development,selectionType:EXCLUDED)))",
+        },
+    ];
+    return {
+        splitOn: "INDUSTRY_SOFTWARE_DEVELOPMENT",
+        partitions: industryBlocks.map((partition) => {
+            const childUrl = new URL(url);
+            childUrl.searchParams.set("query", query.replace(parentIndustryPattern, partition.block));
+            return {
+                idSuffix: partition.idSuffix,
+                searchUrl: childUrl.toString(),
+            };
+        }),
+    };
+}
+function isSanFranciscoBayAreaAccountSearch(sourceQueryUrl) {
+    const query = new URL(sourceQueryUrl).searchParams.get("query") ?? "";
+    return (query.includes("type:REGION") &&
+        query.includes(`id:${LOCAL_ACCOUNT_SEARCH_COLLECTOR_BAY_AREA_PARENT_REGION.id}`));
+}
+function buildLocalAccountSearchCollectorBayAreaPartitions(sourceQueryUrl, filters) {
+    if (!isSanFranciscoBayAreaAccountSearch(sourceQueryUrl)) {
+        return null;
+    }
+    const regionFilter = filters.find((filter) => filter.type === "REGION");
+    if (!regionFilter) {
+        const countyPartitions = LOCAL_ACCOUNT_SEARCH_COLLECTOR_BAY_AREA_COUNTIES.map((county) => [
+            ...filters,
+            { type: "REGION", values: [{ ...county }] },
+        ]);
+        const residualPartition = [
+            ...filters,
+            {
+                type: "REGION",
+                values: [
+                    { ...LOCAL_ACCOUNT_SEARCH_COLLECTOR_BAY_AREA_PARENT_REGION },
+                    ...LOCAL_ACCOUNT_SEARCH_COLLECTOR_BAY_AREA_COUNTIES.map((county) => ({
+                        ...county,
+                        selectionType: "EXCLUDED",
+                    })),
+                ],
+            },
+        ];
+        return {
+            splitOn: "REGION_BAY_AREA_COUNTY",
+            partitions: [...countyPartitions, residualPartition],
+        };
+    }
+    const includedRegions = regionFilter.values.filter((value) => (value.selectionType ?? "INCLUDED") === "INCLUDED");
+    const excludedRegions = regionFilter.values.filter((value) => value.selectionType === "EXCLUDED");
+    const sanFranciscoCounty = LOCAL_ACCOUNT_SEARCH_COLLECTOR_BAY_AREA_COUNTIES.find((county) => county.id === "100901743");
+    if (sanFranciscoCounty &&
+        includedRegions.length === 1 &&
+        includedRegions[0]?.id === sanFranciscoCounty.id &&
+        excludedRegions.length === 0) {
+        return {
+            splitOn: "REGION_SAN_FRANCISCO_CITY",
+            partitions: [
+                [
+                    ...filters.filter((filter) => filter.type !== "REGION"),
+                    {
+                        type: "REGION",
+                        values: [{ ...LOCAL_ACCOUNT_SEARCH_COLLECTOR_SAN_FRANCISCO_CITY }],
+                    },
+                ],
+                [
+                    ...filters.filter((filter) => filter.type !== "REGION"),
+                    {
+                        type: "REGION",
+                        values: [
+                            { ...sanFranciscoCounty },
+                            {
+                                ...LOCAL_ACCOUNT_SEARCH_COLLECTOR_SAN_FRANCISCO_CITY,
+                                selectionType: "EXCLUDED",
+                            },
+                        ],
+                    },
+                ],
+            ],
+        };
+    }
+    return null;
+}
+function migrateLocalAccountSearchCollectorCheckpoint(checkpoint) {
+    let changed = false;
+    const growthFilterType = LOCAL_ACCOUNT_SEARCH_COLLECTOR_GROWTH_DIMENSION.filterType;
+    const needsCoverageMigration = checkpoint.coveragePassVersion !==
+        LOCAL_ACCOUNT_SEARCH_COLLECTOR_COVERAGE_PASS_VERSION;
+    if (needsCoverageMigration) {
+        checkpoint.taskQueue = checkpoint.taskQueue.filter((task) => !task.pass.startsWith("coverage-"));
+        checkpoint.seenQueries = checkpoint.seenQueries.filter((queryKey) => !queryKey.startsWith("coverage-"));
+        checkpoint.coveragePassSeeded = false;
+        checkpoint.coveragePassVersion =
+            LOCAL_ACCOUNT_SEARCH_COLLECTOR_COVERAGE_PASS_VERSION;
+        changed = true;
+    }
+    for (const task of checkpoint.taskQueue) {
+        if (task.kind === "node" && task.pass.startsWith("coverage-")) {
+            const remainingDimensions = task.remainingDimensions.filter((filterType) => filterType !== growthFilterType);
+            if (remainingDimensions.length !== task.remainingDimensions.length) {
+                task.remainingDimensions = remainingDimensions;
+                changed = true;
+            }
+            continue;
+        }
+        if (task.kind === "node" &&
+            !localAccountSearchCollectorHasFilterType(task.filters, growthFilterType) &&
+            !task.remainingDimensions.includes(growthFilterType)) {
+            task.remainingDimensions.push(growthFilterType);
+            changed = true;
+        }
+    }
+    const queuedNodeQueries = new Set(checkpoint.taskQueue
+        .filter(isLocalAccountSearchCollectorNodeTask)
+        .map((task) => localAccountSearchCollectorQueryKey(buildSalesNavigatorAccountQuery(checkpoint.sourceQueryUrl, task.filters).slicedQueryUrl)));
+    const remainingFailures = [];
+    for (const failure of checkpoint.failures) {
+        const error = typeof failure.error === "string" ? failure.error : "";
+        const task = failure.task;
+        const isTerminalSlice = error.includes("with no split dimension left");
+        if (!isTerminalSlice || !isLocalAccountSearchCollectorNodeTask(task)) {
+            remainingFailures.push(failure);
+            continue;
+        }
+        const hasGrowthFilter = localAccountSearchCollectorHasFilterType(task.filters, growthFilterType);
+        const canUseBayAreaFallback = Boolean(buildLocalAccountSearchCollectorBayAreaPartitions(checkpoint.sourceQueryUrl, task.filters));
+        if (hasGrowthFilter && !canUseBayAreaFallback) {
+            remainingFailures.push(failure);
+            continue;
+        }
+        const remainingDimensions = [...task.remainingDimensions];
+        if (!hasGrowthFilter && !remainingDimensions.includes(growthFilterType)) {
+            remainingDimensions.push(growthFilterType);
+        }
+        const queryKey = localAccountSearchCollectorQueryKey(buildSalesNavigatorAccountQuery(checkpoint.sourceQueryUrl, task.filters).slicedQueryUrl);
+        if (!queuedNodeQueries.has(queryKey)) {
+            checkpoint.taskQueue.push({
+                ...task,
+                filters: task.filters.map((filter) => ({
+                    ...filter,
+                    values: filter.values.map((value) => ({ ...value })),
+                })),
+                remainingDimensions,
+            });
+            queuedNodeQueries.add(queryKey);
+        }
+        changed = true;
+    }
+    if (remainingFailures.length !== checkpoint.failures.length) {
+        checkpoint.failures = remainingFailures;
+    }
+    const isFreshCheckpoint = checkpoint.taskQueue.length === 0 && checkpoint.seenQueries.length === 0;
+    if (!isFreshCheckpoint &&
+        needsCoverageMigration &&
+        (checkpoint.rootTotal ?? 0) > checkpoint.cap) {
+        seedLocalAccountSearchCollectorPassTasks(checkpoint, LOCAL_ACCOUNT_SEARCH_COLLECTOR_COVERAGE_PASS, true);
+        checkpoint.coveragePassSeeded = true;
+        changed = true;
+    }
+    const coverageTasks = checkpoint.taskQueue.filter((task) => task.pass.startsWith("coverage-"));
+    if (coverageTasks.length > 0 &&
+        checkpoint.taskQueue.some((task, index) => task.pass.startsWith("coverage-") && index >= coverageTasks.length)) {
+        checkpoint.taskQueue = [
+            ...coverageTasks,
+            ...checkpoint.taskQueue.filter((task) => !task.pass.startsWith("coverage-")),
+        ];
+        changed = true;
+    }
+    return changed;
+}
+function parseLocalAccountSearchCollectorCheckpoint(value) {
+    if (typeof value !== "object" || value === null || Array.isArray(value)) {
+        throw new Error("Account Search checkpoint must be a JSON object.");
+    }
+    const checkpoint = value;
+    if (checkpoint.version !== 1 ||
+        typeof checkpoint.sourceQueryUrl !== "string" ||
+        !Array.isArray(checkpoint.taskQueue) ||
+        !Array.isArray(checkpoint.leaves) ||
+        !Array.isArray(checkpoint.windows) ||
+        !Array.isArray(checkpoint.failures)) {
+        throw new Error("Unsupported or invalid Account Search checkpoint.");
+    }
+    const seenQueryValues = Array.isArray(checkpoint.seenQueries)
+        ? checkpoint.seenQueries
+        : checkpoint.seenQueries && typeof checkpoint.seenQueries === "object"
+            ? Object.keys(checkpoint.seenQueries)
+            : [];
+    return {
+        ...checkpoint,
+        seenQueries: seenQueryValues.map(localAccountSearchCollectorQueryKey),
+    };
+}
+function localAccountSearchCollectorQueryKey(searchUrlOrQuery) {
+    try {
+        const query = new URL(searchUrlOrQuery).searchParams.get("query");
+        return query ?? searchUrlOrQuery;
+    }
+    catch {
+        return searchUrlOrQuery;
+    }
+}
+function localAccountSearchCollectorSeenKey(pass, searchUrlOrQuery) {
+    const queryKey = localAccountSearchCollectorQueryKey(searchUrlOrQuery);
+    return pass.startsWith("coverage-") ? `${pass}:${queryKey}` : queryKey;
+}
+function createLocalAccountSearchCollectorCheckpoint(params) {
+    const now = new Date().toISOString();
+    return {
+        version: 1,
+        sourceQueryUrl: params.sourceQueryUrl,
+        rootTotal: params.rootTotal,
+        cap: params.cap,
+        pageSize: params.pageSize,
+        delayMinMs: params.delayMinMs,
+        delayMaxMs: params.delayMaxMs,
+        requests: 0,
+        pagesWritten: 0,
+        rowsWritten: 0,
+        startedAt: now,
+        updatedAt: now,
+        taskQueue: [],
+        seenQueries: [],
+        duplicateQueries: 0,
+        leaves: [],
+        windows: [],
+        failures: [],
+        rateLimited: null,
+        coveragePassSeeded: false,
+        coveragePassVersion: LOCAL_ACCOUNT_SEARCH_COLLECTOR_COVERAGE_PASS_VERSION,
+        distinctAccounts: 0,
+        completedByDistinctCount: false,
+    };
+}
+function seedLocalAccountSearchCollectorTasks(checkpoint) {
+    for (const pass of LOCAL_ACCOUNT_SEARCH_COLLECTOR_PASSES) {
+        seedLocalAccountSearchCollectorPassTasks(checkpoint, pass.name, false);
+    }
+    checkpoint.coveragePassSeeded = true;
+    checkpoint.coveragePassVersion =
+        LOCAL_ACCOUNT_SEARCH_COLLECTOR_COVERAGE_PASS_VERSION;
+}
+function seedLocalAccountSearchCollectorPassTasks(checkpoint, passName, prepend) {
+    const dimensions = new Map(DEFAULT_SALES_NAVIGATOR_ACCOUNT_CRAWL_DIMENSIONS.map((dimension) => [
+        dimension.filterType,
+        dimension,
+    ]));
+    const seenQueries = new Set(checkpoint.seenQueries);
+    const pass = LOCAL_ACCOUNT_SEARCH_COLLECTOR_PASSES.find((candidate) => candidate.name === passName);
+    if (!pass) {
+        return false;
+    }
+    const [firstFilterType, ...remainingDimensions] = pass.filterTypes;
+    const dimension = dimensions.get(firstFilterType);
+    if (!dimension) {
+        throw new Error(`Missing Account Search split dimension ${firstFilterType}.`);
+    }
+    const tasks = [];
+    for (const partition of buildLocalAccountSearchCollectorDimensionPartitions(dimension)) {
+        const filters = [partition.filter];
+        const searchUrl = buildSalesNavigatorAccountQuery(checkpoint.sourceQueryUrl, filters).slicedQueryUrl;
+        const queryKey = localAccountSearchCollectorSeenKey(pass.name, searchUrl);
+        if (seenQueries.has(queryKey)) {
+            continue;
+        }
+        seenQueries.add(queryKey);
+        tasks.push({
+            kind: "node",
+            id: `${pass.name}-${partition.idSuffix}`,
+            pass: pass.name,
+            filters,
+            remainingDimensions: [...remainingDimensions],
+        });
+    }
+    if (prepend) {
+        checkpoint.taskQueue.unshift(...tasks);
+    }
+    else {
+        checkpoint.taskQueue.push(...tasks);
+    }
+    checkpoint.seenQueries = [...seenQueries];
+    return tasks.length > 0;
+}
+function enqueueLocalAccountSearchCollectorTasks(checkpoint, parentTask, tasks) {
+    if (tasks.length === 0) {
+        return;
+    }
+    if (parentTask.pass.startsWith("coverage-")) {
+        checkpoint.taskQueue.splice(1, 0, ...tasks);
+        return;
+    }
+    checkpoint.taskQueue.push(...tasks);
+}
+function extractLocalSalesNavigatorElements(body) {
+    if (typeof body !== "object" || body === null || Array.isArray(body)) {
+        return [];
+    }
+    const record = body;
+    const elements = record.elements;
+    if (Array.isArray(elements)) {
+        return elements;
+    }
+    const data = typeof record.data === "object" &&
+        record.data !== null &&
+        !Array.isArray(record.data)
+        ? record.data
+        : null;
+    const nestedElements = data?.elements;
+    if (Array.isArray(nestedElements)) {
+        return nestedElements;
+    }
+    const references = data?.["*elements"];
+    const included = record.included;
+    if (!Array.isArray(references) || !Array.isArray(included)) {
+        return [];
+    }
+    const referencedUrns = new Set(references.filter((reference) => typeof reference === "string" && reference.length > 0));
+    return included.filter((value) => {
+        if (typeof value !== "object" ||
+            value === null ||
+            Array.isArray(value)) {
+            return false;
+        }
+        const entityUrn = value.entityUrn;
+        return typeof entityUrn === "string" && referencedUrns.has(entityUrn);
+    });
+}
+async function appendLocalAccountSearchRawElements(params) {
+    if (params.elements.length === 0) {
+        return;
+    }
+    await mkdir(path.dirname(params.rawOutputPath), { recursive: true });
+    await appendFile(params.rawOutputPath, `${params.elements
+        .map((element) => JSON.stringify({ queryUrl: params.searchUrl, element }))
+        .join("\n")}\n`, "utf8");
+}
+function addLocalAccountSearchElementKey(accountKeys, element, queryUrl) {
+    if (typeof element !== "object" || element === null || Array.isArray(element)) {
+        return;
+    }
+    const companyId = extractLinkedInSalesCompanyIdFromUrn(element.entityUrn);
+    if (companyId) {
+        accountKeys.add(`company-id:${companyId}`);
+        return;
+    }
+    const account = normalizeLocalSalesNavigatorAccount(element, queryUrl);
+    if (account) {
+        accountKeys.add(account.accountKey);
+    }
+}
+async function loadLocalAccountSearchRawAccountKeys(rawOutputPath) {
+    const accountKeys = new Set();
+    if (!(await fileExists(rawOutputPath))) {
+        return accountKeys;
+    }
+    const raw = await readFile(rawOutputPath, "utf8");
+    for (const line of raw.split(/\r?\n/)) {
+        if (!line.trim()) {
+            continue;
+        }
+        try {
+            const row = JSON.parse(line);
+            addLocalAccountSearchElementKey(accountKeys, row.element, typeof row.queryUrl === "string" ? row.queryUrl : "");
+        }
+        catch {
+            // The import command reports malformed raw rows with line-level context.
+        }
+    }
+    return accountKeys;
+}
+async function saveLocalAccountSearchCollectorCheckpoint(checkpointPath, checkpoint) {
+    checkpoint.updatedAt = new Date().toISOString();
+    await writeJsonFile(checkpointPath, checkpoint);
+}
 async function fetchAllLocalSalesNavigatorPeople(parsedRequest, options) {
     const people = [];
     const seen = new Set();
@@ -6873,7 +8476,9 @@ async function fetchAllLocalSalesNavigatorPeople(parsedRequest, options) {
             ...parsedRequest,
             url: withSalesNavigatorPaging(parsedRequest.url, start, currentCount),
         };
-        const response = await fetchLocalSalesNavigatorRequest(pageRequest, options.retry);
+        const response = options.executeRequest
+            ? await options.executeRequest(pageRequest)
+            : await fetchLocalSalesNavigatorRequest(pageRequest, options.retry);
         retryCount += response.retryCount;
         totalDelayMs += response.retryDelayMs;
         const responseBody = response.body;
@@ -6919,6 +8524,7 @@ async function fetchAllLocalSalesNavigatorPeople(parsedRequest, options) {
 async function fetchAllLocalSalesNavigatorAccounts(parsedRequest, options) {
     const accounts = [];
     const seen = new Set();
+    let filteredAccounts = 0;
     let totalResults = null;
     let fetchedPages = 0;
     let totalDelayMs = 0;
@@ -6993,13 +8599,20 @@ async function fetchAllLocalSalesNavigatorAccounts(parsedRequest, options) {
         }
         const pageAccounts = normalizeLocalSalesNavigatorAccounts(responseBody, pageRequest.url);
         let added = 0;
+        let addedOrFiltered = 0;
         for (const account of pageAccounts) {
             if (seen.has(account.accountKey)) {
                 continue;
             }
-            seen.add(account.accountKey);
+            seen.add(account.accountKey);
+            if (!salesNavigatorAccountMatchesLocationFilter(account, options.accountLocationFilter)) {
+                filteredAccounts += 1;
+                addedOrFiltered += 1;
+                continue;
+            }
             accounts.push(account);
             added += 1;
+            addedOrFiltered += 1;
             if (requestedAccounts != null && accounts.length >= requestedAccounts) {
                 break;
             }
@@ -7024,7 +8637,7 @@ async function fetchAllLocalSalesNavigatorAccounts(parsedRequest, options) {
             nextStart = start;
             break;
         }
-        if (added === 0) {
+        if (addedOrFiltered === 0) {
             stopReason = "duplicate_page";
             stoppedAtStart = start;
             stoppedAtCount = currentCount;
@@ -7048,6 +8661,7 @@ async function fetchAllLocalSalesNavigatorAccounts(parsedRequest, options) {
     const missingFromReported = totalResults == null ? null : Math.max(0, totalResults - fetchedThrough);
     return {
         accounts,
+        filteredAccounts,
         totalResults,
         fetchedPages,
         sourceQueryUrl: parsedRequest.url,
@@ -7129,6 +8743,13 @@ async function importLocalSalesNavigatorPeopleViaApp(session, payload) {
     }, SalesNavigatorLocalImportResponseSchema);
     return value;
 }
+const SALESPROMPTER_SUPABASE_TABLES = {
+    accountSearchRuns: "salesprompter_linkedin_sales_nav_account_search_runs",
+    accountSearchSlices: "salesprompter_linkedin_sales_nav_account_search_slices",
+    accountSearchAccounts: "salesprompter_linkedin_sales_nav_accounts",
+    accountRunMemberships: "salesprompter_linkedin_sales_nav_account_run_memberships",
+    linkedinCompaniesProcessed: "salesprompter_linkedin_companies_processed",
+};
 async function createSalesNavigatorAccountSearchStore() {
     const databaseUrl = process.env.SALESPROMPTER_DATABASE_URL?.trim() ||
         process.env.DATABASE_URL?.trim() ||
@@ -7159,7 +8780,7 @@ async function closeSalesNavigatorAccountSearchStore(store) {
 }
 async function createSalesNavigatorAccountSearchRun(params) {
     if (params.store.kind === "postgres") {
-        const result = await params.store.client.query(`INSERT INTO public.linkedin_sales_nav_account_search_runs (
+        const result = await params.store.client.query(`INSERT INTO public.salesprompter_linkedin_sales_nav_account_search_runs (
         org_id, source_query_url, slice_preset, max_results_per_search, page_size, status, raw_payload
       )
       VALUES ($1, $2, $3, $4, $5, 'running', $6::jsonb)
@@ -7173,12 +8794,12 @@ async function createSalesNavigatorAccountSearchRun(params) {
         ]);
         const id = result.rows[0]?.id ?? "";
         if (!id) {
-            throw new Error("Failed to create account search run in Neon: missing run id.");
+            throw new Error("Failed to create account search run in Supabase: missing run id.");
         }
         return id;
     }
     const { data, error } = await params.store.client
-        .from("linkedin_sales_nav_account_search_runs")
+        .from(SALESPROMPTER_SUPABASE_TABLES.accountSearchRuns)
         .insert({
         org_id: params.orgId,
         source_query_url: params.sourceQueryUrl,
@@ -7191,17 +8812,17 @@ async function createSalesNavigatorAccountSearchRun(params) {
         .select("id")
         .single();
     if (error) {
-        throw new Error(`Failed to create account search run in Neon: ${error.message}`);
+        throw new Error(`Failed to create account search run in Supabase: ${error.message}`);
     }
     const id = typeof data?.id === "string" ? data.id : "";
     if (!id) {
-        throw new Error("Failed to create account search run in Neon: missing run id.");
+        throw new Error("Failed to create account search run in Supabase: missing run id.");
     }
     return id;
 }
 async function updateSalesNavigatorAccountSearchRun(params) {
     if (params.store.kind === "postgres") {
-        await params.store.client.query(`UPDATE public.linkedin_sales_nav_account_search_runs
+        await params.store.client.query(`UPDATE public.salesprompter_linkedin_sales_nav_account_search_runs
       SET status = $2,
           total_slices = $3,
           stored_accounts = $4,
@@ -7234,12 +8855,12 @@ async function updateSalesNavigatorAccountSearchRun(params) {
     let mergedRawPayload = null;
     if (params.rawPayload) {
         const { data: existing, error: selectError } = await params.store.client
-            .from("linkedin_sales_nav_account_search_runs")
+            .from(SALESPROMPTER_SUPABASE_TABLES.accountSearchRuns)
             .select("raw_payload")
             .eq("id", params.runId)
             .maybeSingle();
         if (selectError) {
-            throw new Error(`Failed to read account search run payload in Neon: ${selectError.message}`);
+            throw new Error(`Failed to read account search run payload in Supabase: ${selectError.message}`);
         }
         const existingPayload = typeof existing?.raw_payload === "object" &&
             existing.raw_payload !== null &&
@@ -7252,7 +8873,7 @@ async function updateSalesNavigatorAccountSearchRun(params) {
         };
     }
     const { error } = await params.store.client
-        .from("linkedin_sales_nav_account_search_runs")
+        .from(SALESPROMPTER_SUPABASE_TABLES.accountSearchRuns)
         .update({
         status: params.status,
         total_slices: params.totalSlices,
@@ -7272,12 +8893,12 @@ async function updateSalesNavigatorAccountSearchRun(params) {
     })
         .eq("id", params.runId);
     if (error) {
-        throw new Error(`Failed to update account search run in Neon: ${error.message}`);
+        throw new Error(`Failed to update account search run in Supabase: ${error.message}`);
     }
 }
 async function upsertSalesNavigatorAccountSearchSlice(params) {
     if (params.store.kind === "postgres") {
-        const result = await params.store.client.query(`INSERT INTO public.linkedin_sales_nav_account_search_slices (
+        const result = await params.store.client.query(`INSERT INTO public.salesprompter_linkedin_sales_nav_account_search_slices (
         run_id, org_id, sliced_query_url, applied_filters, split_trail, depth, status,
         total_results, fetched_pages, stored_accounts, retry_count, retry_delay_ms, last_error, raw_payload
       )
@@ -7313,12 +8934,12 @@ async function upsertSalesNavigatorAccountSearchSlice(params) {
         ]);
         const id = result.rows[0]?.id ?? "";
         if (!id) {
-            throw new Error("Failed to upsert account search slice in Neon: missing slice id.");
+            throw new Error("Failed to upsert account search slice in Supabase: missing slice id.");
         }
         return id;
     }
     const { data, error } = await params.store.client
-        .from("linkedin_sales_nav_account_search_slices")
+        .from(SALESPROMPTER_SUPABASE_TABLES.accountSearchSlices)
         .upsert({
         run_id: params.runId,
         org_id: params.orgId,
@@ -7338,11 +8959,11 @@ async function upsertSalesNavigatorAccountSearchSlice(params) {
         .select("id")
         .single();
     if (error) {
-        throw new Error(`Failed to upsert account search slice in Neon: ${error.message}`);
+        throw new Error(`Failed to upsert account search slice in Supabase: ${error.message}`);
     }
     const id = typeof data?.id === "string" ? data.id : "";
     if (!id) {
-        throw new Error("Failed to upsert account search slice in Neon: missing slice id.");
+        throw new Error("Failed to upsert account search slice in Supabase: missing slice id.");
     }
     return id;
 }
@@ -7821,7 +9442,7 @@ async function upsertLocalLinkedInCompanyScrape(row) {
     let committed = false;
     try {
         await client.query("BEGIN");
-        await client.query(`INSERT INTO public.linkedin_companies_processed (
+        await client.query(`INSERT INTO public.salesprompter_linkedin_companies_processed (
         error, query, timestamp, name, description, follower_count, website, domain, industry,
         company_size, founded, company_address, main_company_id, linkedin_id, sales_navigator_link,
         employees_on_linked_in, company_name, total_employee_count, company_url, headquarters
@@ -8027,7 +9648,7 @@ async function upsertSalesNavigatorAccounts(params) {
     }));
     if (params.store.kind === "postgres") {
         for (const row of rows) {
-            await params.store.client.query(`INSERT INTO public.linkedin_sales_nav_accounts (
+            await params.store.client.query(`INSERT INTO public.salesprompter_linkedin_sales_nav_accounts (
           org_id, last_run_id, last_slice_id, account_key, sales_nav_company_url,
           linkedin_company_url, company_id, company_name, industry, location, headquarters,
           employee_count, follower_count, company_type, description, website, search_query_url,
@@ -8076,17 +9697,62 @@ async function upsertSalesNavigatorAccounts(params) {
                 row.scraped_at,
                 JSON.stringify(row.raw_payload),
             ]);
+            await params.store.client.query(`INSERT INTO public.salesprompter_linkedin_sales_nav_account_run_memberships (
+          run_id, org_id, account_key, last_slice_id
+        )
+        VALUES ($1, $2, $3, $4)
+        ON CONFLICT (run_id, account_key)
+        DO UPDATE SET
+          last_slice_id = excluded.last_slice_id,
+          updated_at = now()`, [
+                row.last_run_id,
+                row.org_id,
+                row.account_key,
+                row.last_slice_id,
+            ]);
         }
         return rows.length;
     }
-    const { error } = await params.store.client
-        .from("linkedin_sales_nav_accounts")
-        .upsert(rows, { onConflict: "org_id,account_key" });
-    if (error) {
-        throw new Error(`Failed to upsert Sales Navigator accounts in Neon: ${error.message}`);
+    const supabaseBatchSize = 250;
+    for (let index = 0; index < rows.length; index += supabaseBatchSize) {
+        const batch = rows.slice(index, index + supabaseBatchSize);
+        const { error } = await params.store.client
+            .from(SALESPROMPTER_SUPABASE_TABLES.accountSearchAccounts)
+            .upsert(batch, { onConflict: "org_id,account_key" });
+        if (error) {
+            throw new Error(`Failed to upsert Sales Navigator accounts in Supabase: ${error.message}`);
+        }
+        const { error: membershipError } = await params.store.client
+            .from(SALESPROMPTER_SUPABASE_TABLES.accountRunMemberships)
+            .upsert(batch.map((row) => ({
+            run_id: row.last_run_id,
+            org_id: row.org_id,
+            account_key: row.account_key,
+            last_slice_id: row.last_slice_id,
+            updated_at: new Date().toISOString(),
+        })), { onConflict: "run_id,account_key" });
+        if (membershipError) {
+            throw new Error(`Failed to record Sales Navigator account run membership in Supabase: ${membershipError.message}`);
+        }
     }
     return rows.length;
 }
+async function countSalesNavigatorAccountsForRun(params) {
+    if (params.store.kind === "postgres") {
+        const result = await params.store.client.query(`SELECT count(*)::text AS count
+       FROM public.salesprompter_linkedin_sales_nav_account_run_memberships
+       WHERE run_id = $1`, [params.runId]);
+        return Number(result.rows[0]?.count ?? 0);
+    }
+    const { count, error } = await params.store.client
+        .from(SALESPROMPTER_SUPABASE_TABLES.accountRunMemberships)
+        .select("account_key", { count: "exact", head: true })
+        .eq("run_id", params.runId);
+    if (error) {
+        throw new Error(`Failed to count Sales Navigator account run membership in Supabase: ${error.message}`);
+    }
+    return count ?? 0;
+}
 function asJsonObject(value) {
     return typeof value === "object" && value !== null && !Array.isArray(value)
         ? value
@@ -8145,8 +9811,8 @@ async function listSalesNavigatorAccountSearchRepairSlices(params) {
         runs.slice_preset,
         runs.max_results_per_search,
         runs.page_size
-      FROM public.linkedin_sales_nav_account_search_slices AS slices
-      INNER JOIN public.linkedin_sales_nav_account_search_runs AS runs
+      FROM public.salesprompter_linkedin_sales_nav_account_search_slices AS slices
+      INNER JOIN public.salesprompter_linkedin_sales_nav_account_search_runs AS runs
         ON runs.id = slices.run_id
       WHERE slices.run_id = $1
         AND slices.status IN ('failed', 'unresolved')
@@ -8178,32 +9844,52 @@ async function listSalesNavigatorAccountSearchRepairSlices(params) {
     }));
 }
 async function summarizeSalesNavigatorAccountSearchRunFromSlices(params) {
-    if (params.store.kind !== "postgres") {
-        throw new Error("Account run summary requires direct Postgres access. Set DATABASE_URL or SALESPROMPTER_DATABASE_URL.");
+    if (params.store.kind === "supabase") {
+        const { data, error } = await params.store.client
+            .from(SALESPROMPTER_SUPABASE_TABLES.accountSearchSlices)
+            .select("status,last_error,updated_at")
+            .eq("run_id", params.runId);
+        if (error) {
+            throw new Error(`Failed to summarize Sales Navigator account slices in Supabase: ${error.message}`);
+        }
+        const rows = (data ?? []);
+        const finalRows = rows.filter((row) => row.status !== "split");
+        const failedRows = rows.filter((row) => row.status === "failed");
+        const unresolvedRows = rows.filter((row) => row.status === "unresolved");
+        const latestProblem = [...failedRows, ...unresolvedRows].sort((a, b) => Date.parse(b.updated_at) - Date.parse(a.updated_at))[0];
+        return {
+            totalSlices: finalRows.length,
+            storedAccounts: await countSalesNavigatorAccountsForRun(params),
+            attemptedSlices: finalRows.length,
+            splitEvents: rows.filter((row) => row.status === "split").length,
+            failedSlices: failedRows.length,
+            unresolvedSlices: unresolvedRows.length,
+            truncated: failedRows.length > 0 || unresolvedRows.length > 0,
+            lastError: latestProblem?.last_error ?? null,
+        };
     }
     const result = await params.store.client.query(`SELECT
         count(*) FILTER (WHERE status <> 'split')::int AS total_slices,
-        COALESCE(sum(stored_accounts) FILTER (WHERE status <> 'split'), 0)::int AS stored_accounts,
         count(*) FILTER (WHERE status <> 'split')::int AS attempted_slices,
         count(*) FILTER (WHERE status = 'split')::int AS split_events,
         count(*) FILTER (WHERE status = 'failed')::int AS failed_slices,
         count(*) FILTER (WHERE status = 'unresolved')::int AS unresolved_slices,
         (
           SELECT last_error
-          FROM public.linkedin_sales_nav_account_search_slices
+          FROM public.salesprompter_linkedin_sales_nav_account_search_slices
           WHERE run_id = $1
             AND status IN ('failed', 'unresolved')
           ORDER BY updated_at DESC
           LIMIT 1
         ) AS last_error
-      FROM public.linkedin_sales_nav_account_search_slices
+      FROM public.salesprompter_linkedin_sales_nav_account_search_slices
       WHERE run_id = $1`, [params.runId]);
     const row = result.rows[0] ?? {};
     const failedSlices = Number(row.failed_slices ?? 0);
     const unresolvedSlices = Number(row.unresolved_slices ?? 0);
     return {
         totalSlices: Number(row.total_slices ?? 0),
-        storedAccounts: Number(row.stored_accounts ?? 0),
+        storedAccounts: await countSalesNavigatorAccountsForRun(params),
         attemptedSlices: Number(row.attempted_slices ?? 0),
         splitEvents: Number(row.split_events ?? 0),
         failedSlices,
@@ -11499,6 +13185,199 @@ program
         }
     });
 });
+async function runAffiliateLaunchCommand(options) {
+    const affiliateLink = z.string().url().parse(options.affiliateLink);
+    const linkedInUrl = z.string().url().parse(options.linkedinUrl);
+    const maxResults = z.coerce.number().int().min(1).max(1000).parse(options.maxResults);
+    const session = await requireAuthSession();
+    const isSalesNavigatorPeopleSearch = new URL(linkedInUrl).pathname.includes("/sales/search/people");
+    let localResults;
+    let localCollection;
+    if (!options.dryRun && isSalesNavigatorPeopleSearch) {
+        const pageSize = z.coerce.number().int().min(1).max(100).parse(options.pageSize);
+        const pageDelayMinMs = z.coerce.number().int().min(0).parse(options.pageDelayMinMs);
+        const pageDelayMaxMs = z.coerce.number().int().min(pageDelayMinMs).parse(options.pageDelayMaxMs);
+        const browserRelayPort = options.browserRelayPort == null
+            ? null
+            : z.coerce.number().int().min(0).max(65535).parse(options.browserRelayPort);
+        if (options.curlFile && browserRelayPort != null) {
+            throw new Error("Use either --curl-file or --browser-relay-port, not both.");
+        }
+        const parsedRequest = options.curlFile
+            ? parseSalesNavigatorCurlRequest(await readFile(path.resolve(String(options.curlFile)), "utf8"))
+            : browserRelayPort != null
+                ? {
+                    url: buildSalesNavigatorLeadApiUrlFromSearchUrl(linkedInUrl, pageSize),
+                    headers: {},
+                }
+                : buildSalesNavigatorApiRequestFromSearchUrl(linkedInUrl, await readLinkedInDirectLookupConfig(), pageSize);
+        if (!new URL(parsedRequest.url).pathname.includes("/sales-api/salesApiLeadSearch")) {
+            throw new Error("Affiliate --curl-file must contain a /sales-api/salesApiLeadSearch request.");
+        }
+        const browserRelay = browserRelayPort == null
+            ? null
+            : await createLocalAccountSearchBrowserRelay(browserRelayPort);
+        let collected;
+        try {
+            collected = await fetchAllLocalSalesNavigatorPeople(parsedRequest, {
+                requestedProfiles: maxResults,
+                pageSize,
+                pageDelayMinMs,
+                pageDelayMaxMs,
+                retry: {
+                    maxRetries: 2,
+                    retryBaseDelayMs: 2_000,
+                    retryMaxDelayMs: 10_000,
+                },
+                executeRequest: browserRelay
+                    ? (request) => browserRelay.request(request.url)
+                    : undefined,
+            });
+        }
+        finally {
+            await browserRelay?.close();
+        }
+        localResults = collected.people;
+        localCollection = {
+            totalResults: collected.totalResults,
+            fetchedPages: collected.fetchedPages,
+            pacing: collected.pacing,
+        };
+    }
+    const payload = await launchAffiliateCampaignViaApp(session, {
+        affiliateLink,
+        linkedInUrl,
+        maxResults,
+        dryRun: Boolean(options.dryRun),
+        localResults,
+        localCollection,
+    });
+    if (options.out) {
+        await writeJsonFile(options.out, payload);
+    }
+    return { session, payload };
+}
+function addAffiliateAudienceOptions(command) {
+    return command
+        .requiredOption("--affiliate-link <url>", "Affiliate link to promote")
+        .requiredOption("--linkedin-url <url>", "Sales Navigator people or LinkedIn content search URL")
+        .option("--max-results <number>", "Maximum audience results", "1000")
+        .option("--curl-file <path>", "Optional copied Sales Navigator Lead Search curl request")
+        .option("--browser-relay-port <number>", "Use the signed-in browser through a loopback relay")
+        .option("--page-size <number>", "Direct Sales Navigator page size", "100")
+        .option("--page-delay-min-ms <number>", "Minimum delay between direct pages", "5000")
+        .option("--page-delay-max-ms <number>", "Maximum delay between direct pages", "8000")
+        .option("--dry-run", "Validate and preview without creating remote resources", false)
+        .option("--out <path>", "Optional local JSON output path");
+}
+addAffiliateAudienceOptions(program
+    .command("affiliate:launch")
+    .description("Build an affiliate audience from an affiliate link and LinkedIn search URL."))
+    .action(async (options) => {
+    const { payload } = await runAffiliateLaunchCommand(options);
+    printOutput(payload);
+});
+addAffiliateAudienceOptions(program
+    .command("affiliate:run")
+    .description("Build an affiliate audience and prepare a reviewed Instantly campaign end to end."))
+    .option("--campaign-name <name>", "Optional Instantly campaign name")
+    .option("--language <language>", "Sequence language", "English")
+    .option("--steps <number>", "Number of sequence emails", "3")
+    .option("--min-email-score <number>", "Minimum Hunter confidence score", "80")
+    .option("--allow-accept-all", "Include catch-all domains that meet the score threshold", false)
+    .option("--daily-limit <number>", "Maximum new leads contacted per day", "25")
+    .option("--timezone <timezone>", "Instantly sending timezone", "America/Detroit")
+    .option("--send-from <time>", "Weekday sending window start (HH:MM)", "09:00")
+    .option("--send-to <time>", "Weekday sending window end (HH:MM)", "16:00")
+    .option("--activate", "Activate the prepared Instantly campaign after review data is returned", false)
+    .action(async (options) => {
+    const launched = await runAffiliateLaunchCommand(options);
+    if (options.dryRun) {
+        printOutput({
+            ...launched.payload,
+            outreach: {
+                status: "dry-run",
+                provider: "instantly",
+                activation: "not_requested"
+            }
+        });
+        return;
+    }
+    const runId = launched.payload.extraction &&
+        typeof launched.payload.extraction.runId === "string"
+        ? launched.payload.extraction.runId
+        : null;
+    if (!runId) {
+        throw new Error("The audience provider did not return a durable run id. End-to-end outreach requires a Sales Navigator people search.");
+    }
+    const outreach = await prepareAffiliateOutreachViaApp(launched.session, {
+        audienceRunId: z.string().uuid().parse(runId),
+        campaignName: options.campaignName?.trim() || undefined,
+        language: z.string().trim().min(1).max(40).parse(options.language),
+        numberOfSteps: z.coerce.number().int().min(1).max(6).parse(options.steps),
+        minEmailScore: z.coerce.number().int().min(0).max(100).parse(options.minEmailScore),
+        allowAcceptAll: Boolean(options.allowAcceptAll),
+        dailyLimit: z.coerce.number().int().min(1).max(1000).parse(options.dailyLimit),
+        timezone: z.string().trim().min(1).max(100).parse(options.timezone),
+        sendFrom: z.string().regex(/^([01]\d|2[0-3]):[0-5]\d$/).parse(options.sendFrom),
+        sendTo: z.string().regex(/^([01]\d|2[0-3]):[0-5]\d$/).parse(options.sendTo)
+    });
+    const finalOutreach = options.activate
+        ? await activateAffiliateOutreachViaApp(launched.session, runId)
+        : outreach;
+    printOutput({
+        status: "ok",
+        audience: launched.payload,
+        outreach: finalOutreach,
+        next: finalOutreach.status === "ready"
+            ? `Review the sequence, then run: salesprompter affiliate:activate ${runId}`
+            : "The Instantly campaign is active."
+    });
+});
+program
+    .command("affiliate:status <run-id>")
+    .description("Show enrichment, sequence, Instantly, and activation status for an affiliate run.")
+    .action(async (runId) => {
+    const session = await requireAuthSession();
+    const outreach = await getAffiliateOutreachViaApp(session, z.string().uuid().parse(runId));
+    printOutput({ status: "ok", outreach });
+});
+program
+    .command("affiliate:regenerate-sequence <run-id>")
+    .description("Regenerate sequence variants and spintax, then sync them to Instantly.")
+    .action(async (runId) => {
+    const session = await requireAuthSession();
+    const outreach = await regenerateAffiliateOutreachSequenceViaApp(session, z.string().uuid().parse(runId));
+    printOutput({
+        status: "ok",
+        outreach,
+        message: "Sequence variants and spintax were regenerated and synced to Instantly."
+    });
+});
+program
+    .command("affiliate:enrich <run-id>")
+    .description("Find additional verified emails and add only new leads to the campaign.")
+    .action(async (runId) => {
+    const session = await requireAuthSession();
+    const outreach = await enrichAffiliateOutreachViaApp(session, z.string().uuid().parse(runId));
+    printOutput({
+        status: "ok",
+        outreach,
+        message: "Email recovery finished and new verified leads were added."
+    });
+});
+program
+    .command("affiliate:activate <run-id>")
+    .description("Activate a reviewed Instantly affiliate campaign.")
+    .action(async (runId) => {
+    const session = await requireAuthSession();
+    const outreach = await activateAffiliateOutreachViaApp(session, z.string().uuid().parse(runId));
+    printOutput({
+        status: "ok",
+        outreach,
+        message: "The Instantly campaign is active."
+    });
+});
 program
     .command("sync:crm")
     .description("Dry-run sync scored leads into a CRM target.")
@@ -12274,16 +14153,533 @@ program
     await writeJsonFile(samplesPath, samples);
     printOutput(payload);
 });
+program
+    .command("salesnav:accounts:collect")
+    .alias("accounts:collect")
+    .description("Collect an exhaustive Sales Navigator account search locally with a durable checkpoint.")
+    .requiredOption("--query-url <url>", "LinkedIn Sales Navigator account search URL")
+    .requiredOption("--checkpoint <path>", "Checkpoint file used to resume after rate limits or interruptions")
+    .requiredOption("--raw-out <path>", "Line-delimited raw account results used by accounts:local-import")
+    .option("--curl-file <path>", "Path to a saved account-search curl request used as the local request template")
+    .option("--browser-relay-port <number>", "Use the signed-in local browser as Account Search transport through this loopback port")
+    .option("--reported-total <number>", "Known root result total. Skips the initial one-request root count probe.")
+    .option("--max-results-per-search <number>", "Maximum pageable results per final filter slice", String(LOCAL_ACCOUNT_SEARCH_COLLECTOR_RESULT_WINDOW))
+    .option("--page-size <number>", "Accounts requested per Account Search API request", "100")
+    .option("--delay-min-ms <number>", "Minimum randomized delay between Account Search API requests", "5000")
+    .option("--delay-max-ms <number>", "Maximum randomized delay between Account Search API requests", "8000")
+    .option("--max-requests <number>", "Maximum API requests in this invocation, or 'all'", "all")
+    .option("--max-retries <number>", "Retries for transient network/5xx failures. Rate limits stop immediately.", "1")
+    .option("--retry-base-delay-ms <number>", "Base delay for full-jitter retry backoff", "2000")
+    .option("--retry-max-delay-ms <number>", "Maximum delay for full-jitter retry backoff", "30000")
+    .option("--out <path>", "Optional JSON summary output path")
+    .action(async (options) => {
+    const queryUrl = z.string().url().parse(options.queryUrl);
+    const checkpointPath = path.resolve(z.string().min(1).parse(options.checkpoint));
+    const rawOutputPath = path.resolve(z.string().min(1).parse(options.rawOut));
+    const cap = z.coerce
+        .number()
+        .int()
+        .min(1)
+        .max(LOCAL_ACCOUNT_SEARCH_COLLECTOR_RESULT_WINDOW)
+        .parse(options.maxResultsPerSearch);
+    const pageSize = z.coerce
+        .number()
+        .int()
+        .min(1)
+        .max(100)
+        .parse(options.pageSize);
+    const delayMinMs = z.coerce
+        .number()
+        .int()
+        .min(0)
+        .max(300000)
+        .parse(options.delayMinMs);
+    const delayMaxMs = z.coerce
+        .number()
+        .int()
+        .min(0)
+        .max(300000)
+        .parse(options.delayMaxMs);
+    if (delayMaxMs < delayMinMs) {
+        throw new Error("--delay-max-ms must be greater than or equal to --delay-min-ms.");
+    }
+    const maxRequestsOption = String(options.maxRequests ?? "all")
+        .trim()
+        .toLowerCase();
+    const maxRequests = maxRequestsOption === "all"
+        ? null
+        : z.coerce.number().int().min(1).max(100000).parse(options.maxRequests);
+    const reportedTotal = options.reportedTotal == null
+        ? null
+        : z.coerce
+            .number()
+            .int()
+            .min(1)
+            .max(1_000_000)
+            .parse(options.reportedTotal);
+    const retry = {
+        maxRetries: z.coerce
+            .number()
+            .int()
+            .min(0)
+            .max(5)
+            .parse(options.maxRetries),
+        retryBaseDelayMs: z.coerce
+            .number()
+            .int()
+            .min(0)
+            .max(300000)
+            .parse(options.retryBaseDelayMs),
+        retryMaxDelayMs: z.coerce
+            .number()
+            .int()
+            .min(0)
+            .max(300000)
+            .parse(options.retryMaxDelayMs),
+    };
+    const normalizedSourceQueryUrl = buildSalesNavigatorAccountQuery(queryUrl, []).sourceQueryUrl;
+    let checkpoint;
+    if (await fileExists(checkpointPath)) {
+        checkpoint = parseLocalAccountSearchCollectorCheckpoint(JSON.parse(await readFile(checkpointPath, "utf8")));
+        const normalizedCheckpointUrl = buildSalesNavigatorAccountQuery(checkpoint.sourceQueryUrl, []).sourceQueryUrl;
+        if (normalizedCheckpointUrl !== normalizedSourceQueryUrl) {
+            throw new Error("The checkpoint belongs to a different Sales Navigator account search.");
+        }
+        if (checkpoint.pageSize !== pageSize || checkpoint.cap > cap) {
+            throw new Error(`Checkpoint paging does not match this invocation. Use --max-results-per-search ${checkpoint.cap} --page-size ${checkpoint.pageSize}.`);
+        }
+        if (checkpoint.cap < cap) {
+            checkpoint.cap = cap;
+        }
+        checkpoint.delayMinMs = delayMinMs;
+        checkpoint.delayMaxMs = delayMaxMs;
+        if (reportedTotal != null && checkpoint.rootTotal == null) {
+            checkpoint.rootTotal = reportedTotal;
+        }
+    }
+    else {
+        checkpoint = createLocalAccountSearchCollectorCheckpoint({
+            sourceQueryUrl: queryUrl,
+            rootTotal: reportedTotal,
+            cap,
+            pageSize,
+            delayMinMs,
+            delayMaxMs,
+        });
+    }
+    if (migrateLocalAccountSearchCollectorCheckpoint(checkpoint)) {
+        await saveLocalAccountSearchCollectorCheckpoint(checkpointPath, checkpoint);
+    }
+    const curlFile = typeof options.curlFile === "string" && options.curlFile.trim().length > 0
+        ? options.curlFile.trim()
+        : null;
+    const browserRelayPort = options.browserRelayPort == null
+        ? null
+        : z.coerce
+            .number()
+            .int()
+            .min(1)
+            .max(65535)
+            .parse(options.browserRelayPort);
+    if (curlFile && browserRelayPort != null) {
+        throw new Error("Use either --curl-file or --browser-relay-port, not both.");
+    }
+    const templateRequest = curlFile
+        ? parseSalesNavigatorCurlRequest(await readFile(curlFile, "utf8"))
+        : null;
+    if (templateRequest &&
+        !new URL(templateRequest.url).pathname.includes("/sales-api/salesApiAccountSearch")) {
+        throw new Error("Account collection --curl-file must contain a /sales-api/salesApiAccountSearch request.");
+    }
+    const config = templateRequest || browserRelayPort != null
+        ? null
+        : await readLinkedInAccountSearchConfig(queryUrl);
+    const browserRelay = browserRelayPort == null
+        ? null
+        : await createLocalAccountSearchBrowserRelay(browserRelayPort);
+    const buildRequest = (searchUrl, start, count) => {
+        const request = browserRelay
+            ? {
+                url: buildSalesNavigatorAccountApiUrlFromSearchUrl(searchUrl, pageSize),
+                headers: {},
+            }
+            : templateRequest
+                ? buildSalesNavigatorAccountApiRequestFromSearchUrlWithTemplate(searchUrl, templateRequest, pageSize)
+                : buildSalesNavigatorAccountApiRequestFromSearchUrl(searchUrl, config, pageSize);
+        return {
+            ...request,
+            url: withSalesNavigatorPaging(request.url, start, count),
+        };
+    };
+    const executeRequest = (request) => browserRelay
+        ? browserRelay.request(request.url)
+        : fetchLocalSalesNavigatorRequest(request, retry);
+    try {
+        let requestsThisRun = 0;
+        let delayThisRunMs = 0;
+        const distinctAccountKeys = await loadLocalAccountSearchRawAccountKeys(rawOutputPath);
+        checkpoint.distinctAccounts = distinctAccountKeys.size;
+        checkpoint.completedByDistinctCount =
+            checkpoint.rootTotal != null &&
+                distinctAccountKeys.size >= checkpoint.rootTotal;
+        if (checkpoint.completedByDistinctCount) {
+            checkpoint.taskQueue = [];
+            await saveLocalAccountSearchCollectorCheckpoint(checkpointPath, checkpoint);
+        }
+        const requestBudgetAvailable = () => maxRequests == null || requestsThisRun < maxRequests;
+        const stopForRateLimit = async (error, task) => {
+            checkpoint.rateLimited = {
+                at: new Date().toISOString(),
+                retryAfter: error.retryAfterMs,
+                status: error.status,
+                task,
+            };
+            await saveLocalAccountSearchCollectorCheckpoint(checkpointPath, checkpoint);
+        };
+        if (checkpoint.rootTotal == null && requestBudgetAvailable()) {
+            try {
+                const rootResponse = await executeRequest(buildRequest(queryUrl, 0, 1));
+                requestsThisRun += 1;
+                checkpoint.requests += 1;
+                checkpoint.rootTotal = extractLocalSalesNavigatorTotalResults(rootResponse.body);
+                checkpoint.rateLimited = null;
+                if (checkpoint.rootTotal == null) {
+                    throw new Error("Sales Navigator Account Search root response did not include a result total.");
+                }
+                await saveLocalAccountSearchCollectorCheckpoint(checkpointPath, checkpoint);
+            }
+            catch (error) {
+                if (error instanceof LocalSalesNavigatorRateLimitError) {
+                    await stopForRateLimit(error, { kind: "root" });
+                    const payload = {
+                        status: "rate_limited",
+                        mode: "account-local-collector",
+                        checkpointPath,
+                        rawOutputPath,
+                        requestsThisRun,
+                        requests: checkpoint.requests,
+                        remainingTasks: checkpoint.taskQueue.length,
+                        rateLimited: checkpoint.rateLimited,
+                    };
+                    if (options.out) {
+                        await writeJsonFile(options.out, payload);
+                    }
+                    printOutput(payload);
+                    return;
+                }
+                throw error;
+            }
+        }
+        if (checkpoint.rootTotal != null &&
+            checkpoint.taskQueue.length === 0 &&
+            checkpoint.seenQueries.length === 0) {
+            seedLocalAccountSearchCollectorTasks(checkpoint);
+            await saveLocalAccountSearchCollectorCheckpoint(checkpointPath, checkpoint);
+        }
+        const dimensions = new Map([
+            ...DEFAULT_SALES_NAVIGATOR_ACCOUNT_CRAWL_DIMENSIONS,
+            LOCAL_ACCOUNT_SEARCH_COLLECTOR_GROWTH_DIMENSION,
+        ].map((dimension) => [dimension.filterType, dimension]));
+        const seenQueries = new Set(checkpoint.seenQueries);
+        let stoppedByRateLimit = false;
+        while (checkpoint.taskQueue.length > 0 && requestBudgetAvailable()) {
+            const task = checkpoint.taskQueue[0];
+            const searchUrl = task.kind === "node"
+                ? task.searchUrlOverride ??
+                    buildSalesNavigatorAccountQuery(checkpoint.sourceQueryUrl, task.filters).slicedQueryUrl
+                : task.searchUrl;
+            const start = task.kind === "page" ? task.start : 0;
+            let response;
+            try {
+                response = await executeRequest(buildRequest(searchUrl, start, pageSize));
+            }
+            catch (error) {
+                if (error instanceof LocalSalesNavigatorRateLimitError) {
+                    stoppedByRateLimit = true;
+                    await stopForRateLimit(error, task);
+                    break;
+                }
+                checkpoint.failures.push({
+                    at: new Date().toISOString(),
+                    task,
+                    error: error instanceof Error ? error.message : String(error),
+                });
+                await saveLocalAccountSearchCollectorCheckpoint(checkpointPath, checkpoint);
+                throw error;
+            }
+            requestsThisRun += 1;
+            checkpoint.requests += 1;
+            checkpoint.rateLimited = null;
+            const elements = extractLocalSalesNavigatorElements(response.body);
+            await appendLocalAccountSearchRawElements({
+                rawOutputPath,
+                searchUrl,
+                elements,
+            });
+            for (const element of elements) {
+                addLocalAccountSearchElementKey(distinctAccountKeys, element, searchUrl);
+            }
+            checkpoint.distinctAccounts = distinctAccountKeys.size;
+            checkpoint.pagesWritten += 1;
+            checkpoint.rowsWritten += elements.length;
+            if (checkpoint.rootTotal != null &&
+                distinctAccountKeys.size >= checkpoint.rootTotal) {
+                checkpoint.taskQueue = [];
+                checkpoint.completedByDistinctCount = true;
+                await saveLocalAccountSearchCollectorCheckpoint(checkpointPath, checkpoint);
+                break;
+            }
+            if (task.kind === "node") {
+                const total = extractLocalSalesNavigatorTotalResults(response.body);
+                if (total == null) {
+                    checkpoint.failures.push({
+                        at: new Date().toISOString(),
+                        task,
+                        error: "Account Search response did not include a result total.",
+                    });
+                }
+                else if (total <= cap) {
+                    checkpoint.leaves.push({
+                        id: task.id,
+                        pass: task.pass,
+                        total,
+                        searchUrl,
+                        filters: task.filters,
+                    });
+                    const pageTasks = [];
+                    for (let pageStart = pageSize; pageStart < total; pageStart += pageSize) {
+                        pageTasks.push({
+                            kind: "page",
+                            id: task.id,
+                            pass: task.pass,
+                            searchUrl,
+                            start: pageStart,
+                            total,
+                        });
+                    }
+                    enqueueLocalAccountSearchCollectorTasks(checkpoint, task, pageTasks);
+                }
+                else {
+                    const [nextFilterType, ...remainingDimensions] = task.remainingDimensions;
+                    const dimension = nextFilterType
+                        ? dimensions.get(nextFilterType)
+                        : null;
+                    if (!dimension) {
+                        const bayAreaPartitionPlan = buildLocalAccountSearchCollectorBayAreaPartitions(checkpoint.sourceQueryUrl, task.filters);
+                        if (!bayAreaPartitionPlan) {
+                            const industryPartitionPlan = task.pass.startsWith("coverage-")
+                                ? buildLocalAccountSearchCollectorIndustryPartitions(searchUrl)
+                                : null;
+                            if (industryPartitionPlan) {
+                                checkpoint.windows.push({
+                                    id: task.id,
+                                    pass: task.pass,
+                                    total,
+                                    searchUrl,
+                                    splitOn: industryPartitionPlan.splitOn,
+                                });
+                                const industryTasks = [];
+                                for (const partition of industryPartitionPlan.partitions) {
+                                    const childQueryKey = localAccountSearchCollectorSeenKey(task.pass, partition.searchUrl);
+                                    if (seenQueries.has(childQueryKey)) {
+                                        checkpoint.duplicateQueries += 1;
+                                        continue;
+                                    }
+                                    seenQueries.add(childQueryKey);
+                                    industryTasks.push({
+                                        kind: "node",
+                                        id: `${task.id}-${industryPartitionPlan.splitOn}-${partition.idSuffix}`,
+                                        pass: task.pass,
+                                        filters: task.filters.map((filter) => ({
+                                            ...filter,
+                                            values: filter.values.map((value) => ({ ...value })),
+                                        })),
+                                        remainingDimensions: [],
+                                        searchUrlOverride: partition.searchUrl,
+                                        keywordClauses: task.keywordClauses
+                                            ? [...task.keywordClauses]
+                                            : undefined,
+                                        keywordDepth: task.keywordDepth,
+                                    });
+                                }
+                                enqueueLocalAccountSearchCollectorTasks(checkpoint, task, industryTasks);
+                            }
+                            else {
+                                const keywordPartitionPlan = buildLocalAccountSearchCollectorKeywordPartitions(searchUrl, task);
+                                if (!keywordPartitionPlan) {
+                                    const terminalPageLimit = Math.min(total, cap);
+                                    const pageTasks = [];
+                                    for (let pageStart = pageSize; pageStart < terminalPageLimit; pageStart += pageSize) {
+                                        pageTasks.push({
+                                            kind: "page",
+                                            id: task.id,
+                                            pass: task.pass,
+                                            searchUrl,
+                                            start: pageStart,
+                                            total,
+                                        });
+                                    }
+                                    enqueueLocalAccountSearchCollectorTasks(checkpoint, task, pageTasks);
+                                    checkpoint.failures.push({
+                                        at: new Date().toISOString(),
+                                        task,
+                                        total,
+                                        collectedResultWindow: terminalPageLimit,
+                                        missingBeyondResultWindow: Math.max(0, total - terminalPageLimit),
+                                        error: `Account Search slice remains above ${cap} with no split dimension left.`,
+                                    });
+                                }
+                                else {
+                                    checkpoint.windows.push({
+                                        id: task.id,
+                                        pass: task.pass,
+                                        total,
+                                        searchUrl,
+                                        splitOn: keywordPartitionPlan.splitOn,
+                                    });
+                                    const keywordTasks = [];
+                                    for (const partition of keywordPartitionPlan.partitions) {
+                                        const childQueryKey = localAccountSearchCollectorSeenKey(task.pass, partition.searchUrl);
+                                        if (seenQueries.has(childQueryKey)) {
+                                            checkpoint.duplicateQueries += 1;
+                                            continue;
+                                        }
+                                        seenQueries.add(childQueryKey);
+                                        keywordTasks.push({
+                                            kind: "node",
+                                            id: `${task.id}-${keywordPartitionPlan.splitOn}-${partition.idSuffix}`,
+                                            pass: task.pass,
+                                            filters: task.filters.map((filter) => ({
+                                                ...filter,
+                                                values: filter.values.map((value) => ({ ...value })),
+                                            })),
+                                            remainingDimensions: [],
+                                            searchUrlOverride: partition.searchUrl,
+                                            keywordClauses: partition.keywordClauses,
+                                            keywordDepth: partition.keywordDepth,
+                                        });
+                                    }
+                                    enqueueLocalAccountSearchCollectorTasks(checkpoint, task, keywordTasks);
+                                }
+                            }
+                        }
+                        else {
+                            checkpoint.windows.push({
+                                id: task.id,
+                                pass: task.pass,
+                                total,
+                                searchUrl,
+                                splitOn: bayAreaPartitionPlan.splitOn,
+                            });
+                            const regionTasks = [];
+                            bayAreaPartitionPlan.partitions.forEach((filters, index) => {
+                                const childSearchUrl = buildSalesNavigatorAccountQuery(checkpoint.sourceQueryUrl, filters).slicedQueryUrl;
+                                const childQueryKey = localAccountSearchCollectorSeenKey(task.pass, childSearchUrl);
+                                if (seenQueries.has(childQueryKey)) {
+                                    checkpoint.duplicateQueries += 1;
+                                    return;
+                                }
+                                seenQueries.add(childQueryKey);
+                                regionTasks.push({
+                                    kind: "node",
+                                    id: `${task.id}-${bayAreaPartitionPlan.splitOn}-${index}`,
+                                    pass: task.pass,
+                                    filters,
+                                    remainingDimensions: [],
+                                });
+                            });
+                            enqueueLocalAccountSearchCollectorTasks(checkpoint, task, regionTasks);
+                        }
+                    }
+                    else {
+                        checkpoint.windows.push({
+                            id: task.id,
+                            pass: task.pass,
+                            total,
+                            searchUrl,
+                            splitOn: dimension.filterType,
+                        });
+                        const dimensionTasks = [];
+                        buildLocalAccountSearchCollectorDimensionPartitions(dimension).forEach((partition) => {
+                            const filters = [
+                                ...task.filters,
+                                partition.filter,
+                            ];
+                            const childSearchUrl = buildSalesNavigatorAccountQuery(checkpoint.sourceQueryUrl, filters).slicedQueryUrl;
+                            const childQueryKey = localAccountSearchCollectorSeenKey(task.pass, childSearchUrl);
+                            if (seenQueries.has(childQueryKey)) {
+                                checkpoint.duplicateQueries += 1;
+                                return;
+                            }
+                            seenQueries.add(childQueryKey);
+                            dimensionTasks.push({
+                                kind: "node",
+                                id: `${task.id}-${dimension.filterType}-${partition.idSuffix}`,
+                                pass: task.pass,
+                                filters,
+                                remainingDimensions,
+                            });
+                        });
+                        enqueueLocalAccountSearchCollectorTasks(checkpoint, task, dimensionTasks);
+                    }
+                }
+            }
+            checkpoint.taskQueue.shift();
+            checkpoint.seenQueries = [...seenQueries];
+            await saveLocalAccountSearchCollectorCheckpoint(checkpointPath, checkpoint);
+            if (checkpoint.taskQueue.length > 0 && requestBudgetAvailable()) {
+                const delayMs = randomIntegerBetween(delayMinMs, delayMaxMs);
+                if (delayMs > 0) {
+                    delayThisRunMs += delayMs;
+                    await delay(delayMs);
+                }
+            }
+        }
+        const payload = {
+            status: stoppedByRateLimit
+                ? "rate_limited"
+                : checkpoint.taskQueue.length === 0
+                    ? "complete"
+                    : "checkpointed",
+            mode: "account-local-collector",
+            sourceQueryUrl: checkpoint.sourceQueryUrl,
+            rootTotal: checkpoint.rootTotal,
+            checkpointPath,
+            rawOutputPath,
+            requestsThisRun,
+            delayThisRunMs,
+            requests: checkpoint.requests,
+            pagesWritten: checkpoint.pagesWritten,
+            rowsWritten: checkpoint.rowsWritten,
+            leaves: checkpoint.leaves.length,
+            windows: checkpoint.windows.length,
+            failures: checkpoint.failures.length,
+            remainingTasks: checkpoint.taskQueue.length,
+            distinctAccounts: distinctAccountKeys.size,
+            completedByDistinctCount: checkpoint.completedByDistinctCount === true,
+            rateLimited: checkpoint.rateLimited,
+            browserRelayPort: browserRelay?.port ?? null,
+        };
+        if (options.out) {
+            await writeJsonFile(options.out, payload);
+        }
+        printOutput(payload);
+    }
+    finally {
+        await browserRelay?.close();
+    }
+});
 program
     .command("salesnav:accounts:split")
     .alias("accounts:split")
     .description("Split a Sales Navigator account search into account slices below the result cap.")
     .requiredOption("--query-url <url>", "LinkedIn Sales Navigator account search URL")
     .option("--curl-file <path>", "Path to a saved account-search curl request used as the local request template")
-    .option("--org-id <id>", "Salesprompter workspace org id for Neon storage. Defaults to SALESPROMPTER_ORG_ID or saved auth session org.")
+    .option("--org-id <id>", "Salesprompter workspace org id for Supabase storage. Defaults to SALESPROMPTER_ORG_ID or saved auth session org.")
     .option("--max-results-per-search <number>", "Maximum account results allowed for each final slice", "1000")
     .option("--max-windowed-final-results <number>", "Bounded fallback fetch for an oversized final account slice when no split dimensions remain", "1000")
     .option("--no-windowed-final-slices", "Do not fetch pageable rows for oversized final account slices after adaptive splitting is exhausted")
+    .option("--include-location-mismatches", "Store account rows even when the visible Sales Navigator account location does not match the source REGION filter", false)
     .option("--max-split-depth <number>", "Maximum number of adaptive account split dimensions to use", "3")
     .option("--max-slices <number>", "Safety cap for total account slices probed in this invocation", "1000")
     .option("--probe-count <number>", "Accounts to request while probing each slice count", "1")
@@ -12389,6 +14785,7 @@ program
             .max(300000)
             .parse(options.retryMaxDelayMs),
     };
+    const filterLocationMismatches = !Boolean(options.includeLocationMismatches);
     const curlFile = typeof options.curlFile === "string" && options.curlFile.trim().length > 0
         ? options.curlFile.trim()
         : null;
@@ -12449,7 +14846,9 @@ program
         !new URL(templateRequest.url).pathname.includes("/sales-api/salesApiAccountSearch")) {
         throw new Error("Account split --curl-file must contain a /sales-api/salesApiAccountSearch request.");
     }
-    const config = templateRequest ? null : await readLinkedInDirectLookupConfig();
+    const config = templateRequest
+        ? null
+        : await readLinkedInAccountSearchConfig(queryUrl);
     const buildAccountApiRequest = (slicedQueryUrl) => templateRequest
         ? buildSalesNavigatorAccountApiRequestFromSearchUrlWithTemplate(slicedQueryUrl, templateRequest, pageSize)
         : buildSalesNavigatorAccountApiRequestFromSearchUrl(slicedQueryUrl, config, pageSize);
@@ -12602,6 +15001,9 @@ program
             },
             exportSlice: async (attempt) => {
                 const parsedRequest = buildAccountApiRequest(attempt.slicedQueryUrl);
+                const accountLocationFilter = filterLocationMismatches
+                    ? buildSalesNavigatorAccountLocationFilter(attempt.slicedQueryUrl)
+                    : null;
                 try {
                     const fetchResult = await fetchAllLocalSalesNavigatorAccounts(parsedRequest, {
                         requestedAccounts,
@@ -12610,6 +15012,7 @@ program
                         pageDelayMaxMs,
                         maxAllowedResults: attempt.maxResultsPerSearch,
                         retry,
+                        accountLocationFilter,
                     });
                     const stop = fetchResult.pacing.stop;
                     const partialError = describeLocalSalesNavigatorAccountPartialError(fetchResult);
@@ -12630,6 +15033,8 @@ program
                             slicedQueryUrl: attempt.slicedQueryUrl,
                             pacing: fetchResult.pacing,
                             stop,
+                            accountLocationFilter,
+                            filteredAccounts: fetchResult.filteredAccounts,
                         },
                     });
                     const storedAccounts = await upsertSalesNavigatorAccounts({
@@ -12639,7 +15044,10 @@ program
                         sliceId,
                         accounts: fetchResult.accounts,
                     });
-                    storedAccountCount += storedAccounts;
+                    storedAccountCount = await countSalesNavigatorAccountsForRun({
+                        store,
+                        runId,
+                    });
                     if (fetchResult.pacing.rateLimit) {
                         throw new SalesNavigatorCrawlStopError(fetchResult.pacing.rateLimit.message, {
                             totalResults: fetchResult.totalResults,
@@ -12739,6 +15147,9 @@ program
         if (canFetchWindowedFinalSlice) {
             try {
                 const parsedRequest = buildAccountApiRequest(failure.attempt.slicedQueryUrl);
+                const accountLocationFilter = filterLocationMismatches
+                    ? buildSalesNavigatorAccountLocationFilter(failure.attempt.slicedQueryUrl)
+                    : null;
                 const fetchResult = await fetchAllLocalSalesNavigatorAccounts(parsedRequest, {
                     requestedAccounts,
                     pageSize,
@@ -12747,6 +15158,7 @@ program
                     maxAllowedResults: maxWindowedFinalResults,
                     retry,
                     allowPartialPageErrors: true,
+                    accountLocationFilter,
                 });
                 const windowedError = describeLocalSalesNavigatorAccountPartialError(fetchResult);
                 const sliceId = await upsertSalesNavigatorAccountSearchSlice({
@@ -12768,6 +15180,8 @@ program
                         originalError: failure.error,
                         pacing: fetchResult.pacing,
                         stop: fetchResult.pacing.stop,
+                        accountLocationFilter,
+                        filteredAccounts: fetchResult.filteredAccounts,
                     },
                 });
                 const storedAccounts = await upsertSalesNavigatorAccounts({
@@ -12777,7 +15191,10 @@ program
                     sliceId,
                     accounts: fetchResult.accounts,
                 });
-                storedAccountCount += storedAccounts;
+                storedAccountCount = await countSalesNavigatorAccountsForRun({
+                    store,
+                    runId,
+                });
                 windowedFinalSlices.push({
                     slicedQueryUrl: failure.attempt.slicedQueryUrl,
                     appliedFilters: failure.attempt.appliedFilters,
@@ -13020,10 +15437,12 @@ program
 program
     .command("salesnav:accounts:local-import")
     .alias("accounts:local-import")
-    .description("Run a saved Sales Navigator account request locally and store the accounts in Neon.")
+    .description("Run a saved Sales Navigator account request locally and store the accounts in Supabase.")
     .option("--curl-file <path>", "Path to a saved account-search curl request copied from the Sales Navigator network panel")
     .option("--query-url <url>", "Sales Navigator account search URL. Uses the locally captured extension session automatically.")
-    .option("--org-id <id>", "Salesprompter workspace org id for Neon storage. Defaults to SALESPROMPTER_ORG_ID or saved auth session org.")
+    .option("--raw-results-file <path>", "Line-delimited raw Sales Navigator account results collected for --query-url")
+    .option("--reported-total <number>", "Reported total for completeness verification when using --raw-results-file")
+    .option("--org-id <id>", "Salesprompter workspace org id for Supabase storage. Defaults to SALESPROMPTER_ORG_ID or saved auth session org.")
     .option("--max-results-per-search <number>", "Maximum expected account results for this local request", "1000")
     .option("--number-of-accounts <number>", "Total accounts to import, or 'all' for the full reported result set", "all")
     .option("--page-size <number>", "Accounts requested per local Sales Navigator API page", "25")
@@ -13035,8 +15454,9 @@ program
     .option("--retry-max-delay-ms <number>", "Maximum delay for full-jitter retry backoff", "30000")
     .option("--slice-preset <name>", "Slice preset label stored with the import run", "local-account-search")
     .option("--allow-partial-page-errors", "Persist rows fetched before a later non-rate-limit page error", false)
+    .option("--include-location-mismatches", "Store account rows even when the visible Sales Navigator account location does not match the source REGION filter", false)
     .option("--out <path>", "Optional local JSON output path")
-    .option("--dry-run", "Run and normalize the local account request without writing to Neon", false)
+    .option("--dry-run", "Run and normalize the local account request without writing to Supabase", false)
     .action(async (options) => {
     const maxResultsPerSearch = z.coerce
         .number()
@@ -13102,31 +15522,76 @@ program
             .max(300000)
             .parse(options.retryMaxDelayMs),
     };
+    const filterLocationMismatches = !Boolean(options.includeLocationMismatches);
     const curlFile = typeof options.curlFile === "string" && options.curlFile.trim().length > 0
         ? options.curlFile.trim()
         : null;
     const queryUrl = typeof options.queryUrl === "string" && options.queryUrl.trim().length > 0
         ? z.string().url().parse(options.queryUrl.trim())
         : null;
-    if (Boolean(curlFile) === Boolean(queryUrl)) {
-        throw new Error("Provide exactly one of --curl-file or --query-url.");
+    const rawResultsFile = typeof options.rawResultsFile === "string" &&
+        options.rawResultsFile.trim().length > 0
+        ? options.rawResultsFile.trim()
+        : null;
+    const reportedTotal = options.reportedTotal == null
+        ? null
+        : z.coerce
+            .number()
+            .int()
+            .min(1)
+            .max(1_000_000)
+            .parse(options.reportedTotal);
+    if (rawResultsFile) {
+        if (curlFile || !queryUrl) {
+            throw new Error("--raw-results-file requires --query-url and cannot be combined with --curl-file.");
+        }
+        if (numberOfAccountsOption !== "all") {
+            throw new Error("--raw-results-file requires --number-of-accounts all so completeness can be verified.");
+        }
     }
-    const parsedRequest = curlFile
-        ? parseSalesNavigatorCurlRequest(await readFile(curlFile, "utf8"))
-        : buildSalesNavigatorAccountApiRequestFromSearchUrl(queryUrl, await readLinkedInDirectLookupConfig(), pageSize);
-    if (!new URL(parsedRequest.url).pathname.includes("/sales-api/salesApiAccountSearch")) {
-        throw new Error("Account local import requires a /sales-api/salesApiAccountSearch request.");
+    else if (Boolean(curlFile) === Boolean(queryUrl)) {
+        throw new Error("Provide exactly one of --curl-file or --query-url, or use --raw-results-file with --query-url.");
+    }
+    else if (reportedTotal != null) {
+        throw new Error("--reported-total is only supported with --raw-results-file.");
+    }
+    let accountLocationFilter = filterLocationMismatches
+        ? buildSalesNavigatorAccountLocationFilter(queryUrl ?? "")
+        : null;
+    let rawInputStats = null;
+    let localFetch;
+    if (rawResultsFile) {
+        const rawInput = await readLocalSalesNavigatorRawAccountInput({
+            filePath: rawResultsFile,
+            sourceQueryUrl: queryUrl,
+            reportedTotal,
+            accountLocationFilter,
+        });
+        rawInputStats = rawInput.stats;
+        localFetch = rawInput.fetchResult;
+    }
+    else {
+        const parsedRequest = curlFile
+            ? parseSalesNavigatorCurlRequest(await readFile(curlFile, "utf8"))
+            : buildSalesNavigatorAccountApiRequestFromSearchUrl(queryUrl, await readLinkedInAccountSearchConfig(queryUrl), pageSize);
+        if (!new URL(parsedRequest.url).pathname.includes("/sales-api/salesApiAccountSearch")) {
+            throw new Error("Account local import requires a /sales-api/salesApiAccountSearch request.");
+        }
+        if (filterLocationMismatches && !accountLocationFilter) {
+            accountLocationFilter = buildSalesNavigatorAccountLocationFilter(queryUrl ?? parsedRequest.url);
+        }
+        localFetch = await fetchAllLocalSalesNavigatorAccounts(parsedRequest, {
+            requestedAccounts,
+            startOffset,
+            pageSize,
+            pageDelayMinMs,
+            pageDelayMaxMs,
+            maxAllowedResults: maxResultsPerSearch,
+            retry,
+            allowPartialPageErrors: Boolean(options.allowPartialPageErrors),
+            accountLocationFilter,
+        });
     }
-    const localFetch = await fetchAllLocalSalesNavigatorAccounts(parsedRequest, {
-        requestedAccounts,
-        startOffset,
-        pageSize,
-        pageDelayMinMs,
-        pageDelayMaxMs,
-        maxAllowedResults: maxResultsPerSearch,
-        retry,
-        allowPartialPageErrors: Boolean(options.allowPartialPageErrors),
-    });
     const accounts = localFetch.accounts;
     const totalResults = localFetch.totalResults;
     const dryRun = Boolean(options.dryRun);
@@ -13136,6 +15601,9 @@ program
     if (accounts.length === 0) {
         throw new Error("The local Sales Navigator account response did not contain any importable account rows.");
     }
+    if (rawResultsFile && partialError) {
+        throw new Error(`Raw Sales Navigator account input is incomplete and was not stored. ${partialError}`);
+    }
     const sourceQueryUrl = queryUrl ?? localFetch.sourceQueryUrl;
     const basePayload = {
         status: "ok",
@@ -13144,6 +15612,7 @@ program
         sourceQueryUrl,
         totalResults,
         discovered: accounts.length,
+        filteredAccounts: localFetch.filteredAccounts,
         fetchedPages: localFetch.fetchedPages,
         requestedAccounts: requestedAccounts ?? "all",
         maxResultsPerSearch,
@@ -13153,7 +15622,8 @@ program
         rateLimit: rateLimit ?? null,
         pageError: pageError ?? null,
         stop: localFetch.pacing.stop,
-        accounts,
+        rawInput: rawInputStats,
+        accounts: rawResultsFile && !dryRun ? undefined : accounts,
     };
     if (dryRun) {
         if (options.out) {
@@ -13188,6 +15658,9 @@ program
             rateLimit: rateLimit ?? null,
             pageError: pageError ?? null,
             stop: localFetch.pacing.stop,
+            accountLocationFilter,
+            filteredAccounts: localFetch.filteredAccounts,
+            rawInput: rawInputStats,
         },
     });
     const attempt = {
@@ -13220,6 +15693,9 @@ program
                 startOffset,
                 pacing: localFetch.pacing,
                 stop: localFetch.pacing.stop,
+                accountLocationFilter,
+                filteredAccounts: localFetch.filteredAccounts,
+                rawInput: rawInputStats,
             },
         });
         const storedAccounts = await upsertSalesNavigatorAccounts({
@@ -13580,6 +16056,7 @@ program
     .option("--max-retries <number>", "Bounded retries for transient network/5xx failures. Rate limits still stop immediately.", "1")
     .option("--retry-base-delay-ms <number>", "Base delay for full-jitter retry backoff", "2000")
     .option("--retry-max-delay-ms <number>", "Maximum delay for full-jitter retry backoff", "30000")
+    .option("--include-location-mismatches", "Store account rows even when the visible Sales Navigator account location does not match the source REGION filter", false)
     .option("--out <path>", "Optional local JSON output path")
     .action(async (options) => {
     const runId = z.string().uuid().parse(options.runId);
@@ -13647,6 +16124,7 @@ program
             .max(300000)
             .parse(options.retryMaxDelayMs),
     };
+    const filterLocationMismatches = !Boolean(options.includeLocationMismatches);
     const templateRequest = parseSalesNavigatorCurlRequest(await readFile(options.curlFile, "utf8"));
     if (!new URL(templateRequest.url).pathname.includes("/sales-api/salesApiAccountSearch")) {
         throw new Error("Account repair --curl-file must contain a /sales-api/salesApiAccountSearch request.");
@@ -13701,6 +16179,9 @@ program
                     ? requestedAccountsOption
                     : Math.min(requestedAccountsOption, remainingFromReported);
             const parsedRequest = buildSalesNavigatorAccountApiRequestFromSearchUrlWithTemplate(slice.slicedQueryUrl, templateRequest, pageSize);
+            const accountLocationFilter = filterLocationMismatches
+                ? buildSalesNavigatorAccountLocationFilter(slice.slicedQueryUrl)
+                : null;
             const fetchResult = await fetchAllLocalSalesNavigatorAccounts(parsedRequest, {
                 requestedAccounts,
                 startOffset,
@@ -13710,6 +16191,7 @@ program
                 maxAllowedResults: 100000,
                 retry,
                 allowPartialPageErrors: true,
+                accountLocationFilter,
             });
             const rateLimit = fetchResult.pacing.rateLimit;
             const pageError = fetchResult.pacing.pageError;
@@ -13741,6 +16223,8 @@ program
                         previousStoredAccounts: slice.storedAccounts,
                         startOffset,
                         fetchedAccounts: fetchResult.accounts.length,
+                        filteredAccounts: fetchResult.filteredAccounts,
+                        accountLocationFilter,
                     },
                     pacing: fetchResult.pacing,
                     stop: fetchResult.pacing.stop,