crawlforge-mcp-server 6.6.2 → 6.8.0

package/src/core/StealthBrowserManager.js

@@ -11,14 +11,34 @@
 import { chromium } from 'playwright';
 import { z } from 'zod';
 import crypto from 'crypto';
+import fs from 'fs';
+import os from 'os';
+import path from 'path';
+import { createRequire } from 'module';
 import HumanBehaviorSimulator from '../utils/HumanBehaviorSimulator.js';
 import { BrowserContextPool } from './BrowserContextPool.js';
 import { safeGoto } from '../utils/ssrfGuard.js';
-import { detectChallengePage } from '../utils/challengeDetection.js';
+import { looksLikeInterstitial } from '../utils/challengeDetection.js';
+import { guardFirefoxPageErrors } from '../utils/firefoxPageErrorGuard.js';
+import { serverStealthProxies } from '../constants/config.js';
 
 // Grace given to a document that rendered no title and no text (see _waitOutEmptyDocument).
 export const EMPTY_DOCUMENT_GRACE_MS = 8000;
 
+// The Chrome major claimed when the installed binary cannot be read at all.
+// Only ever a floor: installedChromeVersion() prefers playwright-core's own
+// browsers.json, and a launched browser's real version overrides both.
+const FALLBACK_CHROME_MAJOR = 151;
+
+// The proxy a camoufox browser was launched with, kept on the browser itself so
+// it survives being parked and restored by an engine switch.
+const CAMOUFOX_PROXY = Symbol('crawlforge.camoufoxProxy');
+
+// The locale that camoufox browser was launched with — null when geoip derived
+// one from the proxy's exit IP and we therefore do not know it. Kept on the
+// browser for the same reason as the proxy: camoufox fixes it at launch.
+const CAMOUFOX_LOCALE = Symbol('crawlforge.camoufoxLocale');
+
 const StealthConfigSchema = z.object({
   level: z.enum(['basic', 'medium', 'advanced']).default('medium'),
   randomizeFingerprint: z.boolean().default(true),
@@ -61,8 +81,11 @@ const StealthConfigSchema = z.object({
     hardwareSpoofing: z.boolean().default(true)
   }).optional(),
 
-  // C2: browser engine selection — 'chromium' (default) or 'camoufox' (Firefox-based)
-  engine: z.enum(['chromium', 'camoufox']).optional().default('chromium')
+  // C2: browser engine selection — 'auto' (default), 'chromium' or 'camoufox'
+  // (Firefox-based). 'auto' is resolved to one of the concrete two by
+  // resolveStealthEngine before anything reads this field; see it for why the
+  // default moved off chromium.
+  engine: z.enum(['chromium', 'camoufox', 'auto']).optional().default('auto')
 });
 
 /**
@@ -84,9 +107,73 @@ function isChromium(page) {
   }
 }
 
+/**
+ * Resolve a requested engine to the one that will actually launch.
+ *
+ * Camoufox is the engine that gets past the walls a stealth call is made for —
+ * it spoofs at the C++/Juggler level, where a page cannot see the seam — so
+ * 'auto', now the default everywhere, asks for it and drops to Chromium only
+ * when the package is not there. That is the semantic ResearchOrchestrator has
+ * run with since v4.6.6 (RESEARCH_STEALTH_ENGINE='auto'); it is lifted here so
+ * every stealth path shares one definition of it.
+ *
+ * A caller who NAMED an engine gets that engine and nothing else: 'camoufox'
+ * is never downgraded, so a missing install still fails at launch with the
+ * install instructions rather than quietly running a browser the caller
+ * rejected — the failure mode this whole review exists to remove.
+ *
+ * @param {'auto'|'chromium'|'camoufox'|'playwright'|null|undefined} requested
+ *   'playwright' is the tool layer's public name for chromium; null/undefined
+ *   mean 'auto'.
+ * @returns {Promise<{engine: 'chromium'|'camoufox', fallbackWarning: string|null}>}
+ *   fallbackWarning is set only when 'auto' wanted camoufox and could not have
+ *   it, and is the one thing that stops that downgrade from being silent.
+ */
+export async function resolveStealthEngine(requested) {
+  if (requested === 'camoufox') return { engine: 'camoufox', fallbackWarning: null };
+  if (requested && requested !== 'auto') return { engine: 'chromium', fallbackWarning: null };
+
+  // Deployment-level answer for 'auto', because there is no correct global one.
+  // Which engine clears a wall depends on the exit IP: the 2026-09-21
+  // residential run had Camoufox clearing indeed.com where Chromium failed, and
+  // two hosted runs from a datacenter address found the exact reverse, with
+  // Camoufox winning no wall Chromium lost. An operator who knows which side of
+  // that their egress sits on can say so here; a caller naming an engine still
+  // overrides it. Anything unrecognised is ignored rather than fatal — a typo in
+  // an env var should not take stealth down.
+  const configured = String(process.env.CRAWLFORGE_STEALTH_ENGINE || '').trim().toLowerCase();
+  if (configured === 'chromium' || configured === 'playwright') {
+    return { engine: 'chromium', fallbackWarning: null };
+  }
+
+  let reason = 'camoufox is not installed (npm install camoufox)';
+  try {
+    if (await new CamoufoxAdapter().isAvailable()) {
+      return { engine: 'camoufox', fallbackWarning: null };
+    }
+  } catch (error) {
+    // Installed-but-broken arrives as a throw, and it is a different problem
+    // from not installed — a fetched binary that will not load is worth
+    // naming. Either way it is a reason to run Chromium, not to fail a scrape
+    // the caller never asked to pin to one engine.
+    reason = error.message;
+  }
+  return {
+    engine: 'chromium',
+    fallbackWarning:
+      `Stealth engine fell back to chromium: ${reason}. ` +
+      'Camoufox passes bot walls this Chromium does not; install it to use it.'
+  };
+}
+
 export class StealthBrowserManager {
   constructor(options = {}) {
     this.browser = null;
+    // Why the running browser is not the engine 'auto' asked for, or null when
+    // nothing was downgraded. Kept on the instance beside _launchedEngine so a
+    // tool layer can tell the caller which browser actually ran — a drop to
+    // Chromium that nobody reports reads as a camoufox result that failed.
+    this._engineFallbackWarning = null;
     this._maxContexts = parseInt(process.env.MAX_BROWSER_CONTEXTS || '10', 10);
     this.contexts = this._createContextPool();
     // D2.2: fingerprints Map is capped at _maxContexts to prevent unbounded growth.
@@ -149,25 +236,19 @@ export class StealthBrowserManager {
     // UA thirty majors behind the engine — the pool sat at 119–121 while
     // Chrome 152 shipped — is a staleness tell for anything that reads
     // sec-ch-ua (R15, 2026-09-04).
+    //
+    // The Chrome major is now read from the installed binary rather than
+    // listed. A pool of four majors on one binary meant three of four personas
+    // mis-stated the version navigator.userAgentData reports — the UA claimed
+    // Chrome 149 on a 151 Chromium (2026-09-21 benchmark, ua-version-vs-binary).
+    // One string per OS is not lost entropy: Chrome's UA has been frozen since
+    // the UA-reduction rollout, so minor/build/patch are always 0.0.0 and the OS
+    // token is fixed, and that one string is the only one a real Chrome of that
+    // major sends. Variation lives in the display, fonts, hardware and persona.
+    this.chromeVersion = StealthBrowserManager.installedChromeVersion() || `${FALLBACK_CHROME_MAJOR}.0.0.0`;
+    this.chromeMajor = StealthBrowserManager.majorVersion(this.chromeVersion) || FALLBACK_CHROME_MAJOR;
     this.userAgentPools = {
-      chrome: {
-        windows: [
-          'Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/151.0.0.0 Safari/537.36',
-          'Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/150.0.0.0 Safari/537.36',
-          'Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/149.0.0.0 Safari/537.36',
-          'Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/148.0.0.0 Safari/537.36'
-        ],
-        macos: [
-          'Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/151.0.0.0 Safari/537.36',
-          'Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/150.0.0.0 Safari/537.36',
-          'Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/149.0.0.0 Safari/537.36'
-        ],
-        linux: [
-          'Mozilla/5.0 (X11; Linux x86_64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/151.0.0.0 Safari/537.36',
-          'Mozilla/5.0 (X11; Linux x86_64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/150.0.0.0 Safari/537.36',
-          'Mozilla/5.0 (X11; Linux x86_64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/149.0.0.0 Safari/537.36'
-        ]
-      },
+      chrome: this.buildChromeUserAgents(this.chromeMajor),
       firefox: {
         windows: [
           'Mozilla/5.0 (Windows NT 10.0; Win64; x64; rv:135.0) Gecko/20100101 Firefox/135.0'
@@ -188,13 +269,9 @@ export class StealthBrowserManager {
       }
     };
 
-    // Operating system distributions for realistic user agent selection
-    this.osDistribution = {
-      windows: 0.75,
-      macos: 0.15,
-      linux: 0.10
-    };
-    
+    // No OS distribution any more: the persona's OS is the host's (see
+    // selectOS), not a draw from market share.
+
     // Browser market share for realistic selection
     this.browserDistribution = {
       chrome: 0.65,
@@ -287,6 +364,12 @@ export class StealthBrowserManager {
    */
   async launchStealthBrowser(config = {}) {
     const validatedConfig = StealthConfigSchema.parse({ ...this.defaultConfig, ...config });
+    // 'auto' has to become a concrete engine before the comparison below: an
+    // unresolved 'auto' never equals _launchedEngine, so every call would park
+    // a perfectly good browser and launch a second one beside it. This is the
+    // call that decides the engine — every other path reaches a browser
+    // through it — so it is the one that records the outcome.
+    await this._resolveConfigEngine(validatedConfig, true);
 
     // A Chromium that was OOM-killed or crashed doesn't error on reuse — its
     // protocol calls hang. Detect the corpse and relaunch instead.
@@ -328,11 +411,49 @@ export class StealthBrowserManager {
     }
   }
 
+  /**
+   * Rewrite config.engine in place to the engine that will actually launch,
+   * recording any downgrade on the instance.
+   *
+   * In place, because `engine` is read again further down — the park/reuse
+   * comparison, the fingerprint's browser pool, the camoufox context surgery —
+   * and every one of them has to see the same answer. Idempotent and cheap (a
+   * concrete engine resolves to itself; isAvailable()'s require is cached by
+   * the module loader), so the context path and the launch path can each call
+   * it without arranging who goes first.
+   *
+   * @param {{engine: string}} validatedConfig — mutated
+   * @param {boolean} [ownsTheDecision] — true for the call this launch's engine
+   *   is decided by (launchStealthBrowser). _doLaunchStealthBrowser re-checks
+   *   the very config that call already resolved, and recording "nothing was
+   *   downgraded" there would erase the downgrade the first pass had just
+   *   found — which is how the fallback would go silent again.
+   * @returns {Promise<string|null>} this call's fallback warning, if any
+   */
+  async _resolveConfigEngine(validatedConfig, ownsTheDecision = false) {
+    // A concrete engine is already the answer and cannot have fallen back.
+    if (validatedConfig.engine && validatedConfig.engine !== 'auto') {
+      if (ownsTheDecision) this._engineFallbackWarning = null;
+      return null;
+    }
+
+    const { engine, fallbackWarning } = await resolveStealthEngine(validatedConfig.engine);
+    validatedConfig.engine = engine;
+    this._engineFallbackWarning = fallbackWarning;
+    return fallbackWarning;
+  }
+
   /**
    * Actual browser launch, guarded by launchStealthBrowser's in-flight
    * promise so only one launch can be in progress at a time.
    */
   async _doLaunchStealthBrowser(validatedConfig) {
+    // Resolved again here rather than trusted: this method is reachable on its
+    // own, and an 'auto' that got this far unresolved would fall through to the
+    // chromium branch below — the exact silent downgrade 'auto' is meant to
+    // report.
+    await this._resolveConfigEngine(validatedConfig);
+
     // C2: delegate to CamoufoxAdapter when engine === 'camoufox'
     if (validatedConfig.engine === 'camoufox') {
       const adapter = new CamoufoxAdapter();
@@ -342,10 +463,69 @@ export class StealthBrowserManager {
           'camoufox is not installed. Run: npm install camoufox to use the Firefox-based stealth engine.'
         );
       }
-      this.browser = await adapter.launch({
-        headless: true,
+      // camoufox fixes its fingerprint — and, with geoip, its geolocation,
+      // timezone and locale — at launch, from the proxy it is launched with.
+      // So the proxy is resolved once here and reused for every context this
+      // browser serves (see createStealthContext): rotating underneath it would
+      // leave camoufox reporting the first proxy's city behind the second
+      // proxy's exit IP, which is a worse signal than not rotating at all.
+      // A rotation takes effect on the next launch, after cleanup().
+      const proxy = this.resolveProxy(validatedConfig);
+      // The caller's locale goes to the launcher, not to the context. camoufox
+      // sets language, Accept-Language and Intl together below the JS layer,
+      // where a Worker reads the same answer as the document; Playwright's
+      // Firefox context override reaches the document only, so asking for
+      // de-DE there produced ["de-DE"] in the page beside camoufox's own list
+      // in its worker (2026-09-21 benchmark, worker-languages). Fixed at
+      // launch, like the proxy: a later context asking for a different locale
+      // inherits the launched one until cleanup(). With a proxy, geoip derives
+      // the locale from the exit IP and must win — a persona from this call
+      // would name a country the address contradicts.
+      const locale = proxy ? null : validatedConfig.locale;
+      const browser = await adapter.launch({
+        // 'virtual' runs a real, windowed Firefox inside Xvfb instead of the
+        // headless build. Headless Firefox is its own tell — no window manager,
+        // no compositor, and a set of media/GL answers that differ from the
+        // browser everyone else runs — and camoufox ships this mode precisely
+        // to avoid it. Only on Linux: that is where a hosted image has no
+        // display and where the Dockerfile provides Xvfb; a Mac or Windows
+        // developer machine has neither, so plain headless stays there.
+        headless: process.platform === 'linux' ? 'virtual' : true,
+        proxy,
+        locale,
+        // camoufox draws its persona from ["windows","macos","linux"] when it
+        // is told nothing, so it claimed Windows on a Mac while still reporting
+        // an Apple M1 GPU and a `-apple-system: Mac` CSS platform hint
+        // (2026-09-21 benchmark, persona-os-vs-host). The host's OS is the only
+        // one the GPU strings, the font list and the TCP/IP fingerprint agree
+        // with, so it is the one camoufox is given.
+        //
+        // KNOWN NOT TO TAKE EFFECT on camoufox npm 0.1.19, measured 2026-09-21:
+        // ten launches asking for "macos" on a Mac produced a Mac persona about
+        // one time in three, which is the market-share draw, not the answer to a
+        // constraint. The client forwards `{ screen, os }` to
+        // fingerprint-generator (chunk-QNWJYPXY.js `generateFingerprint`), whose
+        // option for this is `operatingSystems: string[]` — `os` is not a key it
+        // knows, so it is dropped and the OS is drawn at random. The call below
+        // is the documented API and is kept: it is inert (camoufox only
+        // validates the value), it is correct the moment upstream honours it,
+        // and the alternative — generating a BrowserForge fingerprint ourselves
+        // and passing it through `fingerprint` — needs a dependency this package
+        // does not declare. Phase 2 of the stealth review owns the camoufox
+        // client; until then persona-os-vs-host stays baselined for camoufox.
+        os: this.hostOS(),
+        // Only ask for geoip when there is a proxy to derive it from. Without
+        // one it would look up this machine's own public IP — a network call,
+        // and an external service learning our address, to confirm a location
+        // the browser is already in.
+        geoip: !!proxy,
+        blockWebRTC: validatedConfig.blockWebRTC,
+        humanize: validatedConfig.simulateHumanBehavior,
         launchOptions: {}
       });
+      browser[CAMOUFOX_PROXY] = proxy;
+      browser[CAMOUFOX_LOCALE] = locale;
+      this.browser = browser;
       this._launchedEngine = 'camoufox';
       return this.browser;
     }
@@ -356,9 +536,7 @@ export class StealthBrowserManager {
       '--no-sandbox',
       '--disable-dev-shm-usage',
       '--disable-blink-features=AutomationControlled',
-      '--disable-web-security',
       '--disable-features=VizDisplayCompositor',
-      '--disable-extensions',
       '--disable-plugins',
       '--disable-background-timer-throttling',
       '--disable-backgrounding-occluded-windows',
@@ -374,12 +552,18 @@ export class StealthBrowserManager {
       '--safebrowsing-disable-auto-update',
       '--password-store=basic',
       '--use-mock-keychain',
-      
+
+      // A headless Chromium has no pointing device, so it reports
+      // primaryPointerType=coarse/none and hover:none — the media-query answer
+      // of a touchscreen kiosk under a desktop UA. These four blink settings
+      // (2 = HOVER_HOVER_TYPE, 4 = POINTER_FINE_TYPE) give it the mouse a
+      // desktop persona is supposed to have. Verified present in Chromium 151
+      // with `strings -a` on the binary.
+      '--blink-settings=primaryHoverType=2,availableHoverTypes=2,primaryPointerType=4,availablePointerTypes=4',
+
       // Additional stealth arguments
-      '--disable-default-apps',
       '--disable-component-extensions-with-background-pages',
       '--disable-background-networking',
-      '--disable-component-update',
       '--disable-client-side-phishing-detection',
       '--disable-domain-reliability',
       '--disable-ipc-flooding-protection',
@@ -392,9 +576,7 @@ export class StealthBrowserManager {
     if (validatedConfig.level === 'advanced') {
       stealthArgs.push(
         '--disable-gpu-sandbox',
-        '--disable-popup-blocking',
         '--disable-setuid-sandbox',
-        '--disable-site-isolation-trials',
         '--disable-threaded-animation',
         '--disable-threaded-scrolling',
         '--disable-in-process-stack-traces',
@@ -413,22 +595,22 @@ export class StealthBrowserManager {
       );
     }
 
-    // WebRTC blocking
+    // WebRTC blocking. The five flags that used to stand here disabled
+    // hardware codecs and extra routes — none of them stops an ICE candidate
+    // carrying the real address, which is what CreepJS read the host's IPv6
+    // out of (2026-09-21 benchmark, finding 9). This one is the switch that
+    // governs which local addresses WebRTC may use: with it, only the address
+    // the proxy already exposes is offered. Verified present in Chromium 151
+    // with `strings -a` on the binary.
     if (validatedConfig.blockWebRTC) {
-      stealthArgs.push(
-        '--disable-webrtc-hw-decoding',
-        '--disable-webrtc-hw-encoding',
-        '--disable-webrtc-multiple-routes',
-        '--disable-webrtc-hw-vp8-encoding',
-        '--enforce-webrtc-ip-permission-check'
-      );
+      stealthArgs.push('--webrtc-ip-handling-policy=disable_non_proxied_udp');
     }
 
-    // Handle proxy configuration
-    const currentProxy = await this.rotateProxy(validatedConfig);
-    if (currentProxy) {
-      stealthArgs.push(`--proxy-server=${currentProxy}`);
-    }
+    // No proxy argument here. Chromium's --proxy-server= has no field for the
+    // user:pass every residential proxy requires, and a proxy fixed at launch
+    // could never rotate: the browser it was baked into is cached for the life
+    // of the process. Both engines take the proxy per context instead — see
+    // createStealthContext.
 
     const browser = await chromium.launch({
       headless: true,
@@ -436,12 +618,27 @@ export class StealthBrowserManager {
       // never reads it) — see Dockerfile.
       executablePath: process.env.PLAYWRIGHT_CHROMIUM_EXECUTABLE_PATH || undefined,
       args: stealthArgs,
+      // patchright's "marks you as a stealth driver" list. Playwright passes
+      // all four by default, so dropping them from stealthArgs above is only
+      // half the job — they have to be taken off the default set too, or the
+      // command line still carries them. --disable-web-security went with them:
+      // it is readable in one line from any page (a cross-origin fetch that
+      // should throw and does not), and it contradicts this file's own decision
+      // to leave bypassCSP unset (R15, 2026-09-04).
       ignoreDefaultArgs: [
         '--enable-blink-features=IdleDetection',
-        '--enable-automation'
+        '--enable-automation',
+        '--disable-component-update',
+        '--disable-default-apps',
+        '--disable-extensions',
+        '--disable-popup-blocking'
       ]
     });
 
+    // A hosted image's system Chromium may not be the version browsers.json
+    // named, and the UA has to state the version that is actually running.
+    this._alignUserAgentsWithBinary(browser);
+
     // If this Chromium dies (OOM kill, crash), drop the handle so the next
     // call relaunches instead of reusing a corpse. The identity guard keeps a
     // late event from an old instance from nulling a newer one.
@@ -460,12 +657,18 @@ export class StealthBrowserManager {
    */
   async createStealthContext(config = {}) {
     const validatedConfig = StealthConfigSchema.parse({ ...this.defaultConfig, ...config });
-    
+
     // Always go through launchStealthBrowser: it returns the running browser
     // when the engine matches, and closes + relaunches on an engine mismatch.
     // Guarding on `!this.browser` here skipped that mismatch check, so a
     // camoufox request silently reused an already-running chromium browser.
     await this.launchStealthBrowser(validatedConfig);
+    // The browser that came back is the authority on which engine this context
+    // is created over, and everything below reads it: the fingerprint's browser
+    // pool branches on it, and an 'auto' left unresolved here would draw a
+    // Chrome persona for a Firefox browser.
+    validatedConfig.engine = this._launchedEngine ?? validatedConfig.engine;
+    const engineFallbackWarning = this._engineFallbackWarning;
 
     // Generate fingerprint for this context
     const fingerprint = this.generateAdvancedFingerprint(validatedConfig);
@@ -507,19 +710,79 @@ export class StealthBrowserManager {
       serviceWorkers: 'block'
     };
 
-    // camoufox's Firefox build predates the Browser.setDefaultViewport fields
-    // playwright-core 1.62 sends (screenSize, isMobile, ...) and rejects unknown
-    // properties, so any fixed viewport fails. viewport:null skips that protocol
-    // call entirely (deviceScaleFactor/isMobile/hasTouch/screen are invalid or
-    // meaningless without a viewport). window.screen is still spoofed via
-    // addInitScript in applyAdvancedStealthConfigurations.
+    // The proxy rides on the context, credentials included: Chromium takes it
+    // on Target.createBrowserContext and camoufox's Juggler on
+    // Browser.setContextProxy. Both were verified against a local authenticating
+    // proxy. camoufox additionally gets one at launch, because its geoip lookup
+    // runs there — but a launch-time proxy routes traffic and drops the
+    // credentials, so the context is what actually authenticates, on both
+    // engines. camoufox stays on the proxy it was launched with: its geolocation,
+    // timezone and locale were derived from that exit IP, and rotating
+    // underneath it would leave the first proxy's city behind the second
+    // proxy's address.
+    const proxy = this._launchedEngine === 'camoufox'
+      ? (this.browser[CAMOUFOX_PROXY] || null)
+      : this.resolveProxy(validatedConfig);
+    if (proxy) {
+      contextOptions.proxy = proxy;
+    }
+
     if (this._launchedEngine === 'camoufox') {
+      // camoufox's Firefox build predates the Browser.setDefaultViewport fields
+      // playwright-core 1.62 sends (screenSize, isMobile, ...) and rejects
+      // unknown properties, so any fixed viewport fails. viewport:null skips
+      // that protocol call entirely (deviceScaleFactor/isMobile/hasTouch/screen
+      // are invalid or meaningless without a viewport). camoufox generates its
+      // own screen and window and spoofs them below the JS layer.
       contextOptions.viewport = null;
       delete contextOptions.deviceScaleFactor;
       delete contextOptions.isMobile;
       delete contextOptions.hasTouch;
       delete contextOptions.screen;
       delete contextOptions.serviceWorkers;
+
+      // camoufox arrives with a complete Firefox identity of its own. Ours was
+      // overwriting it, and not with a Firefox one: for this engine the browser
+      // distribution is left open, so about two thirds of camoufox contexts were
+      // handed a Chrome User-Agent on a Gecko engine. Every one of them also
+      // sent sec-ch-ua, sec-ch-ua-mobile and sec-ch-ua-platform — client hints
+      // Firefox has never implemented and never sends. That is a decision a
+      // detector can make from the request headers alone, before a line of
+      // script runs.
+      delete contextOptions.userAgent;
+      delete contextOptions.extraHTTPHeaders;
+
+      // The locale goes the same way, proxy or no proxy — but it is not
+      // dropped: _doLaunchStealthBrowser hands the caller's locale to camoufox
+      // itself, which sets language, Accept-Language and Intl together below
+      // the JS layer. Playwright's Firefox context override reaches the
+      // document only, so setting it here reported ["de-DE"] in the page beside
+      // camoufox's own list in its worker (2026-09-21 benchmark,
+      // worker-languages).
+      delete contextOptions.locale;
+
+      // Behind a proxy, camoufox has already derived timezone and geolocation
+      // from the exit IP. Those agree with the address the site sees; a persona
+      // drawn here does not, so it must not override them.
+      if (proxy) {
+        delete contextOptions.timezoneId;
+        delete contextOptions.geolocation;
+      }
+
+      // Keep what we hand back honest. create_context returns this fingerprint,
+      // and reporting a Chrome user agent and a persona the browser never uses
+      // is worse than reporting nothing: null reads as "the engine owns this".
+      fingerprint.userAgent = null;
+      fingerprint.headers = {};
+      fingerprint.viewport = null;
+      fingerprint.hardware = { ...fingerprint.hardware, platform: null };
+      // The locale camoufox was actually launched with, which is this call's
+      // only when this call is the one that launched it — null behind a proxy,
+      // where geoip derived a locale we never see.
+      fingerprint.locale = this.browser[CAMOUFOX_LOCALE] ?? null;
+      if (proxy) {
+        fingerprint.timezone = null;
+      }
     }
 
     const context = await this.browser.newContext(contextOptions);
@@ -532,7 +795,11 @@ export class StealthBrowserManager {
     // D2.2: enforce LRU cap on fingerprints Map
     this._setFingerprint(contextId, fingerprint);
 
-    return { context, contextId, fingerprint };
+    // The engine and its warning ride back with the context, not only on the
+    // instance: the instance fields follow the browser, which the next call
+    // may switch, and the caller of THIS context still has to be able to say
+    // which browser it got.
+    return { context, contextId, fingerprint, engine: validatedConfig.engine, engineFallbackWarning };
   }
 
   /**
@@ -590,8 +857,11 @@ export class StealthBrowserManager {
       platform: fingerprint.hardware.platform,
       locale: fingerprint.locale,
       timezone: fingerprint.timezone,
-      // width/height only — the pool's selection weight is an internal.
-      viewport: { width: fingerprint.viewport.width, height: fingerprint.viewport.height }
+      // width/height only — the pool's selection weight is an internal. null on
+      // camoufox, which sizes its own window.
+      viewport: fingerprint.viewport
+        ? { width: fingerprint.viewport.width, height: fingerprint.viewport.height }
+        : null
     };
   }
 
@@ -626,17 +896,33 @@ export class StealthBrowserManager {
 
   /**
    * Choose a single OS ('windows' | 'macos' | 'linux') for a fingerprint.
-   * A custom UA pins the OS to whatever that UA reports; a non-random UA pins
-   * to windows (the default pool below); otherwise weighted-random.
+   * A custom UA pins the OS to whatever that UA reports; every other path takes
+   * the host's OS.
+   *
+   * A persona drawn at random claimed Windows, then Linux, on a macOS host
+   * (2026-09-21 benchmark, persona-os-vs-host). Nothing about the machine
+   * follows the draw: the TCP/IP fingerprint is the host kernel's, the GPU
+   * strings and the CSS platform hints are the host's, and a WebGL renderer
+   * reading "Apple M1" under a Windows UA is a cleaner signal than no spoofing
+   * at all. So the OS is the one thing in this fingerprint that is not
+   * randomised — it is observed.
    */
   selectOS(config = {}) {
     if (config.customUserAgent) {
       return this.inferOSFromUserAgent(config.customUserAgent);
     }
-    if (!config.useRandomUserAgent) {
-      return 'windows';
-    }
-    return this.weightedRandom(this.osDistribution);
+    return this.hostOS();
+  }
+
+  /**
+   * The host's own OS in the vocabulary the pools and generators use. Anything
+   * that is neither macOS nor Windows is treated as linux: it is the only other
+   * desktop persona modelled, and the closest to a BSD host's TCP fingerprint.
+   */
+  hostOS() {
+    if (process.platform === 'darwin') return 'macos';
+    if (process.platform === 'win32') return 'windows';
+    return 'linux';
   }
 
   /**
@@ -648,6 +934,64 @@ export class StealthBrowserManager {
     return 'windows';
   }
 
+  /**
+   * The version of the Chromium that is actually installed, as
+   * `151.0.7922.34`. playwright-core's browsers.json names the build it
+   * downloads — the same file Scrapling reads — and is the only source
+   * available before a browser is launched; once one is running,
+   * _alignUserAgentsWithBinary() corrects for a hosted image that pointed
+   * PLAYWRIGHT_CHROMIUM_EXECUTABLE_PATH at a Chromium of its own.
+   */
+  static installedChromeVersion() {
+    try {
+      const require = createRequire(import.meta.url);
+      const file = path.join(path.dirname(require.resolve('playwright-core')), 'browsers.json');
+      const entry = JSON.parse(fs.readFileSync(file, 'utf8')).browsers
+        .find((browser) => browser.name === 'chromium');
+      return entry?.browserVersion || null;
+    } catch {
+      return null;
+    }
+  }
+
+  /** The leading integer of a version string: `151.0.7922.34` -> 151. */
+  static majorVersion(version) {
+    const match = /^(\d+)/.exec(String(version ?? '').trim());
+    return match ? Number(match[1]) : null;
+  }
+
+  /**
+   * One Chrome user agent per OS at `major`. Chrome froze every other token of
+   * the string years ago, so these are literal, not templates with room.
+   */
+  buildChromeUserAgents(major) {
+    const chrome = `AppleWebKit/537.36 (KHTML, like Gecko) Chrome/${major}.0.0.0 Safari/537.36`;
+    return {
+      windows: [`Mozilla/5.0 (Windows NT 10.0; Win64; x64) ${chrome}`],
+      macos: [`Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) ${chrome}`],
+      linux: [`Mozilla/5.0 (X11; Linux x86_64) ${chrome}`]
+    };
+  }
+
+  /**
+   * Re-derive the Chrome pool from the browser that actually launched. Only
+   * does anything when the running binary is not the one browsers.json named —
+   * a hosted image's system Chromium — which is exactly the case where the
+   * pool would otherwise mis-state the version userAgentData reports.
+   */
+  _alignUserAgentsWithBinary(browser) {
+    let version = null;
+    try {
+      version = browser.version();
+    } catch { /* a browser that cannot be asked keeps the installed version */ }
+    if (!version || version === this.chromeVersion) return;
+    this.chromeVersion = version;
+    const major = StealthBrowserManager.majorVersion(version);
+    if (!major || major === this.chromeMajor) return;
+    this.chromeMajor = major;
+    this.userAgentPools.chrome = this.buildChromeUserAgents(major);
+  }
+
   /**
    * Select realistic user agent based on market distribution
    */
@@ -657,12 +1001,14 @@ export class StealthBrowserManager {
     }
 
     if (!config.useRandomUserAgent) {
-      return this.userAgentPools.chrome.windows[0];
+      // Not "the Windows default" any more: a fixed UA still has to be the
+      // host's, or it contradicts everything the machine itself reports.
+      return this.userAgentPools.chrome[this.hostOS()][0];
     }
 
-    // Use the OS chosen once for this fingerprint (falls back to a fresh draw
-    // if called without one, preserving the original standalone behavior).
-    selectedOS = selectedOS || this.weightedRandom(this.osDistribution);
+    // Use the OS chosen once for this fingerprint (falls back to the host's own
+    // if called without one, which is what selectOS would have returned).
+    selectedOS = selectedOS || this.hostOS();
 
     // Select browser based on distribution and OS compatibility
     let availableBrowsers = { ...this.browserDistribution };
@@ -796,24 +1142,41 @@ export class StealthBrowserManager {
   }
 
   /**
-   * Generate sec-ch-ua header.
-   * C2: brand versions are derived from the UA's Chrome major version so
-   * sec-ch-ua and the User-Agent header stay consistent.
+   * The brand list Chrome presents, in both places it is read: the sec-ch-ua
+   * request header and navigator.userAgentData.brands.
+   *
+   * One source for both because the two used to disagree. The header was built
+   * here and said "Google Chrome"; userAgentData was left to Chromium, which
+   * filled it in from the binary and answered "HeadlessChrome 151, Chromium
+   * 151" with no Google Chrome brand at all — rebrowser flagged the page as
+   * Chrome for Testing (2026-09-21 benchmark, useragentdata-brands and
+   * headless-markers). _applyEmulatedIdentity now hands this list to the
+   * renderer, so the header and the JS API are the same list.
+   *
    * @param {string} [userAgent] — the selected user agent string
+   * @returns {Array<{brand:string, version:string}>}
    */
-  generateSecChUaHeader(userAgent = '') {
+  generateUserAgentBrands(userAgent = '') {
     // Extract Chrome major version from the UA (e.g. "Chrome/151.0.0.0" → "151").
-    // Fall back to the bundled Chromium major if the UA is not a Chrome UA.
-    const match = userAgent.match(/Chrome\/(\d+)/i);
-    const version = match ? match[1] : '151';
+    // Fall back to the installed Chromium's major if the UA is not a Chrome UA.
+    const match = String(userAgent).match(/Chrome\/(\d+)/i);
+    const version = match ? match[1] : String(this.chromeMajor);
 
-    const brands = [
+    return [
       { brand: 'Not_A Brand', version: '8' },
       { brand: 'Chromium', version },
       { brand: 'Google Chrome', version }
     ];
+  }
 
-    return brands
+  /**
+   * Generate sec-ch-ua header.
+   * C2: brand versions are derived from the UA's Chrome major version so
+   * sec-ch-ua and the User-Agent header stay consistent.
+   * @param {string} [userAgent] — the selected user agent string
+   */
+  generateSecChUaHeader(userAgent = '') {
+    return this.generateUserAgentBrands(userAgent)
       .map(b => `"${b.brand}";v="${b.version}"`)
       .join(', ');
   }
@@ -828,7 +1191,7 @@ export class StealthBrowserManager {
       linux: '"Linux"'
     };
 
-    selectedOS = selectedOS || this.weightedRandom(this.osDistribution);
+    selectedOS = selectedOS || this.hostOS();
     return platforms[selectedOS] || '"Windows"';
   }
 
@@ -1093,7 +1456,7 @@ export class StealthBrowserManager {
    * Generate realistic hardware fingerprint
    */
   generateHardwareFingerprint(selectedOS) {
-    selectedOS = selectedOS || this.weightedRandom(this.osDistribution);
+    selectedOS = selectedOS || this.hostOS();
 
     const processors = [
       { cores: 4, threads: 8, name: 'Intel(R) Core(TM) i5-8250U CPU @ 1.60GHz' },
@@ -1104,20 +1467,60 @@ export class StealthBrowserManager {
       { cores: 8, threads: 16, name: 'AMD Ryzen 7 3700X 8-Core Processor' }
     ];
 
-    const selectedProcessor = processors[Math.floor(Math.random() * processors.length)];
+    // hardwareConcurrency and deviceMemory are observed, not drawn — the same
+    // call taken for the persona OS, and for the same reason.
+    //
+    // Both are readable from a Worker. An init script does not run in one, and
+    // Emulation.setHardwareConcurrencyOverride does not reach one either: a
+    // Worker is a separate target and the Emulation domain is not available on
+    // it. So a drawn value only ever landed in the document, beside the host's
+    // real one in the worker — 16 cores against 32 (2026-09-21 benchmark,
+    // worker-hardware-concurrency). A machine that reports its own cores is not
+    // a signal. A machine that disagrees with itself is.
+    const hardwareConcurrency = this.hostHardwareConcurrency();
+    const matching = processors.filter((p) => p.threads === hardwareConcurrency);
+    const selectedProcessor = matching.length
+      ? matching[Math.floor(Math.random() * matching.length)]
+      // No modelled CPU has this many threads. Name one that could — the
+      // processor string is reported in the fingerprint, never to a page.
+      : {
+          cores: Math.max(1, Math.round(hardwareConcurrency / 2)),
+          threads: hardwareConcurrency,
+          name: `AMD Ryzen ${Math.max(1, Math.round(hardwareConcurrency / 2))}-Core Processor`
+        };
 
     return {
-      hardwareConcurrency: selectedProcessor.threads,
+      hardwareConcurrency,
       processor: selectedProcessor.name,
       architecture: 'x86_64',
       memory: Math.floor(Math.random() * 24) + 8, // 8-32 GB
-      // navigator.deviceMemory is capped at 8 in every Chromium build, so 16
-      // or 32 is a value no real browser reports (sannysoft CHR_MEMORY: FAIL).
-      deviceMemory: Math.random() < 0.7 ? 8 : 4,
+      deviceMemory: this.hostDeviceMemory(),
       platform: this.selectRealisticPlatform(selectedOS)
     };
   }
 
+  /**
+   * The core count navigator.hardwareConcurrency will report: the host's own
+   * logical CPU count, which is what Chromium answers with
+   * (base::SysInfo::NumberOfProcessors) in the document and in every worker.
+   */
+  hostHardwareConcurrency() {
+    const count = os.cpus()?.length || 0;
+    return count > 0 ? count : 4;
+  }
+
+  /**
+   * navigator.deviceMemory as Chromium computes it: physical RAM rounded to the
+   * nearest power of two, in GiB, then clamped to [0.25, 8]. The clamp is why
+   * 16 or 32 is a value no real browser reports (sannysoft CHR_MEMORY: FAIL),
+   * and why almost every desktop answers 8.
+   */
+  hostDeviceMemory() {
+    const gib = os.totalmem() / (1024 ** 3);
+    if (!(gib > 0)) return 8;
+    return Math.min(8, Math.max(0.25, 2 ** Math.round(Math.log2(gib))));
+  }
+
   /**
    * Map the chosen OS to its navigator.platform value so it stays consistent
    * with the user-agent and sec-ch-ua-platform header.
@@ -1249,17 +1652,67 @@ export class StealthBrowserManager {
    * Apply advanced stealth configurations to browser context
    */
   async applyAdvancedStealthConfigurations(context, config, fingerprint) {
+    // Nothing is injected into camoufox.
+    //
+    // Every script below is Chromium-shaped — it patches navigator.webdriver,
+    // installs a window.chrome, and patches getContext, AudioContext and font
+    // metrics from the main world. camoufox does all of that in its own
+    // C++/Juggler layer, where there is no JS seam to find, and a page that
+    // compares property descriptors, Function.prototype.toString output or the
+    // main thread against a Worker sees ours and not camoufox's. Injecting on
+    // top of an engine built to need no injection only adds back the tells the
+    // engine was chosen to avoid.
+    //
+    // This does not clear deviceandbrowserinfo.com's hasInconsistentWorkerValues
+    // on camoufox: that flag stayed set with every one of these disabled, so it
+    // is camoufox's own worker leak, not ours. What it removes is our share.
+    if (this._launchedEngine === 'camoufox') {
+      return;
+    }
+
     // Enhanced initialization script with comprehensive stealth measures
-    await context.addInitScript((locale) => {
-      // Remove webdriver property completely
-      Object.defineProperty(navigator, 'webdriver', {
-        get: () => undefined,
-        configurable: true
-      });
+    await context.addInitScript(() => {
+      // Everything this script changes about navigator goes on
+      // Navigator.prototype, never on the navigator instance.
+      //
+      // A real Chrome answers Object.getOwnPropertyNames(navigator) with an
+      // empty array: every property it has is inherited. So one
+      // defineProperty(navigator, …) puts the spoof's own name in a list any
+      // page can print in a line — rebrowser's bot detector prints exactly that
+      // list, and it read ["connection","plugins","mimeTypes","getBattery"]
+      // (2026-09-21 bench). It is the same class of tell as the deleted
+      // webdriver property, one level up.
+      //
+      // A property that is not on the prototype is left alone rather than
+      // invented: a shape that no Chromium has is worse than the real value.
+      const defineOnPrototype = (key, descriptor) => {
+        if (!(key in Navigator.prototype)) return false;
+        try {
+          // WebIDL attributes and operations are both enumerable and
+          // configurable on the prototype; matching that keeps the descriptor
+          // indistinguishable from the one it replaces.
+          Object.defineProperty(Navigator.prototype, key, Object.assign(
+            { configurable: true, enumerable: true }, descriptor
+          ));
+          return true;
+        } catch (e) {
+          return false;
+        }
+      };
+
+      // navigator.webdriver reports false; the property stays. Deleting it was
+      // its own tell — rebrowser's bot detector marks a missing webdriver red,
+      // because every real Chrome has the property and answers false
+      // (2026-09-21 benchmark, navigator-webdriver). The launch flags do this
+      // already (--disable-blink-features=AutomationControlled, and
+      // --enable-automation taken off the default args), so on a normal launch
+      // this is a no-op and the native prototype getter is left untouched; the
+      // redefinition is only for a binary where the flag did not take.
+      if (navigator.webdriver !== false) {
+        defineOnPrototype('webdriver', { get: () => false });
+      }
 
       // Hide automation indicators
-      delete window.navigator.__proto__.webdriver;
-      delete window.navigator.webdriver;
       delete window.webdriver;
       delete window._phantom;
       delete window.__nightmare;
@@ -1284,18 +1737,15 @@ export class StealthBrowserManager {
           originalQuery(parameters)
       );
 
-      // Hide headless indicators. configurable: true because the hardware
-      // spoofing script below redefines this with the fingerprint's own core
-      // count — without it that redefinition throws "Cannot redefine property"
-      // and takes navigator.platform and deviceMemory down with it, so the
-      // page saw a Win32 platform on every persona.
-      Object.defineProperty(navigator, 'hardwareConcurrency', {
-        get: () => 4,
-        configurable: true
-      });
+      // No hardwareConcurrency here, and none anywhere else either: the
+      // fingerprint now carries the host's own core count
+      // (generateHardwareFingerprint), so there is nothing to override. A
+      // defineProperty here only ever reached the document, and the worker
+      // answering with the real count beside it was the mismatch
+      // bot.incolumitas.com scores.
 
       // Spoof connection
-      Object.defineProperty(navigator, 'connection', {
+      defineOnPrototype('connection', {
         get: () => ({
           effectiveType: '4g',
           rtt: 50 + Math.random() * 50,
@@ -1360,7 +1810,7 @@ export class StealthBrowserManager {
           Object.defineProperty(pluginArray, index, { value: plugin, enumerable: true });
           Object.defineProperty(pluginArray, plugin.name, { value: plugin });
         });
-        Object.defineProperty(navigator, 'plugins', { get: () => pluginArray });
+        defineOnPrototype('plugins', { get: () => pluginArray });
 
         // Real Chrome pairs those plugins with two navigator.mimeTypes entries
         // (application/pdf, text/pdf). Five plugins beside an empty mimeTypes
@@ -1379,31 +1829,29 @@ export class StealthBrowserManager {
             Object.defineProperty(mimeTypeArray, index, { value: mimeType, enumerable: true });
             Object.defineProperty(mimeTypeArray, mimeType.type, { value: mimeType });
           });
-          Object.defineProperty(navigator, 'mimeTypes', { get: () => mimeTypeArray });
+          defineOnPrototype('mimeTypes', { get: () => mimeTypeArray });
         }
       }
 
-      // Override languages with the fingerprint's own locale — a hardcoded
-      // en-US here contradicts navigator.language and Accept-Language whenever
-      // the persona is not American.
-      Object.defineProperty(navigator, 'languages', {
-        get: function() {
-          const primary = locale.split('-')[0];
-          return primary === locale ? [locale] : [locale, primary];
-        }
-      });
-
-      // Mock battery API with realistic values
-      Object.defineProperty(navigator, 'getBattery', {
-        get: function() {
-          return function() {
-            return Promise.resolve({
-              charging: true,
-              chargingTime: 0,
-              dischargingTime: Infinity,
-              level: 0.8 + Math.random() * 0.19 // 80-99%
-            });
-          };
+      // No languages here either. The persona's language list is handed to
+      // Chromium as the accept-language override in _applyEmulatedIdentity, so
+      // the document and every worker parse the same list; this defineProperty
+      // reached only the document, and the worker's ["en-US"] against the
+      // document's ["en-US", "en"] was the difference the benchmark measured
+      // (2026-09-21, worker-languages).
+
+      // Mock battery API with realistic values. A data property, not an
+      // accessor: getBattery is a WebIDL operation, so on a real Navigator
+      // prototype it is a writable function value and not a getter.
+      defineOnPrototype('getBattery', {
+        writable: true,
+        value: function getBattery() {
+          return Promise.resolve({
+            charging: true,
+            chargingTime: 0,
+            dischargingTime: Infinity,
+            level: 0.8 + Math.random() * 0.19 // 80-99%
+          });
         }
       });
 
@@ -1435,7 +1883,7 @@ export class StealthBrowserManager {
           return originalPrepareStackTrace.call(this, error, filteredStack);
         };
       }
-    }, fingerprint.locale || config.locale || 'en-US');
+    });
 
     // WebRTC leak prevention with advanced spoofing
     if (config.blockWebRTC) {
@@ -1609,48 +2057,56 @@ export class StealthBrowserManager {
       }, fingerprint.mediaDevices);
     }
 
-    // Hardware spoofing
-    if (config.fingerprinting?.hardwareSpoofing) {
+    // Hardware. Nothing is defined onto the document's navigator any more.
+    // hardwareConcurrency and deviceMemory are the host's own values
+    // (generateHardwareFingerprint), so there is nothing left to override — a
+    // defineProperty that sets a property to the value it already has is a JS
+    // seam bought for nothing. platform is set through CDP
+    // (_applyEmulatedIdentity), and with the persona OS taken from the host it
+    // is usually the truth as well.
+    //
+    // Init scripts never run inside a dedicated Worker, so a detector that
+    // compares navigator in a worker with the main thread saw the real
+    // platform, deviceMemory and hardwareConcurrency beside the spoofed
+    // ones (bot.incolumitas.com "inconsistentWebWorkerNavigatorPropery",
+    // R17 2026-09-04). At the advanced level, classic workers start from a
+    // blob that patches WorkerNavigator and then importScripts() the real
+    // script; relative importScripts/fetch inside such a worker resolve
+    // against the original script URL. Module workers, data:/blob: worker
+    // URLs and a CSP that refuses blob workers fall through to the native
+    // constructor untouched. (camoufox never reaches here — this whole method
+    // returns early for it.)
+    //
+    // MEASURED COVERAGE, 2026-09-16, chromium, comparing a worker's navigator
+    // with the main thread's:
+    //
+    //   level      new Worker('/w.js')   new Worker(blob:)
+    //   medium     leaks all four        leaks all four
+    //   advanced   matches               leaks all four
+    //
+    // The four are platform, hardwareConcurrency, deviceMemory and languages.
+    // So a detector that builds its worker from a Blob — which needs no second
+    // request and is the usual shape — read straight past this at every level.
+    //
+    // THE CALL, taken 2026-09-21: stop drawing what a worker can contradict.
+    // hardwareConcurrency and deviceMemory are the host's own values now, and
+    // languages comes from the context locale, which Playwright applies to the
+    // worker as well as the document — all three agree without a wrapper.
+    // That leaves platform, and only for a caller who pins a customUserAgent
+    // from another OS: the persona's OS is otherwise the host's, so the spoofed
+    // platform IS the real one and the wrapper would rewrite every worker
+    // source on the page to change nothing. Hence the guard — the surface is
+    // paid for only when it buys something. WebGL's unmasked vendor/renderer is
+    // still window-only and still leaks in a worker.
+    const hostPlatform = this.selectRealisticPlatform(this.hostOS());
+    if (config.fingerprinting?.hardwareSpoofing
+        && config.level === 'advanced'
+        && fingerprint.hardware.platform !== hostPlatform) {
       await context.addInitScript((hardware) => {
-        Object.defineProperty(navigator, 'hardwareConcurrency', {
-          get: () => hardware.hardwareConcurrency
-        });
-        
-        Object.defineProperty(navigator, 'platform', {
-          get: () => hardware.platform
-        });
-        
-        if (navigator.deviceMemory !== undefined) {
-          Object.defineProperty(navigator, 'deviceMemory', {
-            get: () => hardware.deviceMemory
-          });
-        }
-      }, fingerprint.hardware);
-
-      // Init scripts never run inside a dedicated Worker, so a detector that
-      // compares navigator in a worker with the main thread saw the real
-      // platform, deviceMemory and hardwareConcurrency beside the spoofed
-      // ones (bot.incolumitas.com "inconsistentWebWorkerNavigatorPropery",
-      // R17 2026-09-04). At the advanced level, classic workers start from a
-      // blob that patches WorkerNavigator and then importScripts() the real
-      // script; relative importScripts/fetch inside such a worker resolve
-      // against the original script URL. Module workers, data:/blob: worker
-      // URLs and a CSP that refuses blob workers fall through to the native
-      // constructor untouched. camoufox spoofs workers itself.
-      if (config.level === 'advanced' && this._launchedEngine !== 'camoufox') {
-        await context.addInitScript(({ hardware, locale }) => {
-          const NativeWorker = window.Worker;
-          if (typeof NativeWorker !== 'function') return;
-          const primary = locale.split('-')[0];
-          const languages = primary === locale ? [locale] : [locale, primary];
-          const spoof = JSON.stringify({
-            hardwareConcurrency: hardware.hardwareConcurrency,
-            platform: hardware.platform,
-            deviceMemory: hardware.deviceMemory,
-            languages,
-            language: locale
-          });
-          const prelude = (scriptUrl) =>
+        const NativeWorker = window.Worker;
+        if (typeof NativeWorker !== 'function') return;
+        const spoof = JSON.stringify({ platform: hardware.platform });
+        const prelude = (scriptUrl) =>
             `(() => {
               const spoof = ${spoof};
               const proto = self.WorkerNavigator && self.WorkerNavigator.prototype;
@@ -1658,11 +2114,7 @@ export class StealthBrowserManager {
                 try { Object.defineProperty(proto, key, { get: () => value, configurable: true }); } catch (e) {}
               };
               if (proto) {
-                define('hardwareConcurrency', spoof.hardwareConcurrency);
                 define('platform', spoof.platform);
-                if ('deviceMemory' in self.navigator) define('deviceMemory', spoof.deviceMemory);
-                define('languages', spoof.languages);
-                define('language', spoof.language);
               }
               const base = ${JSON.stringify(scriptUrl)};
               const resolve = (u) => { try { return new URL(String(u), base).href; } catch (e) { return u; } };
@@ -1680,25 +2132,24 @@ export class StealthBrowserManager {
               }
             })();
             importScripts(${JSON.stringify(scriptUrl)});`;
-          const Wrapped = function Worker(scriptURL, options) {
-            try {
-              const isModule = options && options.type === 'module';
-              const absolute = new URL(String(scriptURL), location.href).href;
-              if (!isModule && /^https?:/.test(absolute)) {
-                const blob = new Blob([prelude(absolute)], { type: 'text/javascript' });
-                return new NativeWorker(URL.createObjectURL(blob), options);
-              }
-            } catch (e) {
-              // CSP refused the blob URL or the URL failed to parse: native worker.
+        const Wrapped = function Worker(scriptURL, options) {
+          try {
+            const isModule = options && options.type === 'module';
+            const absolute = new URL(String(scriptURL), location.href).href;
+            if (!isModule && /^https?:/.test(absolute)) {
+              const blob = new Blob([prelude(absolute)], { type: 'text/javascript' });
+              return new NativeWorker(URL.createObjectURL(blob), options);
             }
-            return new NativeWorker(scriptURL, options);
-          };
-          Wrapped.prototype = NativeWorker.prototype;
-          Object.defineProperty(Wrapped, 'name', { value: 'Worker' });
-          Wrapped.toString = () => 'function Worker() { [native code] }';
-          window.Worker = Wrapped;
-        }, { hardware: fingerprint.hardware, locale: config.locale });
-      }
+          } catch (e) {
+            // CSP refused the blob URL or the URL failed to parse: native worker.
+          }
+          return new NativeWorker(scriptURL, options);
+        };
+        Wrapped.prototype = NativeWorker.prototype;
+        Object.defineProperty(Wrapped, 'name', { value: 'Worker' });
+        Wrapped.toString = () => 'function Worker() { [native code] }';
+        window.Worker = Wrapped;
+      }, fingerprint.hardware);
     }
 
     // Font spoofing
@@ -1780,11 +2231,22 @@ export class StealthBrowserManager {
     // Battery API spoofing
     if (config.antiDetection?.spoofBatteryAPI) {
       await context.addInitScript((battery) => {
-        if (navigator.getBattery) {
-          navigator.getBattery = function() {
-            return Promise.resolve(battery);
-          };
-        }
+        // On the prototype, where getBattery natively lives. A plain
+        // `navigator.getBattery = …` assignment makes it an OWN property of the
+        // navigator instance, which is the list rebrowser prints (2026-09-21
+        // bench) — a real Chrome's Object.getOwnPropertyNames(navigator) is
+        // empty.
+        if (!('getBattery' in Navigator.prototype)) return;
+        try {
+          Object.defineProperty(Navigator.prototype, 'getBattery', {
+            configurable: true,
+            enumerable: true,
+            writable: true,
+            value: function getBattery() {
+              return Promise.resolve(battery);
+            }
+          });
+        } catch (e) { /* a build that refuses the redefinition keeps the real one */ }
       }, fingerprint.battery);
     }
   }
@@ -1960,25 +2422,104 @@ export class StealthBrowserManager {
   }
 
   /**
-   * Proxy rotation management
+   * Parse one proxyRotation entry into the { server, username, password } shape
+   * Playwright takes.
+   *
+   * Residential proxies — the only kind that helps against Cloudflare's IP
+   * reputation check — are issued as `http://user:pass@host:port`. Those
+   * credentials are the whole point: the previous code pushed the entry into
+   * `--proxy-server=`, a Chromium flag with nowhere to put them, so every
+   * authenticating proxy answered 407 and the request failed. Splitting them out
+   * here is what lets both engines authenticate.
+   *
+   * A malformed entry throws rather than returning null. A proxy that silently
+   * does not apply is the failure mode this whole path is being fixed for: the
+   * caller believes their traffic is proxied and it is not.
    */
-  async rotateProxy(config) {
-    if (!config.proxyRotation?.enabled || !config.proxyRotation?.proxies?.length) {
+  parseProxyEntry(entry) {
+    if (typeof entry !== 'string' || !entry.trim()) {
+      throw new Error('proxyRotation.proxies entries must be non-empty strings');
+    }
+    const raw = entry.trim();
+    // `host:port` with no scheme parses as protocol "host:" and an empty host,
+    // so give the bare form the http:// every proxy list assumes.
+    const withScheme = /^[a-z][a-z0-9+.-]*:\/\//i.test(raw) ? raw : `http://${raw}`;
+
+    let url;
+    try {
+      url = new URL(withScheme);
+    } catch {
+      throw new Error(`Invalid proxy "${this.redactProxy(raw)}": expected host:port or scheme://user:pass@host:port`);
+    }
+
+    const scheme = url.protocol.replace(':', '').toLowerCase();
+    if (!['http', 'https', 'socks4', 'socks5'].includes(scheme)) {
+      throw new Error(`Invalid proxy scheme "${scheme}": expected http, https, socks4 or socks5`);
+    }
+    if (!url.hostname) {
+      throw new Error(`Invalid proxy "${this.redactProxy(raw)}": no host`);
+    }
+
+    // url.origin is the string "null" for socks4/socks5 — they are not special
+    // schemes — so the server is rebuilt from protocol and host.
+    const proxy = { server: `${url.protocol}//${url.host}` };
+    // A password with a "@" or ":" in it must arrive percent-encoded to parse at
+    // all; the proxy expects the decoded value.
+    if (url.username) proxy.username = decodeURIComponent(url.username);
+    if (url.password) proxy.password = decodeURIComponent(url.password);
+    return proxy;
+  }
+
+  /** A proxy entry with its credentials removed, for logs and get_stats. */
+  redactProxy(entry) {
+    return String(entry).replace(/\/\/[^/@]*@/, '//');
+  }
+
+  /**
+   * Pick the proxy this context should use, advancing the rotation when its
+   * interval has elapsed.
+   *
+   * Called per context rather than per launch. The old call site ran once, at
+   * browser launch, and the browser is cached for the life of the process — so
+   * rotationInterval could never elapse anywhere that mattered and the second
+   * proxy in a list was never reached.
+   */
+  resolveProxy(config) {
+    // The caller's list always wins: a per-call proxyRotation is a deliberate
+    // choice of exit address, and the server-level CRAWLFORGE_STEALTH_PROXIES
+    // is only what this server goes out from when nobody chose one — the
+    // escalation stage, the agent and browser_session have no caller to ask.
+    // Read through the helper on every call, so an operator's list can be set
+    // for a run without restarting the process.
+    const requested = config.proxyRotation?.enabled ? (config.proxyRotation.proxies || []) : [];
+    const proxies = requested.length ? requested : serverStealthProxies();
+    if (!proxies.length) {
       return null;
     }
-    
+    // The server-level list arrives as a bare list with no rotation block of
+    // its own, so it gets the schema's own default interval rather than
+    // comparing against undefined — which is never greater, i.e. never rotates.
+    const rotationInterval = config.proxyRotation?.rotationInterval ?? 300000;
+
     const now = Date.now();
-    const { rotationInterval, proxies } = config.proxyRotation;
-    
-    if (now - this.proxyManager.lastRotation > rotationInterval) {
+    if (this.proxyManager.currentProxy === null) {
+      // First use takes proxies[0]. The old code advanced the index before its
+      // first read, so a single-proxy list worked by wrapping to 0 and every
+      // longer list silently started at the second entry.
+      this.proxyManager.proxyIndex = 0;
+      this.proxyManager.lastRotation = now;
+    } else if (now - this.proxyManager.lastRotation > rotationInterval) {
       this.proxyManager.proxyIndex = (this.proxyManager.proxyIndex + 1) % proxies.length;
-      this.proxyManager.currentProxy = proxies[this.proxyManager.proxyIndex];
       this.proxyManager.lastRotation = now;
-      
-      console.error('Rotated to proxy:', this.proxyManager.currentProxy);
     }
-    
-    return this.proxyManager.currentProxy;
+
+    const entry = proxies[this.proxyManager.proxyIndex % proxies.length];
+    const parsed = this.parseProxyEntry(entry);
+    // Only ever hold the redacted form: getStats() returns currentProxy to the
+    // caller, and these strings carry a password.
+    this.proxyManager.currentProxy = this.redactProxy(entry);
+    this.proxyManager.activeProxies = proxies.map((p) => this.redactProxy(p));
+    return parsed;
   }
 
   /**
@@ -2014,18 +2555,27 @@ export class StealthBrowserManager {
    *
    * @param {Object} params
    * @param {string} params.url                 — URL to scrape
-   * @param {string} [params.engine]            — browser engine (forwarded to config; playwright by default)
+   * @param {string} [params.engine]            — browser engine (forwarded to config; 'auto' by default, i.e. camoufox when installed)
    * @param {number} [params.wait_for]          — extra wait after load, in ms
    * @param {boolean} [params.screenshot]       — capture a base64 PNG screenshot
    * @param {Object} [params.stealthConfig]     — stealth configuration overrides
-   * @returns {Promise<{success:boolean, url:string, title:string, text:string, html:string, screenshot:?string}>}
+   * @returns {Promise<{success:boolean, url:string, title:string, text:string, html:string, screenshot:?string, engine:?string, warnings:string[]}>}
+   *   `engine` is the one that actually ran and `warnings` carries the
+   *   'auto'→chromium downgrade, so the caller can report it.
    */
   /**
-   * If the document is a self-solving bot-wall interstitial (its title is a
-   * known challenge title), wait up to timeoutMs for the title to change —
-   * the challenge script navigates to the real page when it passes — and for
-   * that navigation to reach domcontentloaded. A challenge that never passes
-   * is left to challengeDetection to report as blocked.
+   * If the document is a self-solving bot-wall interstitial, wait up to
+   * timeoutMs for the title to change — the challenge script navigates to the
+   * real page when it passes — and for that navigation to reach
+   * domcontentloaded. A challenge that never passes is left to
+   * challengeDetection to report as blocked.
+   *
+   * The trigger is looksLikeInterstitial, not a known title: nowsecure.nl's
+   * interstitial is titled "nowsecure.nl", so a title-only test skipped the
+   * wait entirely and the block verdict fired on a challenge that had not been
+   * given its chance to solve itself (2026-09-21 benchmark, section 2.2). That
+   * costs one page.content() per call, which is what reading the challenge
+   * bootstrap out of the document takes.
    */
   /**
    * A document with no title and no text right after domcontentloaded is
@@ -2056,6 +2606,80 @@ export class StealthBrowserManager {
     return Date.now() - started;
   }
 
+  /**
+   * Give the page the chance to finish rendering before it is read.
+   *
+   * Navigation returns at DOMContentLoaded, and everything before this only
+   * waits for the document to become non-empty (_waitOutEmptyDocument) or to
+   * stop being an interstitial (_waitOutChallenge). A page that already has
+   * prose and writes the part the caller came for in a load handler passed all
+   * of those as finished, and the read landed mid-render.
+   *
+   * The 6.6.2 bench recorded that as a format bug — "markdown silently dropped
+   * the verdict, text captured it" — but its two calls were two page loads and
+   * only one of them raced. One call asking for markdown and text returns the
+   * same content in both, because both are built from one render. The defect
+   * was the timing.
+   *
+   * Two bounded waits: the page's own load event, then quiet in the DOM. What
+   * this cannot do is predict a payload injected into a still page some
+   * arbitrary time later — that is what the caller's `wait_for` is for.
+   *
+   * @returns {Promise<number>} milliseconds actually waited, 0 for a page that
+   *   was already finished.
+   */
+  async _settleRender(page, { loadTimeoutMs = 3000, quietMs = 400, capMs = 2500 } = {}) {
+    const started = Date.now();
+    // Subresources are often what the render waits on. Bounded, because a page
+    // with a hanging tracker request never fires load at all.
+    await page.waitForLoadState('load', { timeout: loadTimeoutMs }).catch(() => {});
+    const loadMs = Date.now() - started;
+    return loadMs + await this._settleDom(page, { quietMs, capMs });
+  }
+
+  /**
+   * Resolve once the DOM has been unchanged for `quietMs`, or at `capMs`.
+   *
+   * A MutationObserver in the page, so this is one round trip and returns
+   * immediately on a page that was already still. The cap bounds a page that
+   * never stops animating.
+   *
+   * @returns {Promise<number>} milliseconds the DOM went on changing for — 0
+   *   when the page was already still, so a settled page reports no extra wait.
+   */
+  async _settleDom(page, { quietMs = 400, capMs = 2500 } = {}) {
+    try {
+      return await page.evaluate(({ quiet, cap }) => new Promise((resolve) => {
+        if (!document.documentElement) {
+          resolve(0);
+          return;
+        }
+        const started = Date.now();
+        let quietTimer;
+        const finish = () => {
+          observer.disconnect();
+          clearTimeout(quietTimer);
+          clearTimeout(capTimer);
+          // Subtract the quiet window itself: what is worth reporting is how
+          // long the page kept changing, not the time spent confirming it had
+          // stopped.
+          resolve(Math.max(0, Date.now() - started - quiet));
+        };
+        const observer = new MutationObserver(() => {
+          clearTimeout(quietTimer);
+          quietTimer = setTimeout(finish, quiet);
+        });
+        const capTimer = setTimeout(finish, cap);
+        quietTimer = setTimeout(finish, quiet);
+        observer.observe(document.documentElement, { childList: true, subtree: true, characterData: true });
+      }), { quiet: quietMs, cap: capMs });
+    } catch {
+      // Navigated away, closed or crashed mid-settle. The read that follows
+      // reports that properly; there is nothing to add here.
+      return 0;
+    }
+  }
+
   async _waitOutChallenge(page, { timeoutMs = 8000 } = {}) {
     let title;
     try {
@@ -2063,7 +2687,15 @@ export class StealthBrowserManager {
     } catch {
       return;
     }
-    if (!detectChallengePage({ title })) return;
+    // A page that is navigating — which a challenge that has just solved itself
+    // is — can answer title() and still refuse content(). Falling back to the
+    // title-only decision keeps a known interstitial waited on; only the marker
+    // branch, and with it the custom-titled wall, is lost for that call.
+    let html = '';
+    try {
+      html = await page.content();
+    } catch { /* title-only decision */ }
+    if (!looksLikeInterstitial({ title, html })) return;
     await page
       .waitForFunction((t) => document.title !== t, title, { timeout: timeoutMs })
       .catch(() => {});
@@ -2073,7 +2705,12 @@ export class StealthBrowserManager {
   async scrapeWithStealth({ url, engine, wait_for = 0, screenshot = false, stealthConfig = {} } = {}) {
     if (!url) throw new Error('scrapeWithStealth requires a url');
 
-    const { contextId } = await this.createStealthContext({ ...stealthConfig, engine });
+    const { contextId, engineFallbackWarning = null } = await this.createStealthContext({ ...stealthConfig, engine });
+    // What ran, not what was asked for: 'auto' becomes chromium when camoufox
+    // is absent, and a result that says the stealth browser did not get the
+    // page has to name the browser that tried.
+    const engineUsed = this._launchedEngine ?? null;
+    const warnings = engineFallbackWarning ? [engineFallbackWarning] : [];
     try {
       const page = await this.createStealthPage(contextId);
       let crashed = false;
@@ -2100,7 +2737,13 @@ export class StealthBrowserManager {
       // up, so the interstitial came back as success:true (R17, 2026-09-04).
       // An auto-solving challenge gets one bounded wait to finish first.
       await this._waitOutChallenge(page);
-      const gracedMs = await this._waitOutEmptyDocument(page);
+      const emptyGraceMs = await this._waitOutEmptyDocument(page);
+      // Last: let whatever is still rendering finish. Without this the read
+      // below can land between "the page has content" and "the page has the
+      // content the caller came for", and a half-rendered page is returned as
+      // a successful scrape.
+      const renderMs = await this._settleRender(page);
+      const gracedMs = emptyGraceMs + renderMs;
 
       // A failure to read the document is a failure. With every read wrapped
       // in .catch(() => ''), a renderer that crashed or a page closed during
@@ -2127,47 +2770,140 @@ export class StealthBrowserManager {
         ? await page.screenshot({ encoding: 'base64', fullPage: false }).catch(() => null)
         : null;
 
-      return { success: true, url, title, text, html, screenshot: shot, status, gracedMs };
+      return { success: true, url, title, text, html, screenshot: shot, status, gracedMs, engine: engineUsed, warnings };
     } finally {
       await this.closeContext(contextId).catch(() => {});
     }
   }
 
   /**
-   * Whether a request is dropped before it leaves the browser. Only the
-   * advanced level sheds assets, never by URL and never the document itself.
+   * Whether a request is dropped before it leaves the browser. Nothing is, at
+   * any level, which is why applyPageStealthMeasures routes no page at all —
+   * this is the one place that answers the question, and the answer is the
+   * reason the interception is gone.
    * @param {string} resourceType - Playwright's request.resourceType()
    * @param {string} level - stealth level
    * @returns {boolean}
    */
-  static shouldAbortRequest(resourceType, level) {
-    if (level !== 'advanced') return false;
-    if (!['image', 'font', 'stylesheet'].includes(resourceType)) return false;
-    // Allow some images/fonts to maintain realism
-    return Math.random() >= 0.3;
+  static shouldAbortRequest(_resourceType, _level) {
+    return false;
+  }
+
+  /**
+   * The full user-agent client-hint metadata for a fingerprint: what Playwright
+   * already derives from the user agent, plus the brand lists it leaves to the
+   * binary. Omitting a field means "fill this in with what you would normally
+   * use", and what a headless Chromium normally uses says HeadlessChrome — in
+   * brands, in fullVersionList, and so in every high-entropy hint a detector
+   * asks for.
+   *
+   * The five derived fields are what playwright-core's own
+   * calculateUserAgentMetadata produces for the three desktop personas this
+   * manager draws — so for every user agent it can hand out, this changes the
+   * brands and nothing else. A mobile persona is out of scope here for the same
+   * reason isMobile is pinned false in generateAdvancedFingerprint: the pool has
+   * no mobile user agent to be coherent with.
+   *
+   * @param {Object} fingerprint
+   * @returns {Object} a CDP Emulation.UserAgentMetadata
+   */
+  generateUserAgentMetadata(fingerprint) {
+    const userAgent = String(fingerprint.userAgent || '');
+    const brands = this.generateUserAgentBrands(userAgent);
+    const brandVersion = brands[brands.length - 1].version;
+    // The four-part build number, but only when it is the binary the brand
+    // version names; a custom UA on another major gets the reduced form rather
+    // than this machine's build under someone else's version.
+    const fullVersion = brandVersion === String(this.chromeMajor)
+      ? this.chromeVersion
+      : `${brandVersion}.0.0.0`;
+    const platformVersions = { windows: '10.0', macos: '10_15_7', linux: '' };
+    const platforms = { windows: 'Windows', macos: 'macOS', linux: 'Linux' };
+    const os = this.inferOSFromUserAgent(userAgent);
+
+    return {
+      brands,
+      fullVersionList: brands.map((brand) => ({ brand: brand.brand, version: fullVersion })),
+      fullVersion,
+      platform: platforms[os],
+      platformVersion: platformVersions[os],
+      architecture: 'x86',
+      model: '',
+      mobile: false
+    };
+  }
+
+  /**
+   * Tell the renderer who it is, instead of patching it from script.
+   *
+   * navigator.userAgent, .platform and .userAgentData were being defined on the
+   * document's navigator by init scripts. An init script does not run in a
+   * Worker, so every one of those values was spoofed in the document and
+   * truthful in the worker beside it — a MacIntel under a Windows persona,
+   * which is what bot.incolumitas.com and CreepJS score (2026-09-21 benchmark,
+   * worker-*). Emulation.setUserAgentOverride is applied by the renderer, and
+   * the brands it carries are the ones the binary would otherwise fill in as
+   * HeadlessChrome.
+   *
+   * `acceptLanguage` is the plain locale tag, the same single value Playwright
+   * gives the context. It is deliberately NOT the two-entry "en-US,en" list:
+   * this override reaches the document only, while a worker's
+   * navigator.languages comes from the context locale, so a second entry here
+   * showed up in the document and nowhere else — the very mismatch the init
+   * script used to create (2026-09-21 benchmark, worker-languages). The
+   * Accept-Language *header* still carries the `en;q=0.9` fallback, from
+   * generateAdvancedHeaders, which is what a real Chrome sends for a
+   * single-locale preference. The field cannot simply be omitted: that clears
+   * the override Playwright installed and a de-DE persona would fall back to
+   * the binary's default.
+   *
+   * Chromium only: CDP does not exist on camoufox's Firefox, which spoofs all
+   * of this in its own engine anyway. A failure here is not fatal — Playwright
+   * has already set the user agent through the context, so the persona survives
+   * without the brands.
+   */
+  async _applyEmulatedIdentity(page, config, fingerprint) {
+    if (!isChromium(page) || !fingerprint.userAgent) return;
+    try {
+      const client = await page.context().newCDPSession(page);
+      await client.send('Emulation.setUserAgentOverride', {
+        userAgent: fingerprint.userAgent,
+        acceptLanguage: fingerprint.locale || config.locale || 'en-US',
+        platform: fingerprint.hardware.platform,
+        userAgentMetadata: this.generateUserAgentMetadata(fingerprint)
+      });
+    } catch (error) {
+      console.warn(`Identity emulation skipped: ${error.message}`);
+    }
   }
 
   /**
    * Apply page-level stealth measures
    */
   async applyPageStealthMeasures(page, config, fingerprint) {
-    // Resource routing. Nothing is aborted by URL any more: the old list
-    // blocked challenges.cloudflare.com and every URL containing "selenium",
-    // "webdriver" or "puppeteer" — the first meant a Cloudflare challenge
-    // could never complete (the interstitial named the blocked host), the
-    // second killed the top-level navigation to www.selenium.dev on every
-    // stealth path (R15, 2026-09-04). A vendor script that never loads is a
-    // louder tell than one that runs.
-    await page.route('**/*', route => {
-      if (StealthBrowserManager.shouldAbortRequest(route.request().resourceType(), config.level)) {
-        route.abort();
-      } else {
-        route.continue();
-      }
-    });
-
-    // Add request headers
-    await page.setExtraHTTPHeaders(fingerprint.headers);
+    // No request routing at all. R15 had already stopped aborting by URL (the
+    // old list blocked challenges.cloudflare.com, so a Cloudflare challenge
+    // could never complete, and killed the navigation to www.selenium.dev);
+    // what was left was the advanced level dropping about a third of images,
+    // fonts and stylesheets at random. Both halves of that are timeable: a page
+    // that renders without the fonts and images it asked for does not look like
+    // a browser reading it, and route('**/*') itself puts every request through
+    // a node round trip, which shows up as latency no network explains
+    // (2026-09-21 review, finding 10). With nothing left to abort there is
+    // nothing for the interception to decide, so the handler is gone rather
+    // than made conditional.
+
+    // Every identity the renderer can be told about directly, rather than
+    // patched into from script.
+    await this._applyEmulatedIdentity(page, config, fingerprint);
+
+    // Add request headers — Chromium only. These carry sec-ch-ua,
+    // sec-ch-ua-mobile and sec-ch-ua-platform, client hints Gecko does not
+    // implement, so setting them here would put them straight back onto a
+    // camoufox page after createStealthContext had taken them off the context.
+    if (isChromium(page)) {
+      await page.setExtraHTTPHeaders(fingerprint.headers);
+    }
 
     // Emulate realistic network conditions.
     //
@@ -2369,6 +3105,7 @@ export class StealthBrowserManager {
       this._parkedBrowsers.clear();
     }
     this._launchedEngine = null;
+    this._engineFallbackWarning = null;
     for (const browser of browsers) {
       const closed = await withDeadline(browser.close(), 5000);
       if (!closed) {
@@ -2541,6 +3278,115 @@ export class CamoufoxAdapter extends BrowserEngine {
     }
   }
 
+  /**
+   * A browserforge fingerprint pinned to the installed binary's Firefox major.
+   *
+   * camoufox@0.1.19 rewrites the persona's version tokens with
+   *
+   *   data.replace(/(?<!\d)(1[0-9]{2})(\.0)(?!\d)/, `${ffVersion}$2`)
+   *
+   * and there is no /g, so only the FIRST match in each string changes. In a
+   * Firefox UA that match is `rv:`, and `Firefox/` keeps whatever version
+   * browserforge drew — the two then agree only by coincidence. Measured on
+   * the installed 135 binary: 4 of 8 launches produced a self-contradicting UA
+   * (`rv:135.0 ... Firefox/150.0`), which is a one-line detection. Generating
+   * the persona ourselves at the binary's own version makes that replace a
+   * no-op and both tokens agree (8/8 measured, end to end through
+   * launchOptions).
+   *
+   * Nothing else is constrained here because camoufox constrains nothing else:
+   * its getScreenCons() returns null on both branches, and its `os` option is
+   * dropped before it reaches the generator (the client sends `os`, the
+   * generator's key is `operatingSystems`). Pinning the OS too would fix that
+   * second bug, but it is Phase 1's documented `persona-os-vs-host` finding and
+   * changing it here would move a baseline this change has no business moving.
+   *
+   * @returns {object|null} null when the version cannot be read, or when
+   *   browserforge has no data for it — 152 is outside its set, and silently
+   *   drawing some other version would put us back where we started. The
+   *   caller then lets camoufox generate as it did before.
+   */
+  /** process.platform in the vocabulary fingerprint-generator uses, or null. */
+  static _hostOperatingSystem() {
+    if (process.platform === 'darwin') return 'macos';
+    if (process.platform === 'win32') return 'windows';
+    if (process.platform === 'linux') return 'linux';
+    return null;
+  }
+
+  /** The OS a Firefox UA claims, in the same vocabulary, or null. */
+  static _osFromUserAgent(ua) {
+    if (/Macintosh|Mac OS X/.test(ua)) return 'macos';
+    if (/Windows/.test(ua)) return 'windows';
+    if (/Android/.test(ua)) return null;      // Linux-derived, but not the host OS we mean
+    if (/X11|Linux/.test(ua)) return 'linux';
+    return null;
+  }
+
+  _pinnedFingerprint(camoufox) {
+    try {
+      const raw = fs.readFileSync(path.join(camoufox.INSTALL_DIR, 'version.json'), 'utf8');
+      const major = parseInt(String(JSON.parse(raw).version).split('.')[0], 10);
+      if (!Number.isInteger(major)) return null;
+
+      // Resolved through camoufox's own module path first: fingerprint-generator
+      // is its dependency, not ours, and this guarantees the same copy it feeds
+      // its data to rather than a second one hoisted elsewhere.
+      const here = createRequire(import.meta.url);
+      let load;
+      try {
+        load = createRequire(here.resolve('camoufox'));
+      } catch {
+        load = here;
+      }
+      const { FingerprintGenerator } = load('fingerprint-generator');
+
+      // Verify rather than assume: a generator with no data for a constraint can
+      // still hand back a persona that ignores it, and an unchecked fingerprint
+      // would reintroduce exactly the mismatch this exists to close.
+      const attempt = (operatingSystems) => {
+        const { fingerprint } = new FingerprintGenerator({
+          browsers: [{ name: 'firefox', minVersion: major, maxVersion: major }],
+          ...(operatingSystems ? { operatingSystems } : {})
+        }).getFingerprint();
+        const ua = fingerprint?.navigator?.userAgent ?? '';
+        if (ua.match(/rv:(\d+)/)?.[1] !== String(major)) return null;
+        if (ua.match(/Firefox\/(\d+)/)?.[1] !== String(major)) return null;
+        if (operatingSystems && CamoufoxAdapter._osFromUserAgent(ua) !== operatingSystems[0]) return null;
+        return fingerprint;
+      };
+
+      // `operatingSystems` is the key the client gets wrong — it sends `os`, so
+      // the OS is drawn from market share and a Linux host ships a macOS
+      // persona. Generating here means we can use the right key. Measured on the
+      // hosted box 2026-09-22: persona-os-vs-host failed with a coherent UA
+      // version, which is a contradiction a detector scores on its own.
+      const hostOs = CamoufoxAdapter._hostOperatingSystem();
+      if (hostOs) {
+        try {
+          const matched = attempt([hostOs]);
+          if (matched) return matched;
+        } catch {
+          // An impossible constraint THROWS here rather than returning a
+          // mismatched persona ("No headers based on this input can be
+          // generated"), and browserforge has no Firefox 135 on Linux at all —
+          // measured, and it is the combination the hosted box runs. Letting
+          // that escape would lose the version pin too and put the UA back
+          // where it started, so it falls through to the version-only attempt.
+        }
+      }
+
+      // Fall back to a version-only pin. browserforge may have no data for this
+      // Firefox version on this OS, and a persona that is coherent about its
+      // version still beats one that is coherent about neither.
+      return attempt(null);
+    } catch {
+      // Best effort: a missing version.json or an absent generator is a reason
+      // to fall back to camoufox's own persona, not to fail a launch.
+      return null;
+    }
+  }
+
   async launch(config = {}) {
     let camoufox;
     try {
@@ -2556,14 +3402,80 @@ export class CamoufoxAdapter extends BrowserEngine {
 
     await this._ensureMacOSLayout(camoufox);
 
+    // Before any Firefox page can run: camoufox reports an uncaught page error
+    // with no location, and playwright reads one anyway. See the guard.
+    guardFirefoxPageErrors();
+
     // camoufox's launcher is Camoufox(options) — the package has no launch()
     // export. It resolves the fetched Firefox binary (npx camoufox fetch) and
     // returns a Playwright-compatible Browser. Takes `headless` directly plus
     // passthrough Playwright Firefox launch options.
-    return camoufox.Camoufox({
-      headless: config.headless !== false,
+    //
+    // The snake_case names below are camoufox's own option names. They are the
+    // reason to run this engine at all: camoufox spoofs at the C++/Juggler
+    // level, where a page cannot see the seam, and every one of these was
+    // simply not being passed — camoufox ran with its own features off.
+    const options = {
+      // A string mode ('virtual' — Xvfb) has to reach camoufox as that string.
+      // `config.headless !== false` collapsed it to `true`, which is plain
+      // headless: the one mode 'virtual' exists to avoid. Booleans keep their
+      // old meaning, so an unset headless is still headless.
+      headless: typeof config.headless === 'string' ? config.headless : config.headless !== false,
       ...config.launchOptions
-    });
+    };
+    // A bare `{ server }` is fine here; camoufox normalises both shapes.
+    if (config.proxy) options.proxy = config.proxy;
+    // "windows" | "macos" | "linux", as a plain string — a one-element ARRAY is
+    // ignored and falls back to the random draw. Left unset, camoufox picks one
+    // of the three at random, which is how a Mac ended up claiming Windows.
+    if (config.os) options.os = config.os;
+    // The first listed locale is the one used for the Intl API. camoufox
+    // applies it in its own engine, so navigator.language, Accept-Language and
+    // Intl agree in the document and in every worker. Left unset with geoip on,
+    // camoufox derives it from the proxy's exit IP instead.
+    if (config.locale) options.locale = config.locale;
+    // geoip derives longitude, latitude, timezone, country and locale from the
+    // proxy's exit IP, which is the one thing that makes a proxied browser
+    // coherent. It costs a request through the proxy, and the first ever call
+    // downloads MaxMind's city database (~60 MB) into camoufox's install dir.
+    if (config.geoip) options.geoip = true;
+    // Blocking WebRTC is itself a signal. With geoip camoufox instead reports
+    // the proxy's exit IP through WebRTC, which is the coherent answer — so
+    // `blockWebRTC: false` is the stealthier setting behind a proxy.
+    if (config.blockWebRTC) options.block_webrtc = true;
+    // Native cursor humanization: camoufox moves the pointer along a plausible
+    // path rather than teleporting it.
+    if (config.humanize) options.humanize = true;
+    // Pin the persona to the installed binary's Firefox major so the UA's two
+    // version tokens agree. Left unpinned, camoufox's own version rewrite
+    // reaches only `rv:` and about half of all launches announce a Firefox
+    // that is not the one running — see _pinnedFingerprint.
+    const fingerprint = this._pinnedFingerprint(camoufox);
+    if (fingerprint) {
+      options.fingerprint = fingerprint;
+      // Switches off exactly two things: camoufox's "you passed your own
+      // fingerprint" advisory, and its non-Firefox fingerprint check, which is
+      // satisfied by construction — the generator above is Firefox-only. The
+      // other options this flag gates (ff_version, block_images, disable_coop,
+      // block_webgl) are ones this adapter never sets, so nothing else is
+      // silenced.
+      options.i_know_what_im_doing = true;
+    }
+
+    try {
+      return await camoufox.Camoufox(options);
+    } catch (err) {
+      if (options.geoip) {
+        // Do not quietly retry without geoip. A proxied camoufox whose
+        // geolocation says one country while its exit IP says another is a
+        // cleaner detection signal than an unproxied one.
+        throw new Error(
+          `camoufox failed to launch with geoip through the configured proxy: ${err.message}. ` +
+          'Check the proxy credentials and that the proxy can reach the internet.'
+        );
+      }
+      throw err;
+    }
   }
 
   /**