linkedin-secret-sauce 0.12.0 → 0.12.2

package/dist/linkedin-api.js

@@ -47,6 +47,8 @@ exports.getYearsAtCompanyOptions = getYearsAtCompanyOptions;
 exports.getYearsInPositionOptions = getYearsInPositionOptions;
 exports.getYearsOfExperienceOptions = getYearsOfExperienceOptions;
 exports.getSalesNavigatorProfileDetails = getSalesNavigatorProfileDetails;
+exports.getSalesNavigatorProfileFull = getSalesNavigatorProfileFull;
+exports.extractLinkedInHandle = extractLinkedInHandle;
 const config_1 = require("./config");
 const http_client_1 = require("./http-client");
 const profile_parser_1 = require("./parsers/profile-parser");
@@ -57,27 +59,23 @@ const metrics_1 = require("./utils/metrics");
 const logger_1 = require("./utils/logger");
 const errors_1 = require("./utils/errors");
 const constants_1 = require("./constants");
+const lru_cache_1 = require("./utils/lru-cache");
 const LINKEDIN_API_BASE = "https://www.linkedin.com/voyager/api";
 const SALES_NAV_BASE = "https://www.linkedin.com/sales-api";
-// In-memory caches (per-process)
-const profileCacheByVanity = new Map();
-const profileCacheByUrn = new Map();
-const searchCache = new Map();
-// New caches for Phase 2
-const companyCache = new Map();
-const typeaheadCache = new Map();
+// Cache size limits to prevent unbounded memory growth
+const PROFILE_CACHE_MAX_SIZE = 1000;
+const SEARCH_CACHE_MAX_SIZE = 500;
+const COMPANY_CACHE_MAX_SIZE = 500;
+const TYPEAHEAD_CACHE_MAX_SIZE = 200;
+// In-memory LRU caches (per-process) with size limits
+const profileCacheByVanity = new lru_cache_1.LRUCache(PROFILE_CACHE_MAX_SIZE);
+const profileCacheByUrn = new lru_cache_1.LRUCache(PROFILE_CACHE_MAX_SIZE);
+const searchCache = new lru_cache_1.LRUCache(SEARCH_CACHE_MAX_SIZE);
+// Caches for Phase 2
+const companyCache = new lru_cache_1.LRUCache(COMPANY_CACHE_MAX_SIZE);
+const typeaheadCache = new lru_cache_1.LRUCache(TYPEAHEAD_CACHE_MAX_SIZE);
 // In-flight dedupe for profiles by vanity
 const inflightByVanity = new Map();
