linkedin-secret-sauce 0.1.1 → 0.2.0

package/dist/parsers/search-parser.d.ts

@@ -1,2 +1,2 @@
 import type { SalesLeadSearchResult } from '../types';
-export declare function parseSalesSearchResults(rawResponse: any): SalesLeadSearchResult[];
+export declare function parseSalesSearchResults(rawResponse: unknown): SalesLeadSearchResult[];

package/dist/parsers/search-parser.js

@@ -2,7 +2,8 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.parseSalesSearchResults = parseSalesSearchResults;
 function parseSalesSearchResults(rawResponse) {
-    const elements = Array.isArray(rawResponse?.elements) ? rawResponse.elements : [];
+    const rr = rawResponse;
+    const elements = Array.isArray(rr?.elements) ? rr?.elements : [];
     const results = [];
     for (const el of elements) {
         const name = [el?.firstName, el?.lastName].filter(Boolean).join(' ').trim() || undefined;
@@ -16,9 +17,18 @@ function parseSalesSearchResults(rawResponse) {
             summary: el?.summary,
         };
         // fsdKey from URN patterns
-        const m = String(el?.entityUrn || '').match(/^urn:li:(?:fs_salesProfile|fsd_profile):\(([^,\s)]+)/i);
-        if (m)
-            res.fsdKey = m[1];
+        const urn = String(el?.entityUrn || '');
+        const m3 = urn.match(/^urn:li:(?:fs_salesProfile|fsd_profile):\(([^,\s)]+),([^,\s)]+),([^,\s)]+)\)/i);
+        if (m3) {
+            res.fsdKey = m3[1];
+            res.salesAuthType = m3[2];
+            res.salesAuthToken = m3[3];
+        }
+        else {
+            const m1 = urn.match(/^urn:li:(?:fs_salesProfile|fsd_profile):\(([^,\s)]+)/i);
+            if (m1)
+                res.fsdKey = m1[1];
+        }
         // Image best artifact
         const img = el?.profilePictureDisplayImage;
         if (img?.rootUrl && Array.isArray(img?.artifacts) && img.artifacts.length) {

package/dist/types.d.ts

@@ -23,6 +23,7 @@ export interface ProfilePosition {
     endMonth?: number;
     isCurrent?: boolean;
     companyUrn?: string;
+    companyId?: string;
     companyLogoUrl?: string;
 }
 export interface ProfileEducation {
@@ -54,6 +55,8 @@ export interface SalesLeadSearchResult {
     salesProfileUrn?: string;
     objectUrn?: string;
     fsdKey?: string;
+    salesAuthType?: string;
+    salesAuthToken?: string;
     geoRegion?: string;
     locationText?: string;
     summary?: string;
@@ -61,3 +64,147 @@ export interface SalesLeadSearchResult {
     currentCompany?: string;
     companyLogoUrl?: string;
 }
+export interface SearchSalesResult {
+    items: SalesLeadSearchResult[];
+    page: {
+        start: number;
+        count: number;
+        total?: number;
+    };
+}
+export interface Company {
+    companyId: string;
+    universalName?: string;
+    name?: string;
+    websiteUrl?: string;
+    linkedinUrl?: string;
+    description?: string;
+    sizeLabel?: string;
+    followerCount?: number;
+    industries?: string[];
+    headquarters?: string;
+    logoUrl?: string;
+    coverUrl?: string;
+    foundedYear?: number;
+    companyType?: string;
+    specialties?: string[];
+    emailDomains?: string[];
+}
+export type TypeaheadType = 'BING_GEO' | 'TITLE' | 'INDUSTRY' | 'SENIORITY_LEVEL' | 'FUNCTION' | 'COMPANY_SIZE' | 'COMPANY' | 'PROFILE_LANGUAGE';
+export interface TypeaheadItem {
+    id: string;
+    text: string;
+}
+export interface TypeaheadResult {
+    items: TypeaheadItem[];
+    page: {
+        start: number;
+        count: number;
+        total?: number;
+    };
+}
+export interface SalesNavigatorProfile {
+    profileUrn?: string;
+    firstName?: string;
+    lastName?: string;
+    headline?: string;
+    summary?: string;
+    location?: string;
+    imageUrl?: string;
+    flagshipProfileUrl?: string;
+}
+export type Geo = {
+    type: 'region' | 'country' | 'state' | 'city' | 'postal';
+    value: string;
+    id?: string;
+};
+export type SalesSearchFilters = {
+    company?: {
+        current?: {
+            include?: string[];
+            exclude?: string[];
+        };
+        past?: {
+            include?: string[];
+            exclude?: string[];
+        };
+        headcount?: {
+            include?: ("1-10" | "11-50" | "51-200" | "201-500" | "501-1000" | "1001-5000" | "5001-10000" | "10000+")[];
+        };
+        type?: {
+            include?: ("PUBLIC" | "PRIVATE" | "NONPROFIT" | "EDUCATIONAL" | "GOVERNMENT")[];
+        };
+        hq?: Geo[];
+    };
+    role?: {
+        current_titles?: {
+            include?: (string | {
+                id?: string | number;
+                text?: string;
+            })[];
+            exclude?: (string | {
+                id?: string | number;
+                text?: string;
+            })[];
+        };
+        past_titles?: {
+            include?: (string | {
+                id?: string | number;
+                text?: string;
+            })[];
+            exclude?: (string | {
+                id?: string | number;
+                text?: string;
+            })[];
+        };
+        functions?: {
+            include?: string[];
+            exclude?: string[];
+        };
+        seniority_ids?: number[];
+    };
+    personal?: {
+        geography?: {
+            include?: Geo[];
+            exclude?: Geo[];
+        };
+        industry_ids?: {
+            include?: number[];
+            exclude?: number[];
+        };
+        profile_language?: {
+            include?: string[];
+        };
+        years_in_current_role?: {
+            min?: number;
+            max?: number;
+        };
+        years_at_company?: {
+            min?: number;
+            max?: number;
+        };
+        years_experience?: {
+            min?: number;
+            max?: number;
+        };
+        years_in_current_role_ids?: number[];
+        years_at_company_ids?: number[];
+        years_experience_ids?: number[];
+    };
+    spotlights?: {
+        recent_job_change_days?: number;
+        posted_in_last_days?: number;
+    };
+    workflow?: {
+        account_lists?: {
+            include: string[];
+            exclude?: string[];
+        };
+        saved_only?: boolean;
+    };
+    boolean?: {
+        title?: string;
+        company?: string;
+        keywords?: string;
+    };
+};

package/dist/utils/errors.d.ts

@@ -19,4 +19,8 @@ export declare const ERROR_CODES: {
     readonly REQUEST_FAILED: "REQUEST_FAILED";
     readonly ALL_ACCOUNTS_FAILED: "ALL_ACCOUNTS_FAILED";
     readonly PARSE_ERROR: "PARSE_ERROR";
+    readonly INVALID_INPUT: "INVALID_INPUT";
+    readonly NOT_FOUND: "NOT_FOUND";
+    readonly AUTH_ERROR: "AUTH_ERROR";
+    readonly RATE_LIMITED: "RATE_LIMITED";
 };

package/dist/utils/errors.js

@@ -31,4 +31,9 @@ exports.ERROR_CODES = {
     REQUEST_FAILED: 'REQUEST_FAILED',
     ALL_ACCOUNTS_FAILED: 'ALL_ACCOUNTS_FAILED',
     PARSE_ERROR: 'PARSE_ERROR',
+    // Added to satisfy merged specification
+    INVALID_INPUT: 'INVALID_INPUT',
+    NOT_FOUND: 'NOT_FOUND',
+    AUTH_ERROR: 'AUTH_ERROR',
+    RATE_LIMITED: 'RATE_LIMITED',
 };

package/dist/utils/linkedin-config.d.ts

@@ -0,0 +1,43 @@
+export declare const linkedinApiUrl: "https://www.linkedin.com/voyager/api/";
+export declare const linkedinSalesNavigatorUrl: "https://www.linkedin.com/sales-api";
+export declare const authUrl: "https://www.linkedin.com/uas/authenticate";
+export declare const defaultUserAgent: "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/140.0.0.0 Safari/537.36";
+export declare const defaultAcceptNormalized: "application/vnd.linkedin.normalized+json+2.1";
+export declare const defaultAccept: "*/*";
+export declare const defaultAcceptLanguage: "en-US,en;q=0.9,en-GB;q=0.8";
+export declare const defaultLiLang: "en_US";
+export declare const defaultOrigin: "https://www.linkedin.com";
+export type LinkedInTrackPayload = {
+    clientVersion: string;
+    mpVersion: string;
+    osName: string;
+    timezoneOffset: number;
+    timezone: string;
+    deviceFormFactor: "DESKTOP" | "MOBILE" | string;
+    mpName: string;
+    displayDensity?: number;
+    displayWidth?: number;
+    displayHeight?: number;
+};
+export declare const voyagerTrackPayload: LinkedInTrackPayload;
+export declare const salesTrackPayload: LinkedInTrackPayload;
+export type VoyagerHeaderOptions = {
+    cookiesHeader: string;
+    csrf: string;
+    referer?: string;
+    accept?: string;
+    acceptLanguage?: string;
+    userAgent?: string;
+    trackPayload?: LinkedInTrackPayload;
+};
+export declare function buildVoyagerHeaders(opts: VoyagerHeaderOptions): Record<string, string>;
+export type SalesHeaderOptions = {
+    cookiesHeader: string;
+    csrf: string;
+    referer?: string;
+    acceptLanguage?: string;
+    userAgent?: string;
+    trackPayload?: LinkedInTrackPayload;
+    pageInstanceName?: string;
+};
+export declare function buildSalesHeaders(opts: SalesHeaderOptions): Record<string, string>;

package/dist/utils/linkedin-config.js

@@ -0,0 +1,77 @@
+"use strict";
+// Centralized LinkedIn endpoints and header builders
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.salesTrackPayload = exports.voyagerTrackPayload = exports.defaultOrigin = exports.defaultLiLang = exports.defaultAcceptLanguage = exports.defaultAccept = exports.defaultAcceptNormalized = exports.defaultUserAgent = exports.authUrl = exports.linkedinSalesNavigatorUrl = exports.linkedinApiUrl = void 0;
+exports.buildVoyagerHeaders = buildVoyagerHeaders;
+exports.buildSalesHeaders = buildSalesHeaders;
+exports.linkedinApiUrl = "https://www.linkedin.com/voyager/api/";
+exports.linkedinSalesNavigatorUrl = "https://www.linkedin.com/sales-api";
+exports.authUrl = "https://www.linkedin.com/uas/authenticate";
+exports.defaultUserAgent = "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/140.0.0.0 Safari/537.36";
+exports.defaultAcceptNormalized = "application/vnd.linkedin.normalized+json+2.1";
+exports.defaultAccept = "*/*";
+exports.defaultAcceptLanguage = "en-US,en;q=0.9,en-GB;q=0.8";
+exports.defaultLiLang = "en_US";
+exports.defaultOrigin = "https://www.linkedin.com";
+// Voyager (regular profile API) tracking payload
+exports.voyagerTrackPayload = Object.freeze({
+    clientVersion: "1.13.39643",
+    mpVersion: "1.13.39643",
+    osName: "web",
+    timezoneOffset: 1,
+    timezone: "Europe/Paris",
+    deviceFormFactor: "DESKTOP",
+    mpName: "voyager-web", // Different from Sales Nav
+    displayDensity: 1,
+    displayWidth: 1920,
+    displayHeight: 1080,
+});
+// Sales Navigator tracking payload
+exports.salesTrackPayload = Object.freeze({
+    clientVersion: "2.0.5594",
+    mpVersion: "2.0.5594",
+    osName: "web",
+    timezoneOffset: 1,
+    timezone: "Europe/Paris",
+    deviceFormFactor: "DESKTOP",
+    mpName: "lighthouse-web", // Sales-specific
+    displayDensity: 1,
+    displayWidth: 1920,
+    displayHeight: 1080,
+});
+function buildVoyagerHeaders(opts) {
+    const { cookiesHeader, csrf, referer, accept = exports.defaultAcceptNormalized, acceptLanguage = exports.defaultAcceptLanguage, userAgent = exports.defaultUserAgent, trackPayload = exports.voyagerTrackPayload, } = opts;
+    return {
+        Cookie: cookiesHeader,
+        "User-Agent": userAgent,
+        accept,
+        "accept-language": acceptLanguage,
+        "x-restli-protocol-version": "2.0.0",
+        "csrf-token": csrf,
+        "x-li-lang": exports.defaultLiLang,
+        "x-li-track": JSON.stringify(trackPayload),
+        "sec-fetch-site": "same-origin",
+        "sec-fetch-mode": "cors",
+        referer: referer ?? exports.defaultOrigin + "/",
+        origin: exports.defaultOrigin,
+    };
+}
+function buildSalesHeaders(opts) {
+    const { cookiesHeader, csrf, referer, acceptLanguage = exports.defaultAcceptLanguage, userAgent = exports.defaultUserAgent, trackPayload = exports.salesTrackPayload, pageInstanceName = "d_sales2_search_people", } = opts;
+    const pageInstance = `urn:li:page:${pageInstanceName};${Buffer.from(String(Date.now())).toString("base64")}`;
+    return {
+        Cookie: cookiesHeader,
+        "User-Agent": userAgent,
+        accept: exports.defaultAccept,
+        "accept-language": acceptLanguage,
+        "x-restli-protocol-version": "2.0.0",
+        "csrf-token": csrf,
+        "x-li-lang": exports.defaultLiLang,
+        "x-li-track": JSON.stringify(trackPayload),
+        "x-li-page-instance": pageInstance,
+        "sec-fetch-site": "same-origin",
+        "sec-fetch-mode": "cors",
+        referer: referer ?? "https://www.linkedin.com/sales/search/people",
+        origin: exports.defaultOrigin,
+    };
+}

package/dist/utils/logger.d.ts

@@ -1,2 +1,2 @@
 export type LogLevel = 'debug' | 'info' | 'warn' | 'error';
-export declare function log(level: LogLevel, message: string, data?: any): void;
+export declare function log(level: LogLevel, message: string, data?: unknown): void;

package/dist/utils/metrics.d.ts

@@ -5,13 +5,21 @@ export interface Metrics {
     inflightDedupeHits: number;
     searchCacheHits: number;
     searchCacheMisses: number;
+    typeaheadCacheHits: number;
+    companyCacheHits: number;
     accountSelections: number;
     authErrors: number;
     httpRetries: number;
     httpSuccess: number;
+    httpFailures: number;
     cosiallFetches: number;
     cosiallSuccess: number;
     cosiallFailures: number;
+    companyFetches: number;
+    typeaheadRequests: number;
 }
 export declare function incrementMetric(key: keyof Metrics, by?: number): void;
-export declare function getSnapshot(): Metrics;
+export interface MetricsSnapshot extends Metrics {
+    requestHistorySize: number;
+}
+export declare function getSnapshot(): MetricsSnapshot;

package/dist/utils/metrics.js

@@ -2,6 +2,7 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.incrementMetric = incrementMetric;
 exports.getSnapshot = getSnapshot;
+const request_history_1 = require("./request-history");
 const metrics = {
     profileFetches: 0,
     profileCacheHits: 0,
@@ -9,18 +10,31 @@ const metrics = {
     inflightDedupeHits: 0,
     searchCacheHits: 0,
     searchCacheMisses: 0,
+    typeaheadCacheHits: 0,
+    companyCacheHits: 0,
     accountSelections: 0,
     authErrors: 0,
     httpRetries: 0,
     httpSuccess: 0,
+    httpFailures: 0,
     cosiallFetches: 0,
     cosiallSuccess: 0,
     cosiallFailures: 0,
+    companyFetches: 0,
+    typeaheadRequests: 0,
 };
 function incrementMetric(key, by = 1) {
-    // @ts-ignore - index signature not declared, but keys are enforced by type
     metrics[key] = (metrics[key] || 0) + by;
 }
 function getSnapshot() {
-    return { ...metrics };
+    // Augment with dynamic fields derived from other modules
+    const requestHistorySize = (() => {
+        try {
+            return (0, request_history_1.getRequestHistory)().length;
+        }
+        catch {
+            return 0;
+        }
+    })();
+    return { ...metrics, requestHistorySize };
 }

package/dist/utils/request-history.d.ts

@@ -0,0 +1,12 @@
+export interface RequestHistoryEntry {
+    timestamp: number;
+    operation: string;
+    selector: string;
+    status: number;
+    durationMs: number;
+    accountId?: string;
+    errorMessage?: string;
+}
+export declare function recordRequest(entry: Omit<RequestHistoryEntry, 'timestamp'>): void;
+export declare function getRequestHistory(): RequestHistoryEntry[];
+export declare function clearRequestHistory(): void;

package/dist/utils/request-history.js

@@ -0,0 +1,45 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.recordRequest = recordRequest;
+exports.getRequestHistory = getRequestHistory;
+exports.clearRequestHistory = clearRequestHistory;
+const config_1 = require("../config");
+let buffer = [];
+function capacity() {
+    try {
+        const cap = (0, config_1.getConfig)().maxRequestHistory ?? 500;
+        return Math.max(1, cap | 0);
+    }
+    catch {
+        return 500;
+    }
+}
+function redact(s) {
+    if (!s)
+        return s;
+    return s.replace(/li_at=([^;]+)/gi, 'li_at=[REDACTED]')
+        .replace(/JSESSIONID=([^;]+)/gi, 'JSESSIONID=[REDACTED]')
+        .replace(/csrf[^=&]*=([^&]+)/gi, 'csrf=[REDACTED]');
+}
+function recordRequest(entry) {
+    const safe = {
+        timestamp: Date.now(),
+        operation: String(entry.operation || ''),
+        selector: redact(String(entry.selector || '')),
+        status: Number(entry.status || 0),
+        durationMs: Math.max(0, Number(entry.durationMs || 0)),
+        accountId: entry.accountId,
+        errorMessage: entry.errorMessage ? redact(String(entry.errorMessage)) : undefined,
+    };
+    buffer.push(safe);
+    const cap = capacity();
+    if (buffer.length > cap) {
+        buffer.splice(0, buffer.length - cap);
+    }
+}
+function getRequestHistory() {
+    return buffer.slice();
+}
+function clearRequestHistory() {
+    buffer = [];
+}

package/dist/utils/search-encoder.d.ts

@@ -0,0 +1,4 @@
+import type { SalesSearchFilters } from '../types';
+export declare function stableStringify(obj: unknown): string;
+export declare function buildFilterSignature(filters?: SalesSearchFilters, rawQuery?: string): string | undefined;
+export declare function buildLeadSearchQuery(keywords: string, filters?: SalesSearchFilters): string;

package/dist/utils/search-encoder.js

@@ -0,0 +1,164 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.stableStringify = stableStringify;
+exports.buildFilterSignature = buildFilterSignature;
+exports.buildLeadSearchQuery = buildLeadSearchQuery;
+// Stable stringify for cache keys: sorts object keys recursively.
+function stableStringify(obj) {
+    if (obj === null || typeof obj !== 'object')
+        return JSON.stringify(obj);
+    if (Array.isArray(obj))
+        return '[' + obj.map((v) => stableStringify(v)).join(',') + ']';
+    const rec = obj;
+    const keys = Object.keys(rec).sort();
+    return '{' + keys.map((k) => JSON.stringify(k) + ':' + stableStringify(rec[k])).join(',') + '}';
+}
+function buildFilterSignature(filters, rawQuery) {
+    if (rawQuery)
+        return 'rq:' + String(rawQuery).trim();
+    if (!filters)
+        return undefined;
+    return 'f:' + stableStringify(filters);
+}
+// Temporary minimal encoder: today we include only keywords in the query structure to
+// preserve existing behavior. Once facet ids are confirmed, extend this to encode filters
+// into the Sales Navigator query payload.
+function encText(s) {
+    if (s === undefined || s === null)
+        return undefined;
+    return encodeURIComponent(String(s));
+}
+function list(values) {
+    return `List(${values.join(',')})`;
+}
+function valObj(parts) {
+    return `(${parts.join(',')})`;
+}
+function pushFilter(out, type, values) {
+    if (!values.length)
+        return;
+    out.push(valObj([`type:${type}`, `values:${list(values)}`]));
+}
+function buildLeadSearchQuery(keywords, filters) {
+    const kw = (filters?.boolean?.keywords ?? keywords ?? '').toString();
+    const encodedKw = kw.replace(/\s+/g, '%20');
+    const f = [];
+    // SENIORITY_LEVEL
+    if (filters?.role?.seniority_ids?.length) {
+        const values = filters.role.seniority_ids.map((id) => valObj([`id:${id}`, `selectionType:INCLUDED`]));
+        pushFilter(f, 'SENIORITY_LEVEL', values);
+    }
+    // CURRENT_TITLE / PAST_TITLE (supports id or text)
+    function encodeTitles(arr) {
+        if (!arr || !arr.length)
+            return [];
+        return arr.map((t) => {
+            if (typeof t === 'object') {
+                const parts = [];
+                if (t.id != null)
+                    parts.push(`id:${t.id}`);
+                if (t.text)
+                    parts.push(`text:${encText(t.text)}`);
+                parts.push('selectionType:INCLUDED');
+                return valObj(parts);
+            }
+            else {
+                // Heuristic: allow numeric strings to be treated as ids, otherwise text
+                const isNumeric = /^\d+$/.test(t);
+                const parts = [isNumeric ? `id:${t}` : `text:${encText(t)}`, 'selectionType:INCLUDED'];
+                return valObj(parts);
+            }
+        });
+    }
+    const curTitles = encodeTitles(filters?.role?.current_titles?.include);
+    if (curTitles.length)
+        pushFilter(f, 'CURRENT_TITLE', curTitles);
+    const pastTitles = encodeTitles(filters?.role?.past_titles?.include);
+    if (pastTitles.length)
+        pushFilter(f, 'PAST_TITLE', pastTitles);
+    // FUNCTION (ids as strings)
+    if (filters?.role?.functions?.include?.length) {
+        const values = filters.role.functions.include.map((id) => valObj([`id:${id}`, 'selectionType:INCLUDED']));
+        pushFilter(f, 'FUNCTION', values);
+    }
+    // INDUSTRY (numeric ids)
+    if (filters?.personal?.industry_ids?.include?.length) {
+        const values = filters.personal.industry_ids.include.map((id) => valObj([`id:${id}`, 'selectionType:INCLUDED']));
+        pushFilter(f, 'INDUSTRY', values);
+    }
+    // PROFILE_LANGUAGE (ids like en, ar)
+    if (filters?.personal?.profile_language?.include?.length) {
+        const values = filters.personal.profile_language.include.map((id) => valObj([`id:${id}`, 'selectionType:INCLUDED']));
+        pushFilter(f, 'PROFILE_LANGUAGE', values);
+    }
+    // REGION (BING_GEO) — require id present
+    if (filters?.personal?.geography?.include?.length) {
+        const values = (filters.personal.geography.include || [])
+            .filter((g) => g.id)
+            .map((g) => valObj([`id:${g.id}`, `text:${encText(g.value)}`, 'selectionType:INCLUDED']));
+        pushFilter(f, 'REGION', values);
+    }
+    // COMPANY_HEADCOUNT — map common labels to A..I; accept raw letters too
+    const HEADCOUNT_CODE = {
+        'Self-employed': 'A',
+        '1-10': 'B',
+        '11-50': 'C',
+        '51-200': 'D',
+        '201-500': 'E',
+        '501-1000': 'F',
+        '1001-5000': 'G',
+        '5001-10000': 'H',
+        '10000+': 'I',
+    };
+    if (filters?.company?.headcount?.include?.length) {
+        const values = filters.company.headcount.include.map((label) => {
+            const code = HEADCOUNT_CODE[label] ?? label; // allow passing A..I directly
+            return valObj([`id:${code}`, 'selectionType:INCLUDED']);
+        });
+        pushFilter(f, 'COMPANY_HEADCOUNT', values);
+    }
+    // CURRENT_COMPANY — accept org URN (urn:li:organization:ID), numeric ID, or text
+    if (filters?.company?.current?.include?.length) {
+        const values = filters.company.current.include.map((c) => {
+            const s = String(c);
+            const parts = [];
+            if (/^urn:li:organization:\d+$/i.test(s) || /^\d+$/.test(s)) {
+                parts.push(`id:${s}`);
+            }
+            else {
+                parts.push(`text:${encText(s)}`);
+            }
+            parts.push('selectionType:INCLUDED');
+            return valObj(parts);
+        });
+        pushFilter(f, 'CURRENT_COMPANY', values);
+    }
+    // COMPANY_TYPE — map to C,P,N,D,G when known; allow raw codes
+    const COMPANY_TYPE = {
+        PUBLIC: 'C',
+        PRIVATE: 'P',
+        NONPROFIT: 'N',
+        EDUCATIONAL: 'D',
+        GOVERNMENT: 'G',
+    };
+    if (filters?.company?.type?.include?.length) {
+        const values = filters.company.type.include.map((t) => {
+            const code = COMPANY_TYPE[t] ?? t; // allow raw letter code
+            return valObj([`id:${code}`, 'selectionType:INCLUDED']);
+        });
+        pushFilter(f, 'COMPANY_TYPE', values);
+    }
+    // YEARS_* via explicit bucket ids if provided (1..5)
+    const yr = filters?.personal;
+    if (yr?.years_at_company_ids?.length) {
+        pushFilter(f, 'YEARS_AT_CURRENT_COMPANY', yr.years_at_company_ids.map((id) => valObj([`id:${id}`, 'selectionType:INCLUDED'])));
+    }
+    if (yr?.years_in_current_role_ids?.length) {
+        pushFilter(f, 'YEARS_IN_CURRENT_POSITION', yr.years_in_current_role_ids.map((id) => valObj([`id:${id}`, 'selectionType:INCLUDED'])));
+    }
+    if (yr?.years_experience_ids?.length) {
+        pushFilter(f, 'YEARS_OF_EXPERIENCE', yr.years_experience_ids.map((id) => valObj([`id:${id}`, 'selectionType:INCLUDED'])));
+    }
+    const filtersPart = f.length ? `,filters:${list(f)}` : '';
+    return `(spellCorrectionEnabled:true,keywords:${encodedKw}${filtersPart})`;
+}