jumpy-lion 0.1.6-beta.7 → 1.0.0-beta.0

package/dist/browser-controller.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"browser-controller.d.ts","sourceRoot":"","sources":["../src/browser-controller.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,iBAAiB,EAAc,MAAM,SAAS,CAAC;AAGxD,OAAO,KAAK,EAAE,oBAAoB,EAAE,MAAM,qBAAqB,CAAC;AAIhE,OAAO,KAAK,EAAE,WAAW,EAAE,YAAY,EAAE,MAAM,oBAAoB,CAAC;AACpE,OAAO,KAAK,EAAE,MAAM,EAAE,MAAM,WAAW,CAAC;AACxC,OAAO,OAAO,MAAM,WAAW,CAAC;AAEhC,MAAM,MAAM,aAAa,GAAG,OAAO,CAAC;AAEpC,MAAM,CAAC,OAAO,OAAO,oBAAqB,SAAQ,iBAAiB,CAC/D,WAAW,EAAE,6CAA6C;AAC1D,oBAAoB,EAAE,gBAAgB;AACtC,YAAY,EAAE,4BAA4B;AAC1C,EAAE,EAAE,0DAA0D;AAC9D,aAAa,CAChB;IACG,OAAO,CAAC,MAAM,CAAC,CAAa;IAC5B,OAAO,CAAC,iBAAiB,CAAK;IAC9B,OAAO,CAAC,qBAAqB,CAAS;IACtC,OAAO,CAAC,SAAS,CAAS;IAEpB,UAAU,IAAI,OAAO,CAAC,IAAI,CAAC;IA4BjC;;;OAGG;IACH,OAAO,CAAC,yBAAyB;IAiBjC;;;OAGG;YACW,iBAAiB;IAqC/B;;;OAGG;cACa,MAAM,IAAI,OAAO,CAAC,IAAI,CAAC;IAiCvC;;;OAGG;cACa,KAAK,IAAI,OAAO,CAAC,IAAI,CAAC;IAiBtC;;;OAGG;cACa,QAAQ,CAAC,UAAU,SAAI,GAAG,OAAO,CAAC,aAAa,CAAC;YAqDlD,yBAAyB;IAgOvC;;;OAGG;cACa,WAAW,CAAC,IAAI,EAAE,aAAa,EAAE,OAAO,EAAE,MAAM,EAAE,GAAG,OAAO,CAAC,IAAI,CAAC;IAQlF;;;OAGG;cACa,WAAW,CAAC,IAAI,EAAE,aAAa,GAAG,OAAO,CAAC,MAAM,EAAE,CAAC;IAQ1D,qBAAqB,CAAC,SAAS,EAAE,MAAM,GAAG,SAAS,EAAE,YAAY,EAAE,GAAG,GAAG,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC;CAI5G"}
+{"version":3,"file":"browser-controller.d.ts","sourceRoot":"","sources":["../src/browser-controller.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,iBAAiB,EAAc,MAAM,SAAS,CAAC;AAExD,OAAO,KAAK,EAAE,WAAW,EAAE,oBAAoB,EAAE,YAAY,EAAE,MAAM,qBAAqB,CAAC;AAK3F,OAAO,KAAK,EAAE,MAAM,EAAE,MAAM,WAAW,CAAC;AACxC,OAAO,OAAO,MAAM,WAAW,CAAC;AAGhC,MAAM,MAAM,aAAa,GAAG,OAAO,CAAC;AAEpC,MAAM,CAAC,OAAO,OAAO,oBAAqB,SAAQ,iBAAiB,CAC/D,WAAW,EAAE,6CAA6C;AAC1D,oBAAoB,EAAE,gBAAgB;AACtC,YAAY,EAAE,4BAA4B;AAC1C,EAAE,EAAE,0DAA0D;AAC9D,aAAa,CAChB;IACG,OAAO,CAAC,qBAAqB,CAAS;IACtC,OAAO,CAAC,SAAS,CAAS;IAE1B;;;;;OAKG;IACH,OAAO,CAAC,SAAS,CAAC,CAAiB;IACnC,OAAO,CAAC,WAAW,CAAC,CAAoE;IACxF,OAAO,CAAC,qBAAqB,CAAC,CAAyB;IACvD,OAAO,CAAC,MAAM,CAAC,QAAQ,CAAC,qBAAqB,CAAQ;IAErD;;;;;;OAMG;IACH,OAAO,KAAK,MAAM,GAEjB;IAEK,UAAU,IAAI,OAAO,CAAC,IAAI,CAAC;IASjC;;;;OAIG;IACH,OAAO,CAAC,gBAAgB;IAsBxB,eAAe;IACf,OAAO,CAAC,eAAe;IAcvB;;;OAGG;IACH,OAAO,CAAC,yBAAyB;IAiBjC;;;OAGG;YACW,iBAAiB;IAwC/B;;;OAGG;cACa,MAAM,IAAI,OAAO,CAAC,IAAI,CAAC;IA8CvC;;;OAGG;cACa,KAAK,IAAI,OAAO,CAAC,IAAI,CAAC;IAkBtC;;;OAGG;cACa,QAAQ,CAAC,UAAU,SAAI,GAAG,OAAO,CAAC,aAAa,CAAC;IAqEhE;;;;;;OAMG;YACW,yBAAyB;IAOvC;;;;;OAKG;YACW,qBAAqB;IAiBnC;;;;OAIG;YACW,oBAAoB;IAUlC;;;OAGG;cACa,WAAW,CAAC,IAAI,EAAE,aAAa,EAAE,OAAO,EAAE,MAAM,EAAE,GAAG,OAAO,CAAC,IAAI,CAAC;IAQlF;;;OAGG;cACa,WAAW,CAAC,IAAI,EAAE,aAAa,GAAG,OAAO,CAAC,MAAM,EAAE,CAAC;IAQ1D,qBAAqB,CAAC,SAAS,EAAE,MAAM,GAAG,SAAS,EAAE,YAAY,EAAE,GAAG,GAAG,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC;CAI5G"}

package/dist/browser-controller.js

@@ -1,59 +1,107 @@
 import CDP from 'chrome-remote-interface';
 import { BrowserController, log, utils } from 'crawlee';
-import { FingerprintGenerator } from 'fingerprint-generator';
+import { applyToPage } from './browser-process/fingerprint-config.js';
+import { runWithRetries, fixedBackoff, disposeClient } from './connection/cdp-reconnection.js';
+import { createSessionClient } from './connection/session-client.js';
 import { PAGE_CLOSED } from './events.js';
-import { CdpFingerprintInjector } from './fingerprinting/fingerprint-injector.js';
-import { generateNonApifyFingerprint } from './fingerprinting/non-apify-fingerprint-generator.js';
 import CdpPage from './page.js';
-export default class CDPBrowserController extends BrowserController {
+import { installSessionInjectionHook } from './session/inject-hook.js';
+class CDPBrowserController extends BrowserController {
     constructor() {
         super(...arguments);
-        Object.defineProperty(this, "client", {
+        Object.defineProperty(this, "hasDisconnectListener", {
             enumerable: true,
             configurable: true,
             writable: true,
-            value: void 0
-        });
-        Object.defineProperty(this, "reconnectAttempts", {
+            value: false
+        }); // Flag to track disconnect listener
+        Object.defineProperty(this, "isClosing", {
             enumerable: true,
             configurable: true,
             writable: true,
-            value: 0
+            value: false
+        }); // Flag to track intentional browser closure
+        /**
+         * A SINGLE keep-alive ping loop for the whole browser socket. In flatten
+         * mode every page shares one websocket, so one ping loop (and one ws 'error'
+         * listener) covers them all - a per-page heartbeat would fan N intervals and
+         * N listeners onto the same EventEmitter.
+         */
+        Object.defineProperty(this, "heartbeat", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
         });
-        Object.defineProperty(this, "hasDisconnectListener", {
+        Object.defineProperty(this, "heartbeatWs", {
             enumerable: true,
             configurable: true,
             writable: true,
-            value: false
-        }); // Flag to track disconnect listener
-        Object.defineProperty(this, "isClosing", {
+            value: void 0
+        });
+        Object.defineProperty(this, "heartbeatErrorHandler", {
             enumerable: true,
             configurable: true,
             writable: true,
-            value: false
-        }); // Flag to track intentional browser closure
+            value: void 0
+        });
+    }
+    /**
+     * The single browser-level CDP client. This is the ws-endpoint connection
+     * the plugin opened at launch (`_connectViaWsEndpoint`) and Crawlee handed us
+     * via `assignBrowser` - NOT a second connection. Every page is a flat CDP
+     * session multiplexed over this one socket (ADR 0003), so there is no
+     * per-page socket and no `CDP({ port })` here.
+     */
+    get client() {
+        return this.browser;
     }
     async initialize() {
-        const maxInitAttempts = 3;
-        let attempt = 0;
-        while (attempt < maxInitAttempts) {
-            try {
-                this.client = await CDP({
-                    port: this.launchContext.debuggingPort,
-                    local: true,
-                });
-                this._attachDisconnectListener();
-                return;
+        // No connection is opened here - `this.browser` is already the live
+        // browser-level socket. We only wire the disconnect listener + the single
+        // shared-socket heartbeat once. No domain is enabled (eager
+        // Network.enable/Page.enable are CDP detection vectors).
+        this._attachDisconnectListener();
+        this._attachHeartbeat();
+    }
+    /**
+     * One keep-alive ping loop for the shared browser socket. Re-bound after a
+     * socket reconnect so it follows the live ws. Idempotent.
+     * @private
+     */
+    _attachHeartbeat() {
+        this._clearHeartbeat();
+        const ws = this.client?._ws;
+        if (!ws)
+            return;
+        const errorHandler = (error) => {
+            log.error('Browser WebSocket error occurred:', { error });
+        };
+        ws.on('error', errorHandler);
+        this.heartbeatWs = ws;
+        this.heartbeatErrorHandler = errorHandler;
+        this.heartbeat = setInterval(() => {
+            if (ws.readyState === ws.OPEN) {
+                ws.ping(() => { });
             }
-            catch (error) {
-                attempt++;
-                log.error(`Failed to initialize CDP client (attempt ${attempt}/${maxInitAttempts})`, error);
-                if (attempt === maxInitAttempts) {
-                    throw error;
-                }
-                // Wait before retrying
-                await utils.sleep(2000 * attempt);
+            else if (!this.isClosing && ws.readyState !== ws.CONNECTING) {
+                log.debug('Browser socket health check failed, clearing heartbeat');
+                this._clearHeartbeat();
             }
+        }, CDPBrowserController.HEARTBEAT_INTERVAL_MS);
+    }
+    /** @private */
+    _clearHeartbeat() {
+        if (this.heartbeat) {
+            clearInterval(this.heartbeat);
+            this.heartbeat = undefined;
+        }
+        // Detach the ws 'error' listener too, so a reconnect (which re-runs
+        // _attachHeartbeat) never stacks listeners toward MaxListenersExceeded.
+        if (this.heartbeatWs && this.heartbeatErrorHandler) {
+            this.heartbeatWs.removeListener('error', this.heartbeatErrorHandler);
+            this.heartbeatWs = undefined;
+            this.heartbeatErrorHandler = undefined;
         }
     }
     /**
@@ -80,68 +128,85 @@ export default class CDPBrowserController extends BrowserController {
      * @private
      */
     async _attemptReconnect(maxAttempts = 5, delayMs = 2000) {
-        this.reconnectAttempts = 0;
-        while (this.reconnectAttempts < maxAttempts) {
-            try {
-                log.info(`Reconnect attempt ${this.reconnectAttempts + 1} of ${maxAttempts}`);
-                // Connect to browser target directly
-                this.client = await CDP({
-                    port: this.launchContext.debuggingPort,
-                    target: 'browser', // This connects to the root target without creating new ones
-                    local: true,
-                });
-                // NOTE: Network.enable() and Page.enable() REMOVED - they are CDP detection vectors!
-                // These domains will be enabled lazily only when actually needed
-                // Enabling them on connect triggers detectable side effects
-                this.reconnectAttempts = 0;
+        await runWithRetries({
+            label: 'browser socket reconnect',
+            policy: fixedBackoff(maxAttempts, delayMs / 2),
+            attempt: async (attempt) => {
+                log.info(`Reconnect attempt ${attempt} of ${maxAttempts}`);
+                // Reconnect the single browser socket over the SAME ws endpoint
+                // (flatten transport - no port, no root-target connect). Pages
+                // read the client through `() => this.browser`, so reassigning it
+                // here transparently points every page proxy at the fresh socket;
+                // each page re-attaches its own flat session lazily on its next
+                // op (PageSession re-attach). No domain is enabled on connect -
+                // that is a CDP detection vector.
+                const browserProcess = this.launchContext.process;
+                const wsUrl = await browserProcess.wsEndpoint();
+                const oldClient = this.browser;
+                this.browser = await CDP({ target: wsUrl, local: true });
+                // Detach the old client's event listeners BEFORE closing it. Closing
+                // emits 'disconnect'/'close' on the old client; leaving its listeners
+                // attached would (a) re-enter _attemptReconnect even though a fresh
+                // socket is already assigned, and (b) fire the plugin's teardown, which
+                // releases the debugging port for a still-live browser process.
+                oldClient.removeAllListeners?.();
+                // Close the replaced socket so its fd is not leaked per reconnect.
+                await disposeClient(oldClient);
                 log.info('Reconnected to browser successfully.');
                 this.hasDisconnectListener = false;
                 this._attachDisconnectListener();
-                return;
-            }
-            catch (error) {
-                this.reconnectAttempts++;
-                log.error(`Reconnect attempt ${this.reconnectAttempts} failed.`, error);
-                if (this.reconnectAttempts === maxAttempts) {
-                    log.error('Max reconnect attempts reached.');
-                    return;
-                }
-                await utils.sleep(delayMs / 2);
-            }
-        }
+                // Re-bind the heartbeat + error listener to the fresh socket.
+                this._attachHeartbeat();
+                return true;
+            },
+            onAttemptError: (error, attempt) => {
+                log.error(`Reconnect attempt ${attempt} failed.`, error);
+            },
+        });
     }
     /**
      * Gracefully closes the browser and associated process.
      * @private
      */
     async _close() {
+        // Set first so the disconnect listener bails instead of fighting our
+        // own shutdown with reconnect attempts when Browser.close drops the WS.
+        this.isClosing = true;
+        this._clearHeartbeat();
+        const browserProcess = this.launchContext.process;
+        // 1) Graceful CDP quit. This lets Chromium tear down its OWN helper
+        //    processes and write a clean-exit preference, so there is no macOS
+        //    "quit unexpectedly" crash dialog. Fast-fail to the process kill -
+        //    a hung / resource-exhausted browser will not answer this.
         try {
-            this.isClosing = true;
             if (this.client) {
                 await Promise.race([
-                    this.client.close(),
-                    new Promise((_, reject) => setTimeout(() => reject(new Error('CDP client close timeout')), 3000)),
+                    this.client.Browser.close(),
+                    new Promise((_, reject) => setTimeout(() => reject(new Error('Browser.close timeout')), 2000)),
                 ]);
             }
-            // Gracefully close the browser process with shorter timeout
-            await Promise.race([
-                this.launchContext.process.close(),
-                new Promise((_, reject) => setTimeout(() => reject(new Error('Browser process close timeout')), 3000)),
-            ]);
-            log.info('Browser process closed successfully');
         }
         catch (e) {
-            log.warning('Could not close browser gracefully, force killing', e);
-            // Force kill the browser process immediately
-            try {
-                await this.launchContext.process.kill();
-            }
-            catch (killError) {
-                log.error('Could not kill browser process', killError);
+            log.debug('Graceful Browser.close failed; falling back to process group kill', e);
+        }
+        // 2) Drop the websocket (best-effort - it may already be gone after
+        //    Browser.close). Never let this block shutdown.
+        try {
+            if (this.client) {
+                await Promise.race([
+                    this.client.close(),
+                    new Promise((_, reject) => setTimeout(() => reject(new Error('CDP client close timeout')), 1000)),
+                ]);
             }
         }
-        // Wait for 5 seconds to ensure the browser is fully closed
-        await utils.sleep(5000);
+        catch (e) {
+            log.debug('CDP client close failed/timed out', e);
+        }
+        // 3) Guarantee the process and its whole group are gone. close() does
+        //    SIGTERM→SIGKILL on the process GROUP with real escalation, so even
+        //    if the graceful path failed, no orphan helpers survive.
+        await browserProcess.close();
+        log.debug('Browser process closed successfully');
     }
     /**
      * Force kills the browser process without any grace period.
@@ -150,6 +215,7 @@ export default class CDPBrowserController extends BrowserController {
     async _kill() {
         try {
             this.isClosing = true;
+            this._clearHeartbeat();
             if (this.client) {
                 await Promise.race([
                     this.client.close(),
@@ -170,27 +236,42 @@ export default class CDPBrowserController extends BrowserController {
         let retries = 0;
         while (retries < maxRetries) {
             try {
-                if (!this.client) {
+                if (!this.hasDisconnectListener) {
                     await this.initialize();
                 }
-                // Check if client is still connected
+                // Heal the shared browser socket if it has dropped, before we
+                // create a target on it.
                 // @ts-expect-error Accessing internal WebSocket
                 if (this.client._ws?.readyState !== 1) { // WebSocket.OPEN = 1
-                    log.info('Browser connection lost, reinitializing...');
-                    await this.initialize();
+                    log.info('Browser socket lost, reconnecting...');
+                    await this._attemptReconnect();
                 }
-                const { Target } = this.client;
-                // Always create a new target
-                const { targetId } = await Target.createTarget({ url: 'about:blank' });
-                const session = await CDP({ target: targetId, port: this.launchContext.debuggingPort });
-                // Activate the target
-                await Target.activateTarget({ targetId });
-                // Create and return the new page using the static create method
-                const page = await CdpPage.create(session);
+                // Create the page target, then attach a FLAT session to it. The
+                // page is that session multiplexed over the single browser socket
+                // (ADR 0003) - no per-page websocket, no HTTP /json resolution.
+                const { targetId } = await this.client.Target.createTarget({ url: 'about:blank' });
+                // A mutable sessionId the page's proxy reads at call time; a
+                // re-attach after a transport drop rewrites it in place, so the
+                // proxy and PageSession stay stable across reconnects.
+                const sessionRef = { sessionId: '' };
+                const attach = async () => {
+                    const { sessionId } = await this.client.Target.attachToTarget({ targetId, flatten: true });
+                    sessionRef.sessionId = sessionId;
+                };
+                await attach();
+                await this.client.Target.activateTarget({ targetId });
+                const sessionClient = createSessionClient({
+                    browser: () => this.client,
+                    sessionId: () => sessionRef.sessionId,
+                });
+                // Create and return the new page over its session-scoped client.
+                const page = await CdpPage.create(sessionClient, { reattach: attach });
                 page.once(PAGE_CLOSED, () => {
                     this.activePages -= 1;
                 });
                 await this._maybeOverrideFingerprint(page);
+                await this._recordLaunchSnapshot(page);
+                await this._maybeRestoreSession(page);
                 return page;
             }
             catch (error) {
@@ -211,200 +292,53 @@ export default class CDPBrowserController extends BrowserController {
         }
         throw new Error('Failed to create a new page after maximum retry attempts.');
     }
+    /**
+     * Thin delegate to the FingerprintConfig module's post-launch path. It
+     * reuses the once-per-launch profile selection (stamped by the plugin's
+     * pre-launch native path) or selects here for the system-Chrome fallback,
+     * then drives the JS fingerprint injection on the new page. The pre-vs-post
+     * decision and the PROFILE_SELECTION_KEY handshake live inside that module.
+     */
     async _maybeOverrideFingerprint(page) {
-        if (!this.launchContext.fingerprint) {
-            log.debug('No fingerprint provided in launchContext, skipping fingerprint injection');
-            return;
-        }
+        await applyToPage(this.launchContext, page);
+    }
+    /**
+     * Records the launch-time inputs the saveSession() helper later needs to read
+     * off the page - fingerprintConfig, fingerprintOptions, resolvedLocale, fingerprint,
+     * userDataDir, proxyUrl, and the sessionBundle (if any).
+     * @private
+     */
+    async _recordLaunchSnapshot(page) {
         try {
-            // Get fingerprint generator options from launch context (passed from browserPoolOptions)
-            const fingerprintGeneratorOptions = this.launchContext.launchOptions?.fingerprintGeneratorOptions;
-            // Check if we need to regenerate the fingerprint based on OS mismatch
-            const { fingerprint: launchFingerprint } = this.launchContext;
-            let fingerprint = launchFingerprint;
-            let fp = fingerprint.fingerprint;
-            // ── Non-Apify real-device fingerprint override ───────────────────────
-            // When useNonApifyFingerprints is set, replace the Crawlee-provided
-            // synthetic fingerprint with a real Chrome device profile. All fields
-            // (navigator, screen, GPU, UA-CH) come from the same physical device,
-            // guaranteeing cross-property consistency that synthetic generators miss.
-            const _fpOpts = this.launchContext.launchOptions?.fingerprintOptions;
-            if (_fpOpts?.useNonApifyFingerprints) {
-                // User-supplied fingerprintOptions.platform wins; falls back to
-                // whatever the existing fingerprint already says.
-                const userPlatform = _fpOpts?.platform;
-                const osHint = (() => {
-                    const p = (fp?.navigator?.platform || '').toLowerCase();
-                    if (p.includes('mac'))
-                        return 'macos';
-                    if (p.includes('linux'))
-                        return 'linux';
-                    return 'windows';
-                })();
-                const proxySeedKey = this.launchContext.proxyUrl
-                    ? (this.launchContext.proxyUrl.match(/session-([^,&]+)/i)?.[1] ?? null)
-                    : null;
-                fingerprint = await generateNonApifyFingerprint({
-                    platform: userPlatform,
-                    os: osHint,
-                    proxySeedKey,
-                });
-                fp = fingerprint.fingerprint;
-                this.launchContext.fingerprint = fingerprint;
-                log.info('Using non-Apify real Chrome device fingerprint', {
-                    requestedPlatform: userPlatform ?? '(none — derived from existing fingerprint)',
-                    os: osHint,
-                    platform: fp?.navigator?.platform,
-                    userAgent: `${(fp?.navigator?.userAgent || '').substring(0, 70)}...`,
-                    webglRenderer: (fp?.videoCard?.renderer || '').substring(0, 70),
-                });
-            }
-            if (fingerprintGeneratorOptions?.operatingSystems?.length > 0) {
-                const requestedOS = fingerprintGeneratorOptions.operatingSystems[0]?.toLowerCase();
-                const currentPlatform = fp?.navigator?.platform?.toLowerCase() || '';
-                // Map platform names to OS names
-                const platformToOS = {
-                    'win32': 'windows',
-                    'macintel': 'macos',
-                    'linux x86_64': 'linux',
-                    'linux': 'linux',
-                };
-                const currentOS = platformToOS[currentPlatform] || currentPlatform;
-                // Check if the fingerprint matches the requested OS
-                const osMatches = requestedOS === currentOS ||
-                    (requestedOS === 'windows' && currentPlatform.includes('win')) ||
-                    (requestedOS === 'macos' && currentPlatform.includes('mac')) ||
-                    (requestedOS === 'linux' && currentPlatform.includes('linux'));
-                if (!osMatches) {
-                    log.info('Fingerprint OS mismatch detected, regenerating fingerprint', {
-                        requestedOS,
-                        currentPlatform,
-                        currentOS,
-                        fingerprintGeneratorOptions,
-                    });
-                    // Regenerate fingerprint with correct options using fingerprint-generator directly
-                    try {
-                        const generator = new FingerprintGenerator(fingerprintGeneratorOptions);
-                        fingerprint = generator.getFingerprint();
-                        fp = fingerprint.fingerprint;
-                        // Update the launch context with the regenerated fingerprint
-                        this.launchContext.fingerprint = fingerprint;
-                        log.info('Fingerprint regenerated successfully', {
-                            newPlatform: fp?.navigator?.platform,
-                            newUserAgent: `${(fp?.navigator?.userAgent || '').substring(0, 50)}...`,
-                        });
-                    }
-                    catch (regenerateError) {
-                        log.error('Failed to regenerate fingerprint, using original', { error: regenerateError });
-                    }
-                }
-                else {
-                    log.debug('Fingerprint OS matches requested OS', { requestedOS, currentPlatform });
-                }
-            }
-            const webgl = fp?.webgl;
-            log.debug('Fingerprint data from generator:', {
-                hasFingerprint: !!fp,
-                hasHeaders: !!fingerprint.headers,
-                navigatorPlatform: fp?.navigator?.platform,
-                navigatorUserAgent: `${(fp?.navigator?.userAgent || '').substring(0, 50)}...`,
-                screenWidth: fp?.screen?.width,
-                screenHeight: fp?.screen?.height,
-                webglVendor: webgl?.vendorUnmasked?.substring(0, 30),
-                webglRenderer: webgl?.rendererUnmasked?.substring(0, 50),
-            });
-            // Detect platform from fingerprint or default to Windows for better evasion
-            const fingerprintPlatform = fp?.navigator?.platform;
-            const platform = fingerprintPlatform || 'Win32'; // Default to Windows instead of Linux
-            // Determine if we're running on Apify
-            const isApify = process.env.APIFY_IS_AT_HOME === 'true';
-            // Get fingerprint options from launch context
-            const fingerprintOptions = this.launchContext.launchOptions?.fingerprintOptions || {};
-            // Get recommended settings based on environment
-            const defaultOptions = isApify
-                ? CdpFingerprintInjector.getApifyRecommendedSettings()
-                : {
-                    debug: false, // Disable debug logging - anti-bot services detect debug prefixes
-                    enableAdvancedStealth: true,
-                    bypassRuntimeEnable: true,
-                    spoofWebGL: true,
-                    spoofAudioContext: true,
-                    spoofClientRects: true,
-                    spoofFonts: true,
-                    spoofPerformance: true,
-                    spoofLocale: true,
-                    detectTimezone: !!this.launchContext.proxyUrl,
-                    useFingerprintDefaults: true, // Use hardcoded defaults (set to false to use generated fingerprint data)
-                    // 2024-2025 new defaults
-                    bypassCDPDetection: true,
-                    spoofStorage: true,
-                    spoofTiming: true,
-                    enableDataDomeBypass: false,
-                    webRtcPolicy: 'spoof',
-                    // Safe defaults for humanized interaction patterns
-                    humanization: {
-                        mouse: true,
-                        keyboard: true,
-                        scroll: true,
-                    },
-                };
-            // Determine effective useFingerprintDefaults value.
-            // Real device profiles (useNonApifyFingerprints=true) contain consistent cross-property
-            // data measured from a real device — default to using it (useFingerprintDefaults=false).
-            // Synthetic Apify-generated fingerprints need the hardcoded defaults to avoid
-            // injecting inconsistent generated values, so they keep useFingerprintDefaults=true.
-            const usingRealDeviceProfile = !!_fpOpts?.useNonApifyFingerprints;
-            const effectiveUseFingerprintDefaults = fingerprintOptions.useFingerprintDefaults
-                ?? (usingRealDeviceProfile ? false : (defaultOptions.useFingerprintDefaults ?? true));
-            // Platform selection logic:
-            // - When useFingerprintDefaults is false: prefer generated fingerprint platform
-            // - When useFingerprintDefaults is true (default): prefer hardcoded fingerprintOptions.platform
-            const effectivePlatform = effectiveUseFingerprintDefaults === false
-                ? (platform || fingerprintOptions.platform || 'Win32') // Generated fingerprint first
-                : (fingerprintOptions.platform || platform || 'Win32'); // Hardcoded option first
-            // Check useNativeStealth from all possible locations (in priority order):
-            //   1. Top-level launchOptions (e.g. CDPBrowserPlugin constructor arg)
-            //   2. Inside fingerprintOptions (e.g. datadome test / crawler launchOptions)
-            //   3. At launchContext root (some CDPCrawler launchContext configurations)
-            const useNativeStealth = !!this.launchContext.launchOptions?.useNativeStealth ||
-                !!this.launchContext.launchOptions?.fingerprintOptions?.useNativeStealth ||
-                !!this.launchContext?.useNativeStealth;
-            // Resolved locale triple is populated in browser-plugin before launch. Pass the
-            // whole thing through so the injector sets navigator.language, Accept-Language,
-            // Intl defaults, and timezone from one coherent source of truth.
-            const resolvedLocale = this.launchContext.launchOptions?.resolvedLocale;
-            // Merge humanization options properly
-            const mergedOptions = {
-                ...defaultOptions,
-                ...fingerprintOptions,
-                useNativeStealth,
-                // Explicitly set the computed effective value — the spread above would resolve to
-                // defaultOptions.useFingerprintDefaults (always true) when fingerprintOptions
-                // does not include the key, so we must override it here.
-                useFingerprintDefaults: effectiveUseFingerprintDefaults,
+            const launchOptions = this.launchContext.launchOptions ?? {};
+            page.setLaunchSnapshot({
+                fingerprintConfig: launchOptions.fingerprintConfig,
+                fingerprintOptions: (launchOptions.fingerprintOptions ?? {}),
+                resolvedLocale: launchOptions.resolvedLocale,
+                fingerprint: this.launchContext.fingerprint,
+                userDataDir: launchOptions.userDataDir,
                 proxyUrl: this.launchContext.proxyUrl,
-                platform: effectivePlatform,
-                viewport: this.launchContext.launchOptions?.viewport,
-                resolvedLocale,
-                // Ensure humanization options are properly merged
-                humanization: {
-                    ...defaultOptions.humanization,
-                    ...fingerprintOptions.humanization,
-                },
-            };
-            await CdpFingerprintInjector.injectFingerprint(page, fingerprint, mergedOptions);
-            page.setHumanizationOptions(mergedOptions.humanization);
-            log.info('Fingerprint injected successfully', {
-                platform: mergedOptions.platform,
-                isApify,
-                hasProxy: !!this.launchContext.proxyUrl,
-                useFingerprintDefaults: mergedOptions.useFingerprintDefaults,
-                enableDataDomeBypass: mergedOptions.enableDataDomeBypass,
-                humanization: mergedOptions.humanization,
+                sessionBundle: launchOptions.sessionBundle,
             });
         }
-        catch (error) {
-            log.error('Error attaching fingerprint', { error });
+        catch (err) {
+            log.warning('Failed to record launch snapshot on page', { err: err.message });
+        }
+    }
+    /**
+     * Replays cookies + per-origin localStorage/sessionStorage from the sessionBundle
+     * onto a fresh page before any navigation happens.
+     * @private
+     */
+    async _maybeRestoreSession(page) {
+        const bundle = this.launchContext.launchOptions?.sessionBundle;
+        if (!bundle)
+            return;
+        try {
+            await installSessionInjectionHook(page, bundle);
+        }
+        catch (err) {
+            log.error('Failed to inject session bundle on new page', { err: err.message });
         }
     }
     /**
@@ -435,4 +369,11 @@ export default class CDPBrowserController extends BrowserController {
         return {};
     }
 }
+Object.defineProperty(CDPBrowserController, "HEARTBEAT_INTERVAL_MS", {
+    enumerable: true,
+    configurable: true,
+    writable: true,
+    value: 5000
+});
+export default CDPBrowserController;
 //# sourceMappingURL=browser-controller.js.map