indiecrm-cli 0.1.0 → 0.2.1

package/dist/sales-navigator.js

@@ -0,0 +1,1231 @@
+export class SalesNavigatorSliceTooBroadError extends Error {
+    totalResults;
+    details;
+    constructor(message, options) {
+        super(message);
+        this.name = "SalesNavigatorSliceTooBroadError";
+        this.totalResults = options?.totalResults ?? null;
+        this.details = options?.details;
+    }
+}
+export class SalesNavigatorCrawlStopError extends Error {
+    totalResults;
+    details;
+    constructor(message, options) {
+        super(message);
+        this.name = "SalesNavigatorCrawlStopError";
+        this.totalResults = options?.totalResults ?? null;
+        this.details = options?.details;
+    }
+}
+export const DEFAULT_SALES_NAVIGATOR_PEOPLE_SLICE_FILTERS = [
+    {
+        type: "FUNCTION",
+        values: [
+            {
+                id: "12",
+                text: "Human Resources",
+                selectionType: "INCLUDED",
+            },
+        ],
+    },
+    {
+        type: "SENIORITY_LEVEL",
+        values: [
+            {
+                id: "220",
+                text: "Director",
+                selectionType: "INCLUDED",
+            },
+        ],
+    },
+    {
+        type: "YEARS_AT_CURRENT_COMPANY",
+        values: [
+            {
+                id: "3",
+                text: "3 to 5 years",
+                selectionType: "INCLUDED",
+            },
+        ],
+    },
+    {
+        type: "YEARS_IN_CURRENT_POSITION",
+        values: [
+            {
+                id: "3",
+                text: "3 to 5 years",
+                selectionType: "INCLUDED",
+            },
+        ],
+    },
+    {
+        type: "COMPANY_HEADCOUNT",
+        values: [
+            {
+                id: "D",
+                text: "51-200",
+                selectionType: "INCLUDED",
+            },
+        ],
+    },
+    {
+        type: "COMPANY_TYPE",
+        values: [
+            {
+                id: "P",
+                text: "Privately Held",
+                selectionType: "INCLUDED",
+            },
+        ],
+    },
+    {
+        type: "YEARS_OF_EXPERIENCE",
+        values: [
+            {
+                id: "5",
+                text: "More than 10 years",
+                selectionType: "INCLUDED",
+            },
+        ],
+    },
+];
+const LINKEDIN_SALES_NAVIGATOR_PEOPLE_SEARCH_URL = "https://www.linkedin.com/sales/search/people";
+const LINKEDIN_SALES_NAVIGATOR_ACCOUNT_SEARCH_URL = "https://www.linkedin.com/sales/search/company";
+export const SALES_NAVIGATOR_PEOPLE_MAX_RESULTS = 2_500;
+export const SALES_NAVIGATOR_CONNECTIONS_OF_MAX_RESULTS = 1_000;
+export const SALES_NAVIGATOR_ACCOUNT_MAX_RESULTS = 1_000;
+function decodeSalesNavigatorQueryValue(value) {
+    let decoded = value;
+    for (let attempt = 0; attempt < 3; attempt += 1) {
+        try {
+            const next = decodeURIComponent(decoded);
+            if (next === decoded)
+                break;
+            decoded = next;
+        }
+        catch {
+            break;
+        }
+    }
+    return decoded;
+}
+function getSalesNavigatorQueryValue(sourceQueryUrl) {
+    const url = new URL(sourceQueryUrl);
+    const queryFromSearch = url.searchParams.get("query");
+    const queryFromHash = url.hash.startsWith("#query=")
+        ? new URLSearchParams(url.hash.slice(1)).get("query")
+        : null;
+    return decodeSalesNavigatorQueryValue(queryFromSearch ?? queryFromHash ?? "");
+}
+export function isSalesNavigatorConnectionsOfSearch(sourceQueryUrl) {
+    const queryValue = getSalesNavigatorQueryValue(sourceQueryUrl);
+    return /(?:type\s*:\s*)?(?:CONNECTIONS?_OF|CONNECTION_OF|TEAMLINK_CONNECTION_OF)\b/i.test(queryValue) || /\bconnections?\s+of\b/i.test(queryValue);
+}
+export function getSalesNavigatorPeopleAccessibleResultLimit(sourceQueryUrl) {
+    return isSalesNavigatorConnectionsOfSearch(sourceQueryUrl)
+        ? SALES_NAVIGATOR_CONNECTIONS_OF_MAX_RESULTS
+        : SALES_NAVIGATOR_PEOPLE_MAX_RESULTS;
+}
+export function salesNavigatorPeopleSearchHasFilter(sourceQueryUrl, filterType) {
+    const escapedFilterType = filterType.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+    return new RegExp(`\\btype\\s*:\\s*${escapedFilterType}\\b`, "i").test(getSalesNavigatorQueryValue(sourceQueryUrl));
+}
+export const DEFAULT_SALES_NAVIGATOR_CRAWL_BASELINE_FILTERS = [
+    {
+        type: "FUNCTION",
+        values: [
+            {
+                id: "12",
+                text: "Human Resources",
+                selectionType: "INCLUDED",
+            },
+        ],
+    },
+];
+const SALES_NAVIGATOR_FUNCTION_HINTS = [
+    {
+        name: "Human Resources",
+        filterValue: { id: "12", text: "Human Resources", selectionType: "INCLUDED" },
+        patterns: [/(^|[^a-z])(human resources|hr\b|people\b|recruit|talent acquisition|talent management)/i],
+    },
+    {
+        name: "Finance",
+        filterValue: { text: "Finance", selectionType: "INCLUDED" },
+        patterns: [/(^|[^a-z])(finance|accounting|accounts payable|accounts receivable|controller|payroll)/i],
+    },
+    {
+        name: "Information Technology",
+        filterValue: { text: "Information Technology", selectionType: "INCLUDED" },
+        patterns: [/(^|[^a-z])(information technology|devops|infrastructure|security|help desk|service desk)([^a-z]|$)/i],
+    },
+    {
+        name: "Engineering",
+        filterValue: { text: "Engineering", selectionType: "INCLUDED" },
+        patterns: [/(^|[^a-z])(engineering|developer|platform engineer|technical lead|cto\b)([^a-z]|$)/i],
+    },
+    {
+        name: "Sales",
+        filterValue: { text: "Sales", selectionType: "INCLUDED" },
+        patterns: [/(^|[^a-z])(sales|revenue|account executive|business development|sales enablement)/i],
+    },
+    {
+        name: "Marketing",
+        filterValue: { text: "Marketing", selectionType: "INCLUDED" },
+        patterns: [/(^|[^a-z])(marketing|demand generation|growth|brand|campaign)/i],
+    },
+    {
+        name: "Operations",
+        filterValue: { text: "Operations", selectionType: "INCLUDED" },
+        patterns: [/(^|[^a-z])(operations|ops\b|supply chain|procurement|vendor management)/i],
+    },
+    {
+        name: "Legal",
+        filterValue: { text: "Legal", selectionType: "INCLUDED" },
+        patterns: [/(^|[^a-z])(legal|compliance|general counsel|privacy)/i],
+    },
+    {
+        name: "Support",
+        filterValue: { text: "Support", selectionType: "INCLUDED" },
+        patterns: [/(^|[^a-z])(support|customer service|customer success|help center)/i],
+    },
+];
+export const DEFAULT_SALES_NAVIGATOR_CRAWL_DIMENSIONS = [
+    {
+        key: "company-headcount",
+        filterType: "COMPANY_HEADCOUNT",
+        values: [
+            { id: "D", text: "51-200", selectionType: "INCLUDED" },
+            { id: "C", text: "11-50", selectionType: "INCLUDED" },
+            { id: "E", text: "201-500", selectionType: "INCLUDED" },
+            { id: "B", text: "1-10", selectionType: "INCLUDED" },
+            { id: "F", text: "501-1000", selectionType: "INCLUDED" },
+            { id: "G", text: "1001-5000", selectionType: "INCLUDED" },
+            { id: "H", text: "5001-10,000", selectionType: "INCLUDED" },
+            { id: "I", text: "10,000+", selectionType: "INCLUDED" },
+        ],
+    },
+    {
+        key: "company-type",
+        filterType: "COMPANY_TYPE",
+        values: [
+            { id: "P", text: "Privately Held", selectionType: "INCLUDED" },
+            { id: "C", text: "Public Company", selectionType: "INCLUDED" },
+            { text: "Partnership", selectionType: "INCLUDED" },
+            { text: "Self Owned", selectionType: "INCLUDED" },
+            { text: "Non Profit", selectionType: "INCLUDED" },
+            { text: "Educational Institution", selectionType: "INCLUDED" },
+            { text: "Government Agency", selectionType: "INCLUDED" },
+        ],
+    },
+    {
+        key: "seniority-level",
+        filterType: "SENIORITY_LEVEL",
+        values: [
+            { id: "320", text: "Owner / Partner", selectionType: "INCLUDED" },
+            { id: "310", text: "CXO", selectionType: "INCLUDED" },
+            { id: "300", text: "Vice President", selectionType: "INCLUDED" },
+            { id: "220", text: "Director", selectionType: "INCLUDED" },
+            { id: "210", text: "Experienced Manager", selectionType: "INCLUDED" },
+            { id: "120", text: "Senior", selectionType: "INCLUDED" },
+            { id: "110", text: "Entry Level", selectionType: "INCLUDED" },
+        ],
+    },
+    {
+        key: "years-at-company",
+        filterType: "YEARS_AT_CURRENT_COMPANY",
+        values: [
+            { id: "1", text: "Less than 1 year", selectionType: "INCLUDED" },
+            { id: "2", text: "1 to 2 years", selectionType: "INCLUDED" },
+            { id: "3", text: "3 to 5 years", selectionType: "INCLUDED" },
+            { id: "4", text: "6 to 10 years", selectionType: "INCLUDED" },
+            { id: "5", text: "More than 10 years", selectionType: "INCLUDED" },
+        ],
+    },
+    {
+        key: "years-in-position",
+        filterType: "YEARS_IN_CURRENT_POSITION",
+        values: [
+            { id: "1", text: "Less than 1 year", selectionType: "INCLUDED" },
+            { id: "2", text: "1 to 2 years", selectionType: "INCLUDED" },
+            { id: "3", text: "3 to 5 years", selectionType: "INCLUDED" },
+            { id: "4", text: "6 to 10 years", selectionType: "INCLUDED" },
+            { id: "5", text: "More than 10 years", selectionType: "INCLUDED" },
+        ],
+    },
+    {
+        key: "years-of-experience",
+        filterType: "YEARS_OF_EXPERIENCE",
+        values: [
+            { id: "1", text: "Less than 1 year", selectionType: "INCLUDED" },
+            { id: "2", text: "1 to 2 years", selectionType: "INCLUDED" },
+            { id: "3", text: "3 to 5 years", selectionType: "INCLUDED" },
+            { id: "4", text: "6 to 10 years", selectionType: "INCLUDED" },
+            { id: "5", text: "More than 10 years", selectionType: "INCLUDED" },
+        ],
+    },
+];
+export const DEFAULT_SALES_NAVIGATOR_ACCOUNT_CRAWL_DIMENSIONS = [
+    {
+        key: "company-headcount",
+        filterType: "COMPANY_HEADCOUNT",
+        supportsResidualExclusion: true,
+        values: [
+            { id: "B", text: "1-10", selectionType: "INCLUDED" },
+            { id: "C", text: "11-50", selectionType: "INCLUDED" },
+            { id: "D", text: "51-200", selectionType: "INCLUDED" },
+            { id: "E", text: "201-500", selectionType: "INCLUDED" },
+            { id: "F", text: "501-1,000", selectionType: "INCLUDED" },
+            { id: "G", text: "1,001-5,000", selectionType: "INCLUDED" },
+            { id: "H", text: "5,001-10,000", selectionType: "INCLUDED" },
+            { id: "I", text: "10,001+", selectionType: "INCLUDED" },
+        ],
+    },
+    {
+        key: "number-of-followers",
+        filterType: "NUM_OF_FOLLOWERS",
+        supportsResidualExclusion: true,
+        values: [
+            { id: "NFR1", text: "1-50", selectionType: "INCLUDED" },
+            { id: "NFR2", text: "51-100", selectionType: "INCLUDED" },
+            { id: "NFR3", text: "101-1000", selectionType: "INCLUDED" },
+            { id: "NFR4", text: "1001-5000", selectionType: "INCLUDED" },
+            { id: "NFR5", text: "5001+", selectionType: "INCLUDED" },
+        ],
+    },
+    {
+        key: "annual-revenue",
+        filterType: "ANNUAL_REVENUE",
+        supportsResidualExclusion: false,
+        combinableValues: false,
+        values: [
+            { text: "USD 0-0.5M", rangeValue: { min: 0, max: 0.5 }, selectedSubFilter: "USD" },
+            { text: "USD 0.5-1M", rangeValue: { min: 0.5, max: 1 }, selectedSubFilter: "USD" },
+            { text: "USD 1-2.5M", rangeValue: { min: 1, max: 2.5 }, selectedSubFilter: "USD" },
+            { text: "USD 2.5-5M", rangeValue: { min: 2.5, max: 5 }, selectedSubFilter: "USD" },
+            { text: "USD 5-10M", rangeValue: { min: 5, max: 10 }, selectedSubFilter: "USD" },
+            { text: "USD 10-20M", rangeValue: { min: 10, max: 20 }, selectedSubFilter: "USD" },
+            { text: "USD 20-50M", rangeValue: { min: 20, max: 50 }, selectedSubFilter: "USD" },
+            { text: "USD 50-100M", rangeValue: { min: 50, max: 100 }, selectedSubFilter: "USD" },
+            { text: "USD 100-500M", rangeValue: { min: 100, max: 500 }, selectedSubFilter: "USD" },
+            { text: "USD 500M-1B", rangeValue: { min: 500, max: 1000 }, selectedSubFilter: "USD" },
+            { text: "USD 1B+", rangeValue: { min: 1000, max: 1001 }, selectedSubFilter: "USD" },
+        ],
+    },
+];
+function ensureLinkedInSalesPeopleSearchUrl(url) {
+    if (!/(^|\.)linkedin\.com$/i.test(url.hostname)) {
+        throw new Error("Expected a linkedin.com Sales Navigator URL.");
+    }
+    if (!/^\/sales\/search\/people/i.test(url.pathname)) {
+        throw new Error("Expected a LinkedIn Sales Navigator people search URL.");
+    }
+    if (!url.searchParams.has("query")) {
+        throw new Error("Sales Navigator URL is missing the query parameter.");
+    }
+}
+function ensureLinkedInSalesAccountSearchUrl(url) {
+    if (!/(^|\.)linkedin\.com$/i.test(url.hostname)) {
+        throw new Error("Expected a linkedin.com Sales Navigator URL.");
+    }
+    if (!/^\/sales\/search\/company/i.test(url.pathname)) {
+        throw new Error("Expected a LinkedIn Sales Navigator account search URL.");
+    }
+    if (!url.searchParams.has("query")) {
+        throw new Error("Sales Navigator URL is missing the query parameter.");
+    }
+}
+function ensureLinkedInSalesSearchUrl(url, searchType) {
+    if (searchType === "account") {
+        ensureLinkedInSalesAccountSearchUrl(url);
+        return;
+    }
+    ensureLinkedInSalesPeopleSearchUrl(url);
+}
+function splitTopLevelCommaSeparated(value) {
+    const parts = [];
+    let depth = 0;
+    let start = 0;
+    for (let index = 0; index < value.length; index += 1) {
+        const char = value[index];
+        if (char === "(") {
+            depth += 1;
+            continue;
+        }
+        if (char === ")") {
+            depth = Math.max(0, depth - 1);
+            continue;
+        }
+        if (char === "," && depth === 0) {
+            const part = value.slice(start, index).trim();
+            if (part.length > 0) {
+                parts.push(part);
+            }
+            start = index + 1;
+        }
+    }
+    const tail = value.slice(start).trim();
+    if (tail.length > 0) {
+        parts.push(tail);
+    }
+    return parts;
+}
+function findFiltersListBounds(queryValue) {
+    const marker = "filters:List(";
+    const markerIndex = queryValue.indexOf(marker);
+    if (markerIndex === -1) {
+        throw new Error("Sales Navigator query is missing filters:List(...).");
+    }
+    let depth = 1;
+    let endIndex = -1;
+    for (let index = markerIndex + marker.length; index < queryValue.length; index += 1) {
+        const char = queryValue[index];
+        if (char === "(") {
+            depth += 1;
+        }
+        else if (char === ")") {
+            depth -= 1;
+            if (depth === 0) {
+                endIndex = index;
+                break;
+            }
+        }
+    }
+    if (endIndex === -1) {
+        throw new Error("Could not parse filters list from Sales Navigator query.");
+    }
+    return {
+        before: queryValue.slice(0, markerIndex),
+        filtersContent: queryValue.slice(markerIndex + marker.length, endIndex),
+        after: queryValue.slice(endIndex + 1),
+    };
+}
+function extractFilterType(block) {
+    const match = block.match(/^\(type:([A-Z_]+)/);
+    return match?.[1] ?? null;
+}
+function buildFilterBlock(filter) {
+    const rangeValues = filter.values.filter((value) => value.rangeValue);
+    if (rangeValues.length > 0) {
+        if (rangeValues.length !== 1 || filter.values.length !== 1) {
+            throw new Error(`Sales Navigator range filter ${filter.type} requires exactly one range.`);
+        }
+        const value = rangeValues[0];
+        const range = value.rangeValue;
+        const selectedSubFilter = value.selectedSubFilter?.trim();
+        return (`(type:${filter.type},rangeValue:(min:${range.min},max:${range.max})` +
+            `${selectedSubFilter ? `,selectedSubFilter:${encodeURIComponent(selectedSubFilter)}` : ""})`);
+    }
+    const encodedValues = filter.values
+        .map((value) => {
+        const selectionType = value.selectionType ?? "INCLUDED";
+        const segments = [];
+        if (typeof value.id === "string" && value.id.trim().length > 0) {
+            segments.push(`id:${value.id}`);
+        }
+        // Parentheses are Rest.li delimiters but encodeURIComponent leaves them raw.
+        segments.push(`text:${encodeURIComponent(value.text).replace(/[!'()*]/g, char => `%${char.charCodeAt(0).toString(16).toUpperCase()}`)}`);
+        segments.push(`selectionType:${selectionType}`);
+        return `(${segments.join(",")})`;
+    })
+        .join(",");
+    return `(type:${filter.type},values:List(${encodedValues}))`;
+}
+function dedupeSalesNavigatorFilters(filters) {
+    const seen = new Set();
+    const deduped = [];
+    for (const filter of filters) {
+        const values = filter.values.filter((value) => {
+            const key = [
+                filter.type,
+                value.selectionType ?? "INCLUDED",
+                value.text.trim().toLowerCase(),
+                value.id?.trim().toLowerCase() ?? "",
+                value.rangeValue?.min ?? "",
+                value.rangeValue?.max ?? "",
+                value.selectedSubFilter?.trim().toLowerCase() ?? "",
+            ].join("|");
+            if (seen.has(key)) {
+                return false;
+            }
+            seen.add(key);
+            return true;
+        });
+        if (values.length > 0) {
+            deduped.push({
+                type: filter.type,
+                values,
+            });
+        }
+    }
+    return deduped;
+}
+export function applySalesNavigatorFiltersToQueryValue(queryValue, filters) {
+    const { before, filtersContent, after } = findFiltersListBounds(queryValue);
+    const existingBlocks = splitTopLevelCommaSeparated(filtersContent);
+    const replacements = new Map(filters.map((filter) => [filter.type, filter]));
+    const consumedTypes = new Set();
+    const nextBlocks = existingBlocks.map((block) => {
+        const type = extractFilterType(block);
+        if (!type) {
+            return block;
+        }
+        const replacement = replacements.get(type);
+        if (!replacement) {
+            return block;
+        }
+        consumedTypes.add(type);
+        return buildFilterBlock(replacement);
+    });
+    for (const filter of filters) {
+        if (!consumedTypes.has(filter.type)) {
+            nextBlocks.push(buildFilterBlock(filter));
+        }
+    }
+    return `${before}filters:List(${nextBlocks.join(",")})${after}`;
+}
+function canonicalizeSalesNavigatorQueryValue(queryValue) {
+    const { filtersContent } = findFiltersListBounds(queryValue);
+    return `(filters:List(${filtersContent}))`;
+}
+function canonicalizeSalesNavigatorSearchUrl(sourceQueryUrl, searchType = "people") {
+    const url = new URL(sourceQueryUrl);
+    ensureLinkedInSalesSearchUrl(url, searchType);
+    const queryValue = url.searchParams.get("query");
+    if (!queryValue) {
+        throw new Error("Sales Navigator URL is missing the query parameter.");
+    }
+    const canonicalUrl = new URL(searchType === "account"
+        ? LINKEDIN_SALES_NAVIGATOR_ACCOUNT_SEARCH_URL
+        : LINKEDIN_SALES_NAVIGATOR_PEOPLE_SEARCH_URL);
+    canonicalUrl.searchParams.set("query", canonicalizeSalesNavigatorQueryValue(queryValue));
+    return canonicalUrl;
+}
+export function buildSalesNavigatorPeopleQuery(sourceQueryUrl, filters) {
+    const url = canonicalizeSalesNavigatorSearchUrl(sourceQueryUrl, "people");
+    const queryValue = url.searchParams.get("query");
+    if (!queryValue) {
+        throw new Error("Sales Navigator URL is missing the query parameter.");
+    }
+    const appliedFilters = dedupeSalesNavigatorFilters(filters);
+    const slicedQueryValue = applySalesNavigatorFiltersToQueryValue(queryValue, appliedFilters);
+    url.searchParams.set("query", slicedQueryValue);
+    return {
+        sourceQueryUrl: canonicalizeSalesNavigatorSearchUrl(sourceQueryUrl, "people").toString(),
+        slicedQueryUrl: url.toString(),
+        appliedFilters,
+    };
+}
+export function buildSalesNavigatorAccountQuery(sourceQueryUrl, filters) {
+    const url = canonicalizeSalesNavigatorSearchUrl(sourceQueryUrl, "account");
+    const queryValue = url.searchParams.get("query");
+    if (!queryValue) {
+        throw new Error("Sales Navigator URL is missing the query parameter.");
+    }
+    const appliedFilters = dedupeSalesNavigatorFilters(filters);
+    const slicedQueryValue = applySalesNavigatorFiltersToQueryValue(queryValue, appliedFilters);
+    url.searchParams.set("query", slicedQueryValue);
+    return {
+        sourceQueryUrl: canonicalizeSalesNavigatorSearchUrl(sourceQueryUrl, "account").toString(),
+        slicedQueryUrl: url.toString(),
+        appliedFilters,
+    };
+}
+export function buildSalesNavigatorPeopleSearchUrl(filters) {
+    const appliedFilters = dedupeSalesNavigatorFilters(filters);
+    if (appliedFilters.length === 0) {
+        throw new Error("Sales Navigator people search requires at least one filter.");
+    }
+    const url = new URL(LINKEDIN_SALES_NAVIGATOR_PEOPLE_SEARCH_URL);
+    url.searchParams.set("query", `(filters:List(${appliedFilters.map((filter) => buildFilterBlock(filter)).join(",")}))`);
+    return url.toString();
+}
+export function buildSalesNavigatorAccountSearchUrl(filters) {
+    const appliedFilters = dedupeSalesNavigatorFilters(filters);
+    if (appliedFilters.length === 0) {
+        throw new Error("Sales Navigator account search requires at least one filter.");
+    }
+    const url = new URL(LINKEDIN_SALES_NAVIGATOR_ACCOUNT_SEARCH_URL);
+    url.searchParams.set("query", `(filters:List(${appliedFilters.map((filter) => buildFilterBlock(filter)).join(",")}))`);
+    return url.toString();
+}
+function inferSalesNavigatorFunctionFilters(options) {
+    const titleHaystack = options.title.trim();
+    const categoryHaystack = [options.categoryName, options.categorySlug]
+        .filter((value) => typeof value === "string" && value.trim().length > 0)
+        .join(" ");
+    for (const hint of SALES_NAVIGATOR_FUNCTION_HINTS) {
+        if (titleHaystack.length > 0 && hint.patterns.some((pattern) => pattern.test(titleHaystack))) {
+            return [
+                {
+                    type: "FUNCTION",
+                    values: [hint.filterValue]
+                }
+            ];
+        }
+    }
+    for (const hint of SALES_NAVIGATOR_FUNCTION_HINTS) {
+        if (categoryHaystack.length > 0 && hint.patterns.some((pattern) => pattern.test(categoryHaystack))) {
+            return [
+                {
+                    type: "FUNCTION",
+                    values: [hint.filterValue]
+                }
+            ];
+        }
+    }
+    return [];
+}
+function normalizeSalesNavigatorTitle(title) {
+    return title
+        .replace(/[“”"']+/g, "")
+        .replace(/\s*[|/]+\s*/g, " / ")
+        .replace(/\s*&\s*/g, " & ")
+        .replace(/[–—]+/g, "-")
+        .replace(/\s+/g, " ")
+        .replace(/^[\s\-:;,]+|[\s\-:;,]+$/g, "")
+        .trim();
+}
+function canonicalizeSalesNavigatorTitleKey(title) {
+    return normalizeSalesNavigatorTitle(title)
+        .toLowerCase()
+        .replace(/&/g, " and ")
+        .replace(/[^a-z0-9]+/g, " ")
+        .replace(/\s+/g, " ")
+        .trim();
+}
+export function deriveSalesNavigatorTitleQuerySeeds(options) {
+    const rankedTitles = new Map();
+    let firstSeenIndex = 0;
+    for (const item of options.items) {
+        const sourceProduct = options.sourceProductUrl === item.productUrl;
+        for (const intendedRole of item.intendedRoles) {
+            const title = normalizeSalesNavigatorTitle(intendedRole);
+            if (title.length === 0) {
+                continue;
+            }
+            const normalizedTitle = canonicalizeSalesNavigatorTitleKey(title);
+            const existing = rankedTitles.get(normalizedTitle);
+            if (existing) {
+                existing.matchedProductCount += 1;
+                existing.sourceProduct = existing.sourceProduct || sourceProduct;
+                continue;
+            }
+            rankedTitles.set(normalizedTitle, {
+                title,
+                matchedProductCount: 1,
+                sourceProduct,
+                firstSeenIndex,
+                categoryName: item.category?.name,
+                categorySlug: item.category?.slug
+            });
+            firstSeenIndex += 1;
+        }
+    }
+    const orderedTitles = [...rankedTitles.values()].sort((left, right) => {
+        if (left.sourceProduct !== right.sourceProduct) {
+            return left.sourceProduct ? -1 : 1;
+        }
+        if (left.sourceProduct && right.sourceProduct && left.firstSeenIndex !== right.firstSeenIndex) {
+            return left.firstSeenIndex - right.firstSeenIndex;
+        }
+        if (left.matchedProductCount !== right.matchedProductCount) {
+            return right.matchedProductCount - left.matchedProductCount;
+        }
+        if (left.firstSeenIndex !== right.firstSeenIndex) {
+            return left.firstSeenIndex - right.firstSeenIndex;
+        }
+        return left.title.localeCompare(right.title);
+    });
+    const limitedTitles = options.titleLimit && options.titleLimit > 0
+        ? orderedTitles.slice(0, options.titleLimit)
+        : orderedTitles;
+    return limitedTitles.map((entry) => {
+        const appliedFilters = dedupeSalesNavigatorFilters([
+            {
+                type: "CURRENT_TITLE",
+                values: [{ text: entry.title, selectionType: "INCLUDED" }]
+            },
+            ...inferSalesNavigatorFunctionFilters({
+                title: entry.title,
+                categoryName: entry.categoryName,
+                categorySlug: entry.categorySlug
+            })
+        ]);
+        return {
+            title: entry.title,
+            queryUrl: buildSalesNavigatorPeopleSearchUrl(appliedFilters),
+            appliedFilters,
+            matchedProductCount: entry.matchedProductCount,
+            sourceProduct: entry.sourceProduct
+        };
+    });
+}
+export function buildSalesNavigatorPeopleSlice(sourceQueryUrl, filters = DEFAULT_SALES_NAVIGATOR_PEOPLE_SLICE_FILTERS) {
+    return buildSalesNavigatorPeopleQuery(sourceQueryUrl, filters);
+}
+export function buildSalesNavigatorAccountSlice(sourceQueryUrl, filters = []) {
+    return buildSalesNavigatorAccountQuery(sourceQueryUrl, filters);
+}
+export function createSalesNavigatorCrawlSeed(options) {
+    const sliced = options.searchType === "account"
+        ? buildSalesNavigatorAccountQuery(options.sourceQueryUrl, options.baselineFilters ?? [])
+        : buildSalesNavigatorPeopleQuery(options.sourceQueryUrl, options.baselineFilters ?? []);
+    return {
+        ...sliced,
+        depth: 0,
+        retryCount: 0,
+        maxResultsPerSearch: options.maxResultsPerSearch,
+        numberOfProfiles: options.numberOfProfiles,
+        slicePreset: options.slicePreset,
+        splitTrail: [],
+    };
+}
+export function expandSalesNavigatorCrawlAttempt(attempt, dimension, searchType = "people") {
+    return dimension.values.map((value) => {
+        const filters = dedupeSalesNavigatorFilters([
+            ...attempt.appliedFilters.filter((filter) => filter.type !== dimension.filterType),
+            {
+                type: dimension.filterType,
+                values: [
+                    {
+                        ...value,
+                        selectionType: value.selectionType ?? "INCLUDED",
+                    },
+                ],
+            },
+        ]);
+        const sliced = searchType === "account"
+            ? buildSalesNavigatorAccountQuery(attempt.sourceQueryUrl, filters)
+            : buildSalesNavigatorPeopleQuery(attempt.sourceQueryUrl, filters);
+        return {
+            ...sliced,
+            depth: attempt.depth + 1,
+            retryCount: 0,
+            maxResultsPerSearch: attempt.maxResultsPerSearch,
+            numberOfProfiles: attempt.numberOfProfiles,
+            slicePreset: attempt.slicePreset,
+            splitTrail: [
+                ...attempt.splitTrail,
+                {
+                    key: dimension.key,
+                    filterType: dimension.filterType,
+                    value: {
+                        ...value,
+                        selectionType: value.selectionType ?? "INCLUDED",
+                    },
+                },
+            ],
+        };
+    });
+}
+export function buildSalesNavigatorResidualCrawlAttempt(attempt, dimension, searchType = "people") {
+    const residualValues = dimension.values.map((value) => ({
+        ...value,
+        selectionType: "EXCLUDED",
+    }));
+    const filters = dedupeSalesNavigatorFilters([
+        ...attempt.appliedFilters.filter((filter) => filter.type !== dimension.filterType),
+        {
+            type: dimension.filterType,
+            values: residualValues,
+        },
+    ]);
+    const sliced = searchType === "account"
+        ? buildSalesNavigatorAccountQuery(attempt.sourceQueryUrl, filters)
+        : buildSalesNavigatorPeopleQuery(attempt.sourceQueryUrl, filters);
+    return {
+        ...sliced,
+        depth: attempt.depth + 1,
+        retryCount: 0,
+        maxResultsPerSearch: attempt.maxResultsPerSearch,
+        numberOfProfiles: attempt.numberOfProfiles,
+        slicePreset: attempt.slicePreset,
+        splitTrail: [
+            ...attempt.splitTrail,
+            {
+                key: `${dimension.key}-residual`,
+                filterType: dimension.filterType,
+                value: {
+                    text: `Not in ${dimension.key}`,
+                    selectionType: "EXCLUDED",
+                },
+            },
+        ],
+    };
+}
+export function buildSalesNavigatorCrawlPreview(options) {
+    const root = createSalesNavigatorCrawlSeed(options);
+    const dimensions = options.dimensions ?? DEFAULT_SALES_NAVIGATOR_CRAWL_DIMENSIONS;
+    const firstSplit = dimensions[0]
+        ? expandSalesNavigatorCrawlAttempt(root, dimensions[0], options.searchType)
+        : [];
+    return { root, firstSplit, dimensions };
+}
+function salesNavigatorDimensionKeyFromTrailKey(key) {
+    return key.endsWith("-residual") ? key.slice(0, -"-residual".length) : key;
+}
+function getUnusedSalesNavigatorDimensions(attempt, dimensions) {
+    const usedKeys = new Set(attempt.splitTrail.map((entry) => salesNavigatorDimensionKeyFromTrailKey(entry.key)));
+    return dimensions.filter((dimension) => !usedKeys.has(dimension.key));
+}
+function buildSalesNavigatorAdaptiveChildren(attempt, dimension, options) {
+    const expandedChildren = expandSalesNavigatorCrawlAttempt(attempt, dimension, options.searchType);
+    const residualChildren = options.includeResidualExclusionSlices
+        && dimension.supportsResidualExclusion !== false
+        ? [
+            buildSalesNavigatorResidualCrawlAttempt(attempt, dimension, options.searchType),
+        ]
+        : [];
+    return [...expandedChildren, ...residualChildren];
+}
+function getSalesNavigatorAttemptDimensionValues(attempt, dimension) {
+    const trailEntry = attempt.splitTrail.at(-1);
+    if (trailEntry?.key !== dimension.key) {
+        return null;
+    }
+    const filter = attempt.appliedFilters.find((entry) => entry.type === dimension.filterType);
+    if (!filter || filter.values.length !== 1) {
+        return null;
+    }
+    if (filter.values.some((value) => (value.selectionType ?? "INCLUDED") !== "INCLUDED")) {
+        return null;
+    }
+    return filter.values;
+}
+function buildSalesNavigatorCombinedCrawlAttempt(attempt, dimension, children, searchType = "people") {
+    const values = children.flatMap((child) => getSalesNavigatorAttemptDimensionValues(child.attempt, dimension) ?? []);
+    const filters = dedupeSalesNavigatorFilters([
+        ...attempt.appliedFilters.filter((filter) => filter.type !== dimension.filterType),
+        {
+            type: dimension.filterType,
+            values: values.map((value) => ({
+                ...value,
+                selectionType: value.selectionType ?? "INCLUDED",
+            })),
+        },
+    ]);
+    const sliced = searchType === "account"
+        ? buildSalesNavigatorAccountQuery(attempt.sourceQueryUrl, filters)
+        : buildSalesNavigatorPeopleQuery(attempt.sourceQueryUrl, filters);
+    const valueText = values.map((value) => value.text).join(" + ");
+    return {
+        ...sliced,
+        depth: attempt.depth + 1,
+        retryCount: 0,
+        maxResultsPerSearch: attempt.maxResultsPerSearch,
+        numberOfProfiles: attempt.numberOfProfiles,
+        slicePreset: attempt.slicePreset,
+        splitTrail: [
+            ...attempt.splitTrail,
+            {
+                key: dimension.key,
+                filterType: dimension.filterType,
+                value: {
+                    text: valueText,
+                    selectionType: "INCLUDED",
+                },
+            },
+        ],
+    };
+}
+async function coalesceSalesNavigatorUnderCapChildren(options) {
+    if (options.dimension.combinableValues === false) {
+        return options.summaries;
+    }
+    const packable = [];
+    const fixed = [];
+    for (const summary of options.summaries) {
+        const values = getSalesNavigatorAttemptDimensionValues(summary.attempt, options.dimension);
+        if (!values ||
+            summary.totalResults == null ||
+            summary.totalResults > summary.attempt.maxResultsPerSearch) {
+            fixed.push(summary);
+            continue;
+        }
+        packable.push(summary);
+    }
+    if (packable.length <= 1) {
+        return options.summaries;
+    }
+    const bins = [];
+    const ordered = [...packable].sort((left, right) => (right.totalResults ?? 0) - (left.totalResults ?? 0));
+    for (const item of ordered) {
+        let placed = false;
+        for (const bin of bins) {
+            const combinedAttempt = buildSalesNavigatorCombinedCrawlAttempt(options.parentAttempt, options.dimension, [...bin.children, item], options.searchType);
+            const combinedSummary = await probeSalesNavigatorAdaptiveAttempt(combinedAttempt, options.probeSlice, options.probeCache);
+            if (combinedSummary.totalResults != null &&
+                combinedSummary.totalResults <= combinedAttempt.maxResultsPerSearch) {
+                bin.children.push(item);
+                bin.summary = {
+                    attempt: combinedAttempt,
+                    totalResults: combinedSummary.totalResults,
+                };
+                placed = true;
+                break;
+            }
+        }
+        if (!placed) {
+            bins.push({
+                children: [item],
+                summary: item,
+            });
+        }
+    }
+    return [
+        ...bins.map((bin) => bin.summary),
+        ...fixed,
+    ];
+}
+function summarizeSalesNavigatorAdaptiveSplitCandidate(summaries, maxResultsPerSearch, estimate) {
+    const knownTotals = summaries
+        .map((summary) => summary.totalResults)
+        .filter((total) => typeof total === "number");
+    const knownChildren = knownTotals.length;
+    const oversizedChildren = knownTotals.filter((total) => total > maxResultsPerSearch).length;
+    const largestChildTotal = knownTotals.length > 0 ? Math.max(...knownTotals) : null;
+    const underCapTotals = knownTotals.filter((total) => total <= maxResultsPerSearch);
+    const utilization = underCapTotals.length === 0
+        ? 0
+        : underCapTotals.reduce((sum, total) => sum + total / maxResultsPerSearch, 0) / underCapTotals.length;
+    const largestPenalty = largestChildTotal == null
+        ? maxResultsPerSearch * 2
+        : Math.max(0, largestChildTotal - maxResultsPerSearch) /
+            maxResultsPerSearch;
+    return {
+        knownChildren,
+        oversizedChildren,
+        largestChildTotal,
+        estimatedFinalBatches: estimate.estimatedFinalBatches,
+        unresolvedChildren: estimate.unresolvedChildren,
+        score: estimate.unresolvedChildren * 1_000_000 +
+            estimate.estimatedFinalBatches * 1_000 +
+            oversizedChildren * 100 +
+            largestPenalty * 10 -
+            utilization,
+    };
+}
+async function estimateSalesNavigatorMinimumFinalBatches(options) {
+    const remainingDimensions = getUnusedSalesNavigatorDimensions(options.attempt, options.dimensions);
+    if (remainingDimensions.length === 0 ||
+        options.attempt.depth >= options.maxSplitDepth) {
+        return {
+            estimatedFinalBatches: 1,
+            unresolvedChildren: 1,
+            largestChildTotal: null,
+        };
+    }
+    const candidateEstimates = [];
+    for (const dimension of remainingDimensions) {
+        const rawChildren = buildSalesNavigatorAdaptiveChildren(options.attempt, dimension, options);
+        const rawSummaries = [];
+        for (const child of rawChildren) {
+            rawSummaries.push({
+                attempt: child,
+                ...(await probeSalesNavigatorAdaptiveAttempt(child, options.probeSlice, options.probeCache)),
+            });
+        }
+        const summaries = await coalesceSalesNavigatorUnderCapChildren({
+            parentAttempt: options.attempt,
+            dimension,
+            summaries: rawSummaries,
+            searchType: options.searchType,
+            probeSlice: options.probeSlice,
+            probeCache: options.probeCache,
+        });
+        let estimatedFinalBatches = 0;
+        let unresolvedChildren = 0;
+        let largestChildTotal = null;
+        for (const summary of summaries) {
+            if (summary.totalResults != null) {
+                largestChildTotal =
+                    largestChildTotal == null
+                        ? summary.totalResults
+                        : Math.max(largestChildTotal, summary.totalResults);
+            }
+            if (summary.totalResults != null &&
+                summary.totalResults <= summary.attempt.maxResultsPerSearch) {
+                estimatedFinalBatches += 1;
+                continue;
+            }
+            const childEstimate = await estimateSalesNavigatorMinimumFinalBatches({
+                ...options,
+                attempt: summary.attempt,
+            });
+            estimatedFinalBatches += childEstimate.estimatedFinalBatches;
+            unresolvedChildren += childEstimate.unresolvedChildren;
+            if (childEstimate.largestChildTotal != null) {
+                largestChildTotal =
+                    largestChildTotal == null
+                        ? childEstimate.largestChildTotal
+                        : Math.max(largestChildTotal, childEstimate.largestChildTotal);
+            }
+        }
+        candidateEstimates.push({
+            estimatedFinalBatches,
+            unresolvedChildren,
+            largestChildTotal,
+        });
+    }
+    candidateEstimates.sort((left, right) => {
+        if (left.unresolvedChildren !== right.unresolvedChildren) {
+            return left.unresolvedChildren - right.unresolvedChildren;
+        }
+        if (left.estimatedFinalBatches !== right.estimatedFinalBatches) {
+            return left.estimatedFinalBatches - right.estimatedFinalBatches;
+        }
+        return dimensionsSortValue(right.largestChildTotal) -
+            dimensionsSortValue(left.largestChildTotal);
+    });
+    return candidateEstimates[0] ?? {
+        estimatedFinalBatches: 1,
+        unresolvedChildren: 1,
+        largestChildTotal: null,
+    };
+}
+async function probeSalesNavigatorAdaptiveAttempt(attempt, probeSlice, probeCache) {
+    let cached = probeCache.get(attempt.slicedQueryUrl);
+    if (!cached) {
+        cached = probeSlice(attempt);
+        probeCache.set(attempt.slicedQueryUrl, cached);
+    }
+    return await cached;
+}
+async function chooseSalesNavigatorAdaptiveSplitCandidate(options) {
+    const candidates = [];
+    const probeCache = new Map();
+    for (const dimension of options.dimensions) {
+        const children = buildSalesNavigatorAdaptiveChildren(options.attempt, dimension, options).filter((child) => !options.seenQueryUrls.has(child.slicedQueryUrl));
+        if (children.length === 0) {
+            continue;
+        }
+        const summaries = [];
+        for (const child of children) {
+            summaries.push({
+                attempt: child,
+                ...(await probeSalesNavigatorAdaptiveAttempt(child, options.probeSlice, probeCache)),
+            });
+        }
+        const coalescedSummaries = await coalesceSalesNavigatorUnderCapChildren({
+            parentAttempt: options.attempt,
+            dimension,
+            summaries,
+            searchType: options.searchType,
+            probeSlice: options.probeSlice,
+            probeCache,
+        });
+        const coalescedChildren = coalescedSummaries.map((summary) => summary.attempt);
+        let estimatedFinalBatches = 0;
+        let unresolvedChildren = 0;
+        let largestChildTotal = null;
+        for (const summary of coalescedSummaries) {
+            if (summary.totalResults != null) {
+                largestChildTotal =
+                    largestChildTotal == null
+                        ? summary.totalResults
+                        : Math.max(largestChildTotal, summary.totalResults);
+            }
+            if (summary.totalResults != null &&
+                summary.totalResults <= summary.attempt.maxResultsPerSearch) {
+                estimatedFinalBatches += 1;
+                continue;
+            }
+            const childEstimate = await estimateSalesNavigatorMinimumFinalBatches({
+                attempt: summary.attempt,
+                dimensions: options.dimensions,
+                maxSplitDepth: options.maxSplitDepth,
+                searchType: options.searchType,
+                includeResidualExclusionSlices: options.includeResidualExclusionSlices,
+                probeSlice: options.probeSlice,
+                probeCache,
+            });
+            estimatedFinalBatches += childEstimate.estimatedFinalBatches;
+            unresolvedChildren += childEstimate.unresolvedChildren;
+            if (childEstimate.largestChildTotal != null) {
+                largestChildTotal =
+                    largestChildTotal == null
+                        ? childEstimate.largestChildTotal
+                        : Math.max(largestChildTotal, childEstimate.largestChildTotal);
+            }
+        }
+        const score = summarizeSalesNavigatorAdaptiveSplitCandidate(coalescedSummaries, options.attempt.maxResultsPerSearch, {
+            estimatedFinalBatches,
+            unresolvedChildren,
+        });
+        const largestTotal = largestChildTotal == null
+            ? score.largestChildTotal
+            : score.largestChildTotal == null
+                ? largestChildTotal
+                : Math.max(largestChildTotal, score.largestChildTotal);
+        candidates.push({
+            dimension,
+            children: coalescedChildren,
+            summaries: coalescedSummaries,
+            ...score,
+            largestChildTotal: largestTotal,
+        });
+    }
+    candidates.sort((left, right) => {
+        if (left.score !== right.score) {
+            return left.score - right.score;
+        }
+        if (left.oversizedChildren !== right.oversizedChildren) {
+            return left.oversizedChildren - right.oversizedChildren;
+        }
+        return dimensionsSortValue(right.largestChildTotal) -
+            dimensionsSortValue(left.largestChildTotal);
+    });
+    return candidates[0] ?? null;
+}
+function dimensionsSortValue(value) {
+    return value ?? -1;
+}
+export async function executeSalesNavigatorAdaptiveCrawl(options) {
+    const dimensions = options.dimensions ?? DEFAULT_SALES_NAVIGATOR_CRAWL_DIMENSIONS;
+    const maxSplitDepth = Math.min(options.maxSplitDepth ?? dimensions.length, dimensions.length);
+    const maxSlices = options.maxSlices ?? 1000;
+    const maxRetries = options.maxRetries ?? 1;
+    const exported = [];
+    const splitEvents = [];
+    const failed = [];
+    const unresolved = [];
+    const queue = [
+        createSalesNavigatorCrawlSeed({
+            sourceQueryUrl: options.sourceQueryUrl,
+            baselineFilters: options.baselineFilters,
+            maxResultsPerSearch: options.maxResultsPerSearch,
+            numberOfProfiles: options.numberOfProfiles,
+            slicePreset: options.slicePreset,
+            searchType: options.searchType,
+        }),
+    ];
+    const seenQueryUrls = new Set(queue.map((attempt) => attempt.slicedQueryUrl));
+    let attempted = 0;
+    let truncated = false;
+    while (queue.length > 0) {
+        if (attempted >= maxSlices) {
+            truncated = true;
+            break;
+        }
+        const attempt = queue.shift();
+        if (!attempt) {
+            break;
+        }
+        attempted += 1;
+        try {
+            const result = await options.exportSlice(attempt);
+            exported.push({ attempt, result });
+        }
+        catch (error) {
+            if (error instanceof SalesNavigatorCrawlStopError) {
+                failed.push({
+                    attempt,
+                    error: error.message,
+                    totalResults: error.totalResults,
+                });
+                truncated = true;
+                break;
+            }
+            if (error instanceof SalesNavigatorSliceTooBroadError) {
+                const remainingDimensions = getUnusedSalesNavigatorDimensions(attempt, dimensions);
+                if (remainingDimensions.length === 0 || attempt.depth >= maxSplitDepth) {
+                    unresolved.push({
+                        attempt,
+                        error: error.message,
+                        totalResults: error.totalResults,
+                    });
+                    continue;
+                }
+                let nextDimension = remainingDimensions[0];
+                let children = [];
+                let probeSummary;
+                let strategy = "fixed-order";
+                if (options.adaptiveSplitProbing && options.probeSlice) {
+                    const candidate = await chooseSalesNavigatorAdaptiveSplitCandidate({
+                        attempt,
+                        dimensions: remainingDimensions,
+                        searchType: options.searchType,
+                        includeResidualExclusionSlices: options.includeResidualExclusionSlices,
+                        seenQueryUrls,
+                        maxSplitDepth,
+                        probeSlice: options.probeSlice,
+                    });
+                    if (candidate) {
+                        nextDimension = candidate.dimension;
+                        children = candidate.children;
+                        strategy = "adaptive-probe";
+                        probeSummary = [
+                            {
+                                dimension: candidate.dimension.key,
+                                childCount: candidate.children.length,
+                                knownChildren: candidate.knownChildren,
+                                oversizedChildren: candidate.oversizedChildren,
+                                largestChildTotal: candidate.largestChildTotal,
+                                estimatedFinalBatches: candidate.estimatedFinalBatches,
+                                unresolvedChildren: candidate.unresolvedChildren,
+                                score: candidate.score,
+                            },
+                        ];
+                    }
+                }
+                if (children.length === 0) {
+                    const expandedChildren = expandSalesNavigatorCrawlAttempt(attempt, nextDimension, options.searchType);
+                    const residualChildren = options.includeResidualExclusionSlices
+                        && nextDimension.supportsResidualExclusion !== false
+                        ? [
+                            buildSalesNavigatorResidualCrawlAttempt(attempt, nextDimension, options.searchType),
+                        ]
+                        : [];
+                    children = [...expandedChildren, ...residualChildren];
+                }
+                children = children.filter((child) => {
+                    if (seenQueryUrls.has(child.slicedQueryUrl)) {
+                        return false;
+                    }
+                    seenQueryUrls.add(child.slicedQueryUrl);
+                    return true;
+                });
+                if (children.length === 0) {
+                    unresolved.push({
+                        attempt,
+                        error: error.message,
+                        totalResults: error.totalResults,
+                    });
+                    continue;
+                }
+                splitEvents.push({
+                    attempt,
+                    totalResults: error.totalResults,
+                    nextDimension: nextDimension.key,
+                    childCount: children.length,
+                    strategy,
+                    probeSummary,
+                });
+                queue.push(...children);
+                continue;
+            }
+            const message = error instanceof Error ? error.message : String(error);
+            if (attempt.retryCount < maxRetries) {
+                queue.push({
+                    ...attempt,
+                    retryCount: attempt.retryCount + 1,
+                });
+                continue;
+            }
+            failed.push({
+                attempt,
+                error: message,
+            });
+        }
+    }
+    return {
+        exported,
+        splitEvents,
+        failed,
+        unresolved,
+        attempted,
+        truncated,
+        remainingQueue: queue.length,
+    };
+}