-function getCached(map, key, ttl) {
-    const entry = map.get(key);
-    if (!entry)
-        return null;
-    if (ttl && ttl > 0 && Date.now() - entry.ts > ttl) {
-        map.delete(key);
-        return null;
-    }
-    return entry.data;
-}
 /**
  * Fetches a LinkedIn profile by vanity URL (public identifier).
  * Results are cached for the configured TTL (default: 15 minutes).
@@ -104,7 +102,7 @@ async function getProfileByVanity(vanity) {
     }
     catch { }
     // Cache
-    const cached = getCached(profileCacheByVanity, key, cfg.profileCacheTtl);
+    const cached = profileCacheByVanity.get(key, cfg.profileCacheTtl);
     if (cached) {
         (0, metrics_1.incrementMetric)("profileCacheHits");
         return cached;
@@ -151,7 +149,7 @@ async function getProfileByVanity(vanity) {
                 catch { }
                 throw new errors_1.LinkedInClientError("Failed to parse profile", errors_1.ERROR_CODES.PARSE_ERROR, 500);
             }
-            profileCacheByVanity.set(key, { data: prof, ts: Date.now() });
+            profileCacheByVanity.set(key, prof);
             (0, metrics_1.incrementMetric)("profileFetches");
             try {
                 (0, logger_1.log)("info", "api.ok", {
@@ -210,7 +208,7 @@ async function getProfileByUrn(fsdKey) {
         });
     }
     catch { }
-    const cachedUrn = getCached(profileCacheByUrn, cacheKey, cfg.profileCacheTtl);
+    const cachedUrn = profileCacheByUrn.get(cacheKey, cfg.profileCacheTtl);
     if (cachedUrn) {
         (0, metrics_1.incrementMetric)("profileCacheHits");
         return cachedUrn;
@@ -322,7 +320,7 @@ async function getProfileByUrn(fsdKey) {
         catch { }
         throw new errors_1.LinkedInClientError("Failed to parse profile", errors_1.ERROR_CODES.PARSE_ERROR, 500);
     }
-    profileCacheByUrn.set(cacheKey, { data: prof, ts: Date.now() });
+    profileCacheByUrn.set(cacheKey, prof);
     (0, metrics_1.incrementMetric)("profileFetches");
     try {
         (0, logger_1.log)("info", "api.ok", { operation: "getProfileByUrn", selector: cacheKey });
@@ -390,7 +388,7 @@ async function searchSalesLeads(keywords, options) {
         cacheKeyObj.sessionId = options.sessionId;
     }
     const cacheKey = JSON.stringify(cacheKeyObj);
-    const cached = getCached(searchCache, cacheKey, cfg.searchCacheTtl);
+    const cached = searchCache.get(cacheKey, cfg.searchCacheTtl);
     if (cached) {
         (0, metrics_1.incrementMetric)("searchCacheHits");
         return cached;
@@ -466,7 +464,7 @@ async function searchSalesLeads(keywords, options) {
             : undefined,
         _meta: { sessionId }, // Return sessionId to consumer
     };
-    searchCache.set(cacheKey, { data: result, ts: Date.now() });
+    searchCache.set(cacheKey, result);
     (0, metrics_1.incrementMetric)("searchCacheMisses");
     return result;
 }
@@ -564,7 +562,7 @@ async function resolveCompanyUniversalName(universalName) {
 async function getCompanyById(companyId) {
     const cfg = (0, config_1.getConfig)();
     const key = String(companyId || "").trim();
-    const cached = getCached(companyCache, key, cfg.companyCacheTtl);
+    const cached = companyCache.get(key, cfg.companyCacheTtl);
     if (cached) {
         (0, metrics_1.incrementMetric)("companyCacheHits");
         return cached;
@@ -578,7 +576,7 @@ async function getCompanyById(companyId) {
         const raw = await (0, http_client_1.executeLinkedInRequest)({ url }, "getCompanyById");
         const parsed = (0, company_parser_1.parseCompany)(raw);
         (0, metrics_1.incrementMetric)("companyFetches");
-        companyCache.set(key, { data: parsed, ts: Date.now() });
+        companyCache.set(key, parsed);
         try {
             (0, logger_1.log)("info", "api.ok", { operation: "getCompanyById", selector: key });
         }
@@ -717,7 +715,7 @@ async function typeahead(options) {
     }
     // Make API call to LinkedIn for search queries or unsupported types
     const cacheKey = JSON.stringify({ type, query, start, count });
-    const cached = getCached(typeaheadCache, cacheKey, cfg.typeaheadCacheTtl);
+    const cached = typeaheadCache.get(cacheKey, cfg.typeaheadCacheTtl);
     if (cached) {
         (0, metrics_1.incrementMetric)("typeaheadCacheHits");
         return cached;
@@ -764,7 +762,7 @@ async function typeahead(options) {
             total: paging2?.total,
         },
     };
-    typeaheadCache.set(cacheKey, { data: result, ts: Date.now() });
+    typeaheadCache.set(cacheKey, result);
     try {
         (0, logger_1.log)("info", "api.ok", {
             operation: "typeahead",
@@ -920,3 +918,138 @@ async function getSalesNavigatorProfileDetails(profileUrnOrId) {
         throw e;
     }
 }
+/**
+ * Fetches full Sales Navigator profile data including flagshipProfileUrl (LinkedIn handle).
+ * This is a more complete version that returns all available profile data.
+ *
+ * The key use case is extracting the LinkedIn handle from flagshipProfileUrl
+ * for use with email finder services like Hunter.io.
+ *
+ * @param profileUrnOrId - Profile identifier in any of these formats:
+ *   - Sales profile URN: "urn:li:fs_salesProfile:(ABC123xyz,NAME_SEARCH,abc)"
+ *   - FSD profile URN: "urn:li:fsd_profile:ABC123xyz"
+ *   - Bare key: "ABC123xyz"
+ * @returns Full Sales Navigator profile with flagshipProfileUrl, contactInfo, positions, etc.
+ * @throws LinkedInClientError with code NOT_FOUND if profile doesn't exist
+ *
+ * @example
+ * ```typescript
+ * const profile = await getSalesNavigatorProfileFull('urn:li:fs_salesProfile:(ABC123,NAME_SEARCH,xyz)');
+ * console.log(profile.flagshipProfileUrl); // "https://www.linkedin.com/in/john-doe"
+ *
+ * // Extract LinkedIn handle for Hunter.io
+ * const handle = extractLinkedInHandle(profile.flagshipProfileUrl);
+ * console.log(handle); // "john-doe"
+ * ```
+ */
+async function getSalesNavigatorProfileFull(profileUrnOrId) {
+    const idOrUrn = String(profileUrnOrId || "").trim();
+    // Build Sales API path supporting URN triple or explicit profileId/authType/authToken
+    let pathSeg = "";
+    let pidFromTriple = null;
+    // URN with triple
+    const mUrn = idOrUrn.match(/^urn:li:(?:fs_salesProfile|fsd_profile):\(([^,\s)]+),([^,\s)]+),([^,\s)]+)\)/i);
+    if (mUrn) {
+        const [_, pid, authType, authToken] = mUrn;
+        pathSeg = `(profileId:${pid},authType:${authType},authToken:${authToken})`;
+        pidFromTriple = pid;
+    }
+    else if (/profileId:/.test(idOrUrn) &&
+        /authType:/.test(idOrUrn) &&
+        /authToken:/.test(idOrUrn)) {
+        // Already the triple form without urn prefix
+        pathSeg = `(${idOrUrn.replace(/^\(|\)$/g, "")})`;
+        const m = idOrUrn.match(/profileId:([^,\s)]+)/);
+        pidFromTriple = m ? m[1] : null;
+    }
+    else {
+        // Fallback to simple id/urn
+        pathSeg = idOrUrn.startsWith("urn:")
+            ? idOrUrn
+            : encodeURIComponent(idOrUrn);
+    }
+    // Decoration 2: Returns flagshipProfileUrl, contactInfo, summary, positions
+    // This is the key decoration for email enrichment - flagshipProfileUrl contains the LinkedIn handle
+    const decoration = encodeURIComponent("(entityUrn,objectUrn,firstName,lastName,fullName,headline,pronoun,degree,profileUnlockInfo,location,listCount,summary,savedLead,defaultPosition,contactInfo,crmStatus,pendingInvitation,unlocked,flagshipProfileUrl,positions*(companyName,current,new,description,endedOn,posId,startedOn,title,location,companyUrn~fs_salesCompany(entityUrn,name,companyPictureDisplayImage)))");
+    const base = `${SALES_NAV_BASE}/salesApiProfiles/`;
+    async function requestWith(seg) {
+        const url = `${base}${seg}?decoration=${decoration}`;
+        return (0, http_client_1.executeLinkedInRequest)({
+            url,
+            headers: { Referer: "https://www.linkedin.com/sales/search/people" },
+        }, "getSalesNavigatorProfileFull");
+    }
+    try {
+        try {
+            (0, logger_1.log)("info", "api.start", {
+                operation: "getSalesNavigatorProfileFull",
+                selector: idOrUrn,
+            });
+        }
+        catch { }
+        let raw;
+        try {
+            raw = await requestWith(pathSeg);
+        }
+        catch (e) {
+            const status = e?.status ?? 0;
+            if (status === 400 && pidFromTriple) {
+                // Fallback: some environments reject the triple form; retry with bare id
+                const fallbackSeg = encodeURIComponent(pidFromTriple);
+                try {
+                    (0, logger_1.log)("warn", "api.salesProfileFullFallback", {
+                        from: pathSeg,
+                        to: fallbackSeg,
+                    });
+                }
+                catch { }
+                raw = await requestWith(fallbackSeg);
+            }
+            else if (status === 404) {
+                try {
+                    (0, logger_1.log)("warn", "api.notFound", {
+                        operation: "getSalesNavigatorProfileFull",
+                        selector: idOrUrn,
+                        status,
+                    });
+                }
+                catch { }
+                throw new errors_1.LinkedInClientError("Sales profile not found", errors_1.ERROR_CODES.NOT_FOUND, 404);
+            }
+            else {
+                throw e;
+            }
+        }
+        try {
+            (0, logger_1.log)("info", "api.ok", {
+                operation: "getSalesNavigatorProfileFull",
+                selector: idOrUrn,
+                hasHandle: !!raw.flagshipProfileUrl,
+            });
+        }
+        catch { }
+        return raw;
+    }
+    catch (e) {
+        throw e;
+    }
+}
+/**
+ * Extracts LinkedIn handle/vanity from a flagship profile URL.
+ *
+ * @param flagshipProfileUrl - Full LinkedIn profile URL (e.g., "https://www.linkedin.com/in/john-doe")
+ * @returns LinkedIn handle/vanity (e.g., "john-doe") or null if not found
+ *
+ * @example
+ * ```typescript
+ * extractLinkedInHandle("https://www.linkedin.com/in/john-doe"); // "john-doe"
+ * extractLinkedInHandle("https://www.linkedin.com/in/georgi-metodiev-tech2rec"); // "georgi-metodiev-tech2rec"
+ * extractLinkedInHandle(null); // null
+ * ```
+ */
+function extractLinkedInHandle(flagshipProfileUrl) {
+    if (!flagshipProfileUrl)
+        return null;
+    const match = flagshipProfileUrl.match(/linkedin\.com\/in\/([^\/\?]+)/i);
+    return match ? match[1] : null;
+}

package/dist/types.d.ts

@@ -5,7 +5,7 @@
 export interface CosiallProfileEmailsResponse {
     /** Cosiall internal profile ID */
     profileId: number;
-    /** LinkedIn ObjectURN identifier (e.g., "urn:li:fsd_profile:ACoAABcdEfG") */
+    /** LinkedIn ObjectURN identifier (e.g., "urn:li:member:129147375") */
     objectUrn: string;
     /** LinkedIn profile URL */
     linkedInUrl: string;
@@ -233,6 +233,55 @@ export interface SalesNavigatorProfile {
     imageUrl?: string;
     flagshipProfileUrl?: string;
 }
+export interface SalesNavigatorPosition {
+    companyName?: string;
+    companyUrn?: string;
+    title?: string;
+    description?: string;
+    current?: boolean;
+    new?: boolean;
+    location?: string;
+    posId?: number;
+    startedOn?: {
+        year?: number;
+        month?: number;
+    };
+    endedOn?: {
+        year?: number;
+        month?: number;
+    };
+}
+export interface SalesNavigatorContactInfo {
+    emailAddresses?: string[];
+    phoneNumbers?: string[];
+    twitterHandles?: string[];
+    websites?: string[];
+}
+export interface SalesNavigatorProfileFull {
+    entityUrn?: string;
+    objectUrn?: string;
+    firstName?: string;
+    lastName?: string;
+    fullName?: string;
+    headline?: string;
+    summary?: string;
+    location?: string;
+    degree?: number;
+    pronoun?: string;
+    /** LinkedIn public profile URL - contains the vanity/handle (e.g., "https://www.linkedin.com/in/john-doe") */
+    flagshipProfileUrl?: string;
+    /** Contact info (emails, phones) - only available if connected */
+    contactInfo?: SalesNavigatorContactInfo;
+    /** Current and past positions */
+    positions?: SalesNavigatorPosition[];
+    defaultPosition?: SalesNavigatorPosition;
+    profileUnlockInfo?: unknown;
+    listCount?: number;
+    savedLead?: boolean;
+    crmStatus?: unknown;
+    pendingInvitation?: boolean;
+    unlocked?: boolean;
+}
 export type Geo = {
     type: "region" | "country" | "state" | "city" | "postal";
     value: string;

package/dist/utils/lru-cache.d.ts

@@ -0,0 +1,105 @@
+/**
+ * Simple LRU (Least Recently Used) Cache
+ *
+ * A memory-bounded cache that evicts the least recently used entries
+ * when the maximum size is exceeded. Prevents unbounded memory growth.
+ *
+ * Features:
+ * - O(1) get and set operations
+ * - Automatic eviction of stale entries
+ * - Optional TTL support
+ * - Size limit enforcement
+ */
+/**
+ * Cache entry with data and timestamp
+ */
+export interface CacheEntry<T> {
+    data: T;
+    ts: number;
+}
+/**
+ * LRU Cache implementation using Map's insertion order
+ *
+ * JavaScript Map maintains insertion order, so we can implement LRU
+ * by deleting and re-inserting on access (moving to end).
+ */
+export declare class LRUCache<T> {
+    private cache;
+    private readonly maxSize;
+    private readonly ttlMs;
+    /**
+     * Create a new LRU cache
+     *
+     * @param maxSize - Maximum number of entries to store (default: 1000)
+     * @param ttlMs - Optional TTL in milliseconds (default: null = no expiry)
+     */
+    constructor(maxSize?: number, ttlMs?: number | null);
+    /**
+     * Get a value from the cache
+     *
+     * @param key - Cache key
+     * @param ttlOverride - Optional TTL override in milliseconds (for dynamic TTL from config)
+     * @returns The cached value or null if not found/expired
+     */
+    get(key: string, ttlOverride?: number): T | null;
+    /**
+     * Set a value in the cache
+     *
+     * @param key - Cache key
+     * @param data - Value to cache
+     */
+    set(key: string, data: T): void;
+    /**
+     * Delete a key from the cache
+     *
+     * @param key - Cache key to delete
+     * @returns true if the key existed
+     */
+    delete(key: string): boolean;
+    /**
+     * Check if a key exists in the cache (without updating access time)
+     *
+     * @param key - Cache key
+     * @returns true if key exists and is not expired
+     */
+    has(key: string): boolean;
+    /**
+     * Clear all entries from the cache
+     */
+    clear(): void;
+    /**
+     * Get the current number of entries in the cache
+     */
+    get size(): number;
+    /**
+     * Get all keys in the cache (for debugging/testing)
+     */
+    keys(): IterableIterator<string>;
+    /**
+     * Prune expired entries (useful for periodic cleanup)
+     *
+     * @returns Number of entries removed
+     */
+    prune(): number;
+    /**
+     * Get cache statistics
+     */
+    stats(): {
+        size: number;
+        maxSize: number;
+        ttlMs: number | null;
+    };
+}
+/**
+ * Create a new LRU cache with the specified options
+ *
+ * @example
+ * ```typescript
+ * // Cache up to 500 profiles for 15 minutes
+ * const profileCache = createLRUCache<LinkedInProfile>(500, 15 * 60 * 1000);
+ *
+ * profileCache.set('johndoe', profile);
+ * const cached = profileCache.get('johndoe');
+ * ```
+ */
+export declare function createLRUCache<T>(maxSize?: number, ttlMs?: number | null): LRUCache<T>;

package/dist/utils/lru-cache.js

@@ -0,0 +1,175 @@
+"use strict";
+/**
+ * Simple LRU (Least Recently Used) Cache
+ *
+ * A memory-bounded cache that evicts the least recently used entries
+ * when the maximum size is exceeded. Prevents unbounded memory growth.
+ *
+ * Features:
+ * - O(1) get and set operations
+ * - Automatic eviction of stale entries
+ * - Optional TTL support
+ * - Size limit enforcement
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.LRUCache = void 0;
+exports.createLRUCache = createLRUCache;
+/**
+ * LRU Cache implementation using Map's insertion order
+ *
+ * JavaScript Map maintains insertion order, so we can implement LRU
+ * by deleting and re-inserting on access (moving to end).
+ */
+class LRUCache {
+    cache;
+    maxSize;
+    ttlMs;
+    /**
+     * Create a new LRU cache
+     *
+     * @param maxSize - Maximum number of entries to store (default: 1000)
+     * @param ttlMs - Optional TTL in milliseconds (default: null = no expiry)
+     */
+    constructor(maxSize = 1000, ttlMs = null) {
+        this.cache = new Map();
+        this.maxSize = maxSize;
+        this.ttlMs = ttlMs;
+    }
+    /**
+     * Get a value from the cache
+     *
+     * @param key - Cache key
+     * @param ttlOverride - Optional TTL override in milliseconds (for dynamic TTL from config)
+     * @returns The cached value or null if not found/expired
+     */
+    get(key, ttlOverride) {
+        const entry = this.cache.get(key);
+        if (!entry) {
+            return null;
+        }
+        // Check TTL expiration (use override if provided, otherwise instance TTL)
+        const effectiveTtl = ttlOverride ?? this.ttlMs;
+        if (effectiveTtl !== null && Date.now() - entry.ts > effectiveTtl) {
+            this.cache.delete(key);
+            return null;
+        }
+        // Move to end (most recently used) by delete + set
+        this.cache.delete(key);
+        this.cache.set(key, entry);
+        return entry.data;
+    }
+    /**
+     * Set a value in the cache
+     *
+     * @param key - Cache key
+     * @param data - Value to cache
+     */
+    set(key, data) {
+        // If key exists, delete it first (will be re-added at end)
+        if (this.cache.has(key)) {
+            this.cache.delete(key);
+        }
+        // Evict oldest entries if at capacity
+        while (this.cache.size >= this.maxSize) {
+            const oldestKey = this.cache.keys().next().value;
+            if (oldestKey !== undefined) {
+                this.cache.delete(oldestKey);
+            }
+            else {
+                break;
+            }
+        }
+        // Add new entry
+        this.cache.set(key, { data, ts: Date.now() });
+    }
+    /**
+     * Delete a key from the cache
+     *
+     * @param key - Cache key to delete
+     * @returns true if the key existed
+     */
+    delete(key) {
+        return this.cache.delete(key);
+    }
+    /**
+     * Check if a key exists in the cache (without updating access time)
+     *
+     * @param key - Cache key
+     * @returns true if key exists and is not expired
+     */
+    has(key) {
+        const entry = this.cache.get(key);
+        if (!entry) {
+            return false;
+        }
+        // Check TTL expiration
+        if (this.ttlMs !== null && Date.now() - entry.ts > this.ttlMs) {
+            this.cache.delete(key);
+            return false;
+        }
+        return true;
+    }
+    /**
+     * Clear all entries from the cache
+     */
+    clear() {
+        this.cache.clear();
+    }
+    /**
+     * Get the current number of entries in the cache
+     */
+    get size() {
+        return this.cache.size;
+    }
+    /**
+     * Get all keys in the cache (for debugging/testing)
+     */
+    keys() {
+        return this.cache.keys();
+    }
+    /**
+     * Prune expired entries (useful for periodic cleanup)
+     *
+     * @returns Number of entries removed
+     */
+    prune() {
+        if (this.ttlMs === null) {
+            return 0;
+        }
+        const now = Date.now();
+        let removed = 0;
+        for (const [key, entry] of this.cache) {
+            if (now - entry.ts > this.ttlMs) {
+                this.cache.delete(key);
+                removed++;
+            }
+        }
+        return removed;
+    }
+    /**
+     * Get cache statistics
+     */
+    stats() {
+        return {
+            size: this.cache.size,
+            maxSize: this.maxSize,
+            ttlMs: this.ttlMs,
+        };
+    }
+}
+exports.LRUCache = LRUCache;
+/**
+ * Create a new LRU cache with the specified options
+ *
+ * @example
+ * ```typescript
+ * // Cache up to 500 profiles for 15 minutes
+ * const profileCache = createLRUCache<LinkedInProfile>(500, 15 * 60 * 1000);
+ *
+ * profileCache.set('johndoe', profile);
+ * const cached = profileCache.get('johndoe');
+ * ```
+ */
+function createLRUCache(maxSize = 1000, ttlMs = null) {
+    return new LRUCache(maxSize, ttlMs);
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "linkedin-secret-sauce",
-  "version": "0.12.0",
+  "version": "0.12.2",
   "description": "Private LinkedIn Sales Navigator client with automatic cookie management",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",
@@ -10,30 +10,6 @@
   "publishConfig": {
     "registry": "https://registry.npmjs.org/"
   },
-  "scripts": {
-    "dev:playground": "pnpm -C apps/playground dev",
-    "search": "node scripts/rg-fast.mjs",
-    "rg:fast": "node scripts/rg-fast.mjs",
-    "build": "tsc -p tsconfig.json",
-    "typecheck": "tsc --noEmit",
-    "typecheck:playground": "pnpm -C apps/playground typecheck",
-    "typecheck:all": "pnpm typecheck && pnpm typecheck:playground",
-    "lint": "eslint \"src/**/*.ts\" --max-warnings=0",
-    "lint:playground": "eslint \"apps/playground/src/**/*.{ts,tsx}\" \"apps/playground/server/**/*.ts\" --max-warnings=0",
-    "lint:all": "eslint \"src/**/*.ts\" \"apps/playground/src/**/*.{ts,tsx}\" \"apps/playground/server/**/*.ts\" --max-warnings=0",
-    "lint:fix": "eslint \"src/**/*.ts\" \"apps/playground/src/**/*.{ts,tsx}\" \"apps/playground/server/**/*.ts\" --fix",
-    "check": "pnpm typecheck:all && pnpm lint:all",
-    "dev": "pnpm dev:playground",
-    "dev:watch": "tsc -w -p tsconfig.json",
-    "test": "vitest run",
-    "docs": "typedoc",
-    "docs:netlify": "rm -rf docs/api && typedoc && echo 'Build complete'",
-    "docs:watch": "typedoc --watch",
-    "prepublishOnly": "npm run build",
-    "release:patch": "npm version patch && git push --follow-tags",
-    "release:minor": "npm version minor && git push --follow-tags",
-    "release:major": "npm version major && git push --follow-tags"
-  },
   "keywords": [
     "linkedin",
     "sales-navigator",
@@ -66,5 +42,28 @@
     "typedoc-plugin-markdown": "^4.9.0",
     "typescript": "^5.9.3",
     "vitest": "^1.6.0"
+  },
+  "scripts": {
+    "dev:playground": "pnpm -C apps/playground dev",
+    "search": "node scripts/rg-fast.mjs",
+    "rg:fast": "node scripts/rg-fast.mjs",
+    "build": "tsc -p tsconfig.json",
+    "typecheck": "tsc --noEmit",
+    "typecheck:playground": "pnpm -C apps/playground typecheck",
+    "typecheck:all": "pnpm typecheck && pnpm typecheck:playground",
+    "lint": "eslint \"src/**/*.ts\" --max-warnings=0",
+    "lint:playground": "eslint \"apps/playground/src/**/*.{ts,tsx}\" \"apps/playground/server/**/*.ts\" --max-warnings=0",
+    "lint:all": "eslint \"src/**/*.ts\" \"apps/playground/src/**/*.{ts,tsx}\" \"apps/playground/server/**/*.ts\" --max-warnings=0",
+    "lint:fix": "eslint \"src/**/*.ts\" \"apps/playground/src/**/*.{ts,tsx}\" \"apps/playground/server/**/*.ts\" --fix",
+    "check": "pnpm typecheck:all && pnpm lint:all",
+    "dev": "pnpm dev:playground",
+    "dev:watch": "tsc -w -p tsconfig.json",
+    "test": "vitest run",
+    "docs": "typedoc",
+    "docs:netlify": "rm -rf docs/api && typedoc && echo 'Build complete'",
+    "docs:watch": "typedoc --watch",
+    "release:patch": "npm version patch && git push --follow-tags",
+    "release:minor": "npm version minor && git push --follow-tags",
+    "release:major": "npm version major && git push --follow-tags"
   }
-}
+}