jumpy-lion 0.1.6-beta.9 → 1.0.0-beta.4

package/dist/browser-process/anti-detect-config.js

@@ -1,28 +1,68 @@
 /**
- * anti-detect-config.ts — Generate and manage FingerprintConfig JSON for the anti-detect browser
+ * anti-detect-config.ts - Generate and manage FingerprintConfig JSON for the anti-detect browser
  *
  * Called by browser.ts before launching the browser when useNativeStealth is enabled.
  * Translates the fingerprint-generator BrowserFingerprintWithHeaders output into
- * the --fingerprint-config JSON schema consumed by the C++ FingerprintConfig class.
+ * the --blink-platform-overrides-file JSON schema consumed by the C++ override singleton.
  */
+import crypto from 'crypto';
 import fs from 'fs/promises';
 import os from 'os';
 import path from 'path';
-import crypto from 'crypto';
+import { log } from 'crawlee';
+import { deriveWebglFamilyProfile } from './gpu-family-profiles.js';
+import { deriveRealisticDeviceMemory, deriveStorageQuota, normalizePlatformVersion, } from '../fingerprinting/hardware-realism.js';
+import { alignBrandList } from '../fingerprinting/ua-ch-brands.js';
+// ─── Helpers ──────────────────────────────────────────────────────────────────
+/**
+ * Pick deterministic, plausible navigator.connection values for a given session.
+ * Real residential broadband: rtt 25-150ms (Chrome rounds to 25ms steps),
+ * downlink 5-50 Mbps. Datacenters report rtt<5ms and downlink>500 Mbps which
+ * is an obvious bot signal. Same seed → same values, so a Mac harvest and a
+ * Linux-Docker-spoof harvest produce identical readouts.
+ */
+function deriveNetwork(seed) {
+    // rtt in [50, 150] ms, in 25ms steps (so 50, 75, 100, 125, 150).
+    const rttSteps = [50, 75, 100, 125, 150];
+    const rttIdx = (seed >>> 16) % rttSteps.length;
+    const rtt = rttSteps[rttIdx];
+    // downlink in [5, 25] Mbps, rounded to one decimal - Chrome rounds to ~1.5
+    // significant figures. Use a stable hash of the seed so the choice is
+    // reproducible.
+    const downlinkBucket = (seed >>> 24) & 0xFF; // 0..255
+    const downlink = Math.round((5 + (downlinkBucket / 255) * 20) * 10) / 10;
+    return { rtt, downlink, effectiveType: '4g', saveData: false };
+}
+/**
+ * Pick the AudioContext sampleRate the claimed machine's output runs at.
+ * Pinning it here makes the JS-visible value match the OS we claim rather than
+ * the container we run in.
+ */
+function deriveAudioSampleRate(platform) {
+    // 48000 everywhere, including Mac. This used to return 44100 for Mac on the
+    // widely-repeated "CoreAudio defaults to 44.1 kHz" claim, which is stale:
+    // measured 2026-08-12 against real Google Chrome 151.0.7922.108 on macOS
+    // 26.5.2 (M4 Pro), `new AudioContext().sampleRate` is 48000. Apple Silicon
+    // Macs run their built-in output at 48 kHz; 44100 is an Intel-era value.
+    //
+    // The old branch did not merely miss - it was actively harmful. A Linux
+    // container's default output reports 44100, so forcing 44100 under a Mac
+    // claim PRESERVED the container's value and moved the session away from the
+    // Mac it claims to be. Doing nothing would have been closer.
+    //
+    // Non-Mac claims land on 48000 too (WASAPI and PulseAudio both default
+    // there), so the platform argument no longer changes the answer; it stays in
+    // the signature because an Intel-Mac measurement could reintroduce a branch.
+    void platform;
+    return 48000;
+}
 // ─── Generation ───────────────────────────────────────────────────────────────
 /**
- * Generate a FingerprintConfig JSON object from fingerprint-generator output.
- *
- * @param fingerprint - BrowserFingerprintWithHeaders from fingerprint-generator
- * @param sessionId - Session identifier used to derive the seed (proxy session ID, etc.)
- * @param resolvedLocale - Pre-resolved locale/languages/timezone triple. When provided,
- *   these values win over anything derived from fingerprint-generator headers so that a
- *   user-supplied `locale: 'ko-KR'` coherently propagates to every locale surface
- *   (Accept-Language, navigator.language, Intl defaults, timezone).
+ * Derive the 53-bit session seed from the proxy session tag (or a per-process
+ * random source when none is supplied) and the UA. See `generateFingerprintConfig`
+ * for the determinism rationale.
  */
-export function generateFingerprintConfig(fingerprint, sessionId, resolvedLocale) {
-    const fp = fingerprint.fingerprint;
-    const headers = fingerprint.headers;
+function deriveSeed(sessionId, userAgent) {
     // Seed derivation:
     //   - With a sessionId (proxy session tag) → deterministic: same session ID
     //     always yields the same seed so cookies/IP/canvas/audio stay coherent
@@ -31,20 +71,25 @@ export function generateFingerprintConfig(fingerprint, sessionId, resolvedLocale
     //     random. Without this, the fingerprint-generator macOS/Chrome pool
     //     emits exactly one UA across many runs, so sessionId-less calls would
     //     all produce the same seed and therefore the same canvas/audio noise
-    //     hash across every session — a cross-session correlation signal.
+    //     hash across every session - a cross-session correlation signal.
     const seedSource = sessionId
-        ? `${sessionId}|${fp.navigator?.userAgent ?? ''}`
-        : `${crypto.randomBytes(16).toString('hex')}|${fp.navigator?.userAgent ?? ''}`;
+        ? `${sessionId}|${userAgent}`
+        : `${crypto.randomBytes(16).toString('hex')}|${userAgent}`;
     const seedHash = crypto.createHash('sha256').update(seedSource).digest();
     // Take first 8 bytes as a number (JavaScript number precision is sufficient for 53-bit ints)
-    const seed = seedHash.readUInt32BE(0) * 0x100000000 + seedHash.readUInt32BE(4);
-    // Navigator platform
+    return seedHash.readUInt32BE(0) * 0x100000000 + seedHash.readUInt32BE(4);
+}
+/**
+ * Build the navigator surface: legacy + UA-CH platform split, UA-CH brands,
+ * user agent, deviceMemory resampling, and storage-quota pinning. Pure.
+ */
+function buildNavigatorSurface(fp, headers, seed, locale) {
     // navigator.platform (legacy) and navigator.userAgentData.platform (UA-CH)
     // are DIFFERENT APIs with DIFFERENT values:
     //   navigator.platform                  → 'MacIntel' | 'Win32' | 'Linux x86_64'
     //   navigator.userAgentData.platform    → 'macOS'    | 'Windows' | 'Linux'
     // Previously this code collapsed both to the UA-CH form, which made
-    // navigator.platform report "macOS" in both the main frame and workers —
+    // navigator.platform report "macOS" in both the main frame and workers -
     // that is a Chrome invariant violation (real Chrome always returns
     // "MacIntel" from navigator.platform regardless of architecture).
     //
@@ -59,103 +104,385 @@ export function generateFingerprintConfig(fingerprint, sessionId, resolvedLocale
         'Linux x86_64': 'Linux',
     };
     const uaChPlatform = legacyToUaCH[platform] ?? platform;
-    // UA-CH brands from fingerprint
+    // User agent from headers (most accurate source)
+    const userAgent = headers['user-agent']
+        ?? fp.navigator?.userAgent
+        ?? '';
+    // UA-CH brands from fingerprint. Rebuilt rather than copied: Chromium
+    // derives the GREASE token, its fake version and the ORDER of the
+    // three-entry list from the major alone (see ua-ch-brands.ts). Pool
+    // profiles occasionally carry a GREASE token harvested from a different
+    // major, and `alignFingerprintConfigWithBinary` only runs when the binary
+    // version can be read - so the C++ FingerprintConfig has to be coherent at
+    // construction, or the binary faithfully emits a `sec-ch-ua` no Chromium
+    // ever sent (challenge-free HTTP 418 on Naver - issue #131).
     const uaData = fp.navigator?.userAgentData;
     const brands = uaData?.brands ?? [];
-    const fullVersionList = uaData?.fullVersionList ?? brands;
-    const uaBrands = brands.map((b, i) => ({
+    // Same rule on the native path: UA-CH carries the real build even though UA
+    // Reduction froze the UA string to MAJOR.0.0.0, so the UA is the LAST resort
+    // for this value. `alignFingerprintConfigWithBinary` normally replaces it
+    // with the binary's own build; when the version probe failed AND the profile
+    // has no build number, the config would emit "147.0.0.0" in
+    // sec-ch-ua-full-version(-list) - a shape no Chrome sends (issue #131).
+    const uaFullVersion = uaData?.uaFullVersion ?? extractFullVersion(userAgent);
+    if (/^\d+\.0\.0\.0$/.test(uaFullVersion)) {
+        log.warning('[AntiDetect] Profile has no UA-CH build version; falling back to the UA-reduced '
+            + 'MAJOR.0.0.0 shape. Origins that request high-entropy hints reject it - the binary '
+            + 'version probe must succeed for alignFingerprintConfigWithBinary to repair this.', { uaFullVersion });
+    }
+    const majorBrands = alignBrandList(brands, uaFullVersion.split('.')[0]);
+    const fullBrands = alignBrandList(brands, uaFullVersion);
+    const uaBrands = brands.length === 0 ? [] : majorBrands.map((b, i) => ({
         brand: b.brand,
         version: b.version,
-        full_version: fullVersionList[i]?.version ?? b.version,
+        full_version: fullBrands[i]?.version ?? b.version,
     }));
+    const brandName = extractBrandName(uaBrands, userAgent);
+    // deviceMemory: the W3C 2018 spec defined {0.25, 0.5, 1, 2, 4, 8} buckets,
+    // but real Chrome 147 on desktop now returns the raw host RAM in GB
+    // (verified by harvest 2026-05-11: 32 GB Apple Silicon Mac reports
+    // `navigator.deviceMemory === 32`). Reporting the legacy spec-bucketed 8
+    // is now a population minority (<15% of real Mac traffic) and an
+    // instant detection vector. Sample from a realistic 2026 Mac RAM
+    // distribution (8/16/24/32/48/64/128 GB), keyed off the session seed
+    // so Mac-on-Mac and Mac-on-Linux runs of the same seed agree.
+    const rawDeviceMemory = fp.navigator?.deviceMemory ?? 8;
+    const deviceMemory = deriveRealisticDeviceMemory(seed, rawDeviceMemory);
+    // navigator.storage.estimate().quota - pinned per-session so the same profile
+    // reports the same quota on Mac and Linux (without this, real disk leaks
+    // through). Derived from seed+deviceMemory to land in a plausible Mac-SSD
+    // distribution: 8 GB RAM ↔ 256/512 GB SSD, 16 GB ↔ 512/1024 GB, 24/32 GB ↔
+    // 1024/2048 GB. Chrome's StorageManager normally reports ~60% of total disk
+    // space; we mirror that range with ±10% seed-driven jitter so different
+    // profiles get different (but plausible) values.
+    const storageQuota = deriveStorageQuota(seed, deviceMemory);
+    const navigator = {
+        platform, // legacy form: 'MacIntel' | 'Win32' | 'Linux x86_64'
+        ...(locale.language && { language: locale.language }),
+        ...(locale.languages && { languages: locale.languages }),
+        hardwareConcurrency: fp.navigator?.hardwareConcurrency ?? 8,
+        deviceMemory,
+        storageQuota,
+        userAgent,
+        ...(uaBrands.length > 0 && {
+            userAgentData: {
+                brands: uaBrands,
+                mobile: uaData?.mobile ?? false,
+                platform: uaData?.platform ?? uaChPlatform,
+                platformVersion: normalizePlatformVersion(platform, uaData?.platformVersion, seed),
+                architecture: uaData?.architecture ?? 'x86',
+                bitness: uaData?.bitness ?? '64',
+                model: uaData?.model ?? '',
+                uaFullVersion,
+                fullVersionList: uaBrands,
+            },
+        }),
+    };
+    return { navigator, brandName, uaChPlatform, platform };
+}
+/**
+ * Build the WebGL surface: vendor/renderer passthrough, family classification,
+ * texture-size cap matched to the renderer, and the per-family pname block. Pure.
+ */
+function buildWebglSurface(fp) {
     // WebGL from fingerprint. Real Chrome 147 on Apple Silicon leaks the
     // exact chip variant verbatim ("ANGLE (Apple, ANGLE Metal Renderer:
     // Apple M4 Pro, Unspecified Version)"), confirmed against a user's
     // shipping Chrome + CreepJS verdict. Matching that behavior is safer than
-    // sanitizing to a generic M1 — anti-bot ML models expect the raw string,
+    // sanitizing to a generic M1 - anti-bot ML models expect the raw string,
     // and the hardware leak is not a Chrome-level invariant violation.
     const videoCard = fp.videoCard;
     const webglVendor = videoCard?.vendor ?? 'Google Inc. (NVIDIA)';
     const webglRenderer = videoCard?.renderer
         ?? 'ANGLE (NVIDIA, NVIDIA GeForce RTX 3060 Direct3D11 vs_5_0 ps_5_0, D3D11)';
-    // Screen
+    // GL_MAX_TEXTURE_SIZE override. SwiftShader (--use-angle=swiftshader) returns
+    // 8192; real Apple Silicon (Metal), modern NVIDIA / AMD discrete GPUs, and
+    // most Intel iGPUs return 16384. Pair the spoofed renderer with its real
+    // texture-size cap; mismatch is an instant CreepJS catch.
+    //
+    // M1 - also classify the renderer into a GPU family (apple_metal,
+    // linux_mesa_*, windows_d3d_*) so we can populate the rest of the
+    // platform-divergent WebGL pnames (max_draw_buffers, aliased_*_range, ...)
+    // from the per-family PLATFORM_GPU_TABLE. The C++ binary ignores the new
+    // keys until M2 lands the parser additions; once it does, the JSON shape
+    // is already correct.
+    const rendererLower = webglRenderer.toLowerCase();
+    // Thread navigator.platform so an unclassifiable renderer (SwiftShader,
+    // exotic strings) on a known OS falls back to that OS's family params
+    // instead of Apple-Silicon defaults - keeps the param block OS-coherent.
+    const navPlatform = fp.navigator?.platform;
+    const { family: webglFamily, profile: webglFamilyProfile } = deriveWebglFamilyProfile(webglRenderer, navPlatform);
+    const webglMaxTextureSize = (() => {
+        if (/apple|metal|m[123]\b|intel.*iris.*xe|nvidia geforce rtx 40|nvidia geforce rtx 30|nvidia geforce rtx 20|amd radeon (rx [56789]|pro)/i.test(rendererLower)) {
+            return 16384;
+        }
+        if (/nvidia geforce (gtx 1[06]|rtx 50|rtx 60)|amd radeon rx 7|nvidia rtx (a|h)/i.test(rendererLower)) {
+            return 32768; // newest cards / workstation
+        }
+        if (/swiftshader|llvmpipe|mesa offscreen/i.test(rendererLower)) {
+            return 8192; // honest SwiftShader claim
+        }
+        return webglFamilyProfile.maxTextureSize; // family-table default
+    })();
+    const webgl = {
+        vendor: webglVendor,
+        renderer: webglRenderer,
+        maxTextureSize: webglMaxTextureSize,
+        maxViewportDim: webglFamilyProfile.maxViewportDim,
+        extensions: webglFamilyProfile.extensions,
+        ...(webglFamily && { familyHint: webglFamily }),
+        maxDrawBuffers: webglFamilyProfile.maxDrawBuffers,
+        maxSamples: webglFamilyProfile.maxSamples,
+        max3dTextureSize: webglFamilyProfile.max3dTextureSize,
+        maxArrayTextureLayers: webglFamilyProfile.maxArrayTextureLayers,
+        subpixelBits: webglFamilyProfile.subpixelBits,
+        maxTransformFeedbackInterleavedComponents: webglFamilyProfile.maxTransformFeedbackInterleavedComponents,
+        aliasedLineWidthRange: webglFamilyProfile.aliasedLineWidthRange,
+        aliasedPointSizeRange: webglFamilyProfile.aliasedPointSizeRange,
+    };
+    return { webgl, family: webglFamily, vendor: webglVendor };
+}
+/**
+ * The WebGPU adapter surface of a real Apple Silicon Mac, captured from Google
+ * Chrome 151.0.7922.108 on macOS 26.5.2 (M4 Pro), 2026-08-12.
+ *
+ * On a GPU-less container Dawn hands us a SwiftShader adapter, and spoofing only
+ * its vendor/architecture leaves a page reading Apple identity strings against
+ * software-renderer capabilities: 8192 max texture dimension instead of 16384,
+ * 256 compute invocations instead of 1024, subgroups of 4 instead of 32, and a
+ * feature list missing shader-f16 / dual-source-blending / primitive-index /
+ * texture-formats-tier1+2 while carrying two SwiftShader-only entries. Each is a
+ * table lookup away from "this is not an Apple GPU".
+ */
+const APPLE_WEBGPU_ADAPTER = {
+    subgroupMinSize: 32,
+    subgroupMaxSize: 32,
+    features: [
+        'bgra8unorm-storage', 'clip-distances', 'core-features-and-limits', 'depth-clip-control',
+        'depth32float-stencil8', 'dual-source-blending', 'float32-blendable', 'float32-filterable',
+        'indirect-first-instance', 'primitive-index', 'rg11b10ufloat-renderable', 'shader-f16',
+        'subgroups', 'texture-component-swizzle', 'texture-compression-astc',
+        'texture-compression-astc-sliced-3d', 'texture-compression-bc',
+        'texture-compression-bc-sliced-3d', 'texture-compression-etc2', 'texture-formats-tier1',
+        'texture-formats-tier2', 'timestamp-query',
+    ],
+    limits: {
+        maxBufferSize: 4294967292,
+        maxComputeInvocationsPerWorkgroup: 1024,
+        maxComputeWorkgroupSizeX: 1024,
+        maxComputeWorkgroupSizeY: 1024,
+        maxDynamicStorageBuffersPerPipelineLayout: 8,
+        maxDynamicUniformBuffersPerPipelineLayout: 10,
+        maxSampledTexturesPerShaderStage: 48,
+        maxStorageBufferBindingSize: 4294967292,
+        maxStorageTexturesInFragmentStage: 8,
+        maxStorageTexturesInVertexStage: 8,
+        maxStorageTexturesPerShaderStage: 8,
+        maxTextureArrayLayers: 2048,
+        maxTextureDimension1D: 16384,
+        maxTextureDimension2D: 16384,
+        maxVertexAttributes: 30,
+    },
+};
+/** Build the WebGPU surface from explicit fingerprint data or the WebGL vendor. Pure. */
+function buildWebgpuSurface(fp, webglVendor) {
+    // WebGPU - from explicit webgpu field on fingerprint (non-Apify profiles), or
+    // derived from WebGL vendor as a fallback (Apify fingerprints have no webgpu data).
+    const webgpuData = fp.webgpu;
+    const derivedWebGPUVendor = webgpuData?.vendor ?? deriveWebGPUVendorFromWebGL(webglVendor);
+    if (!derivedWebGPUVendor)
+        return undefined;
+    const surface = {
+        vendor: derivedWebGPUVendor,
+        // An Apple vendor with an EMPTY architecture is not what any Mac
+        // reports, and that is what the synthetic pool produces (it carries no
+        // WebGPU data at all, so the vendor is derived from WebGL and the rest
+        // defaults blank). Chrome 151 on Metal-3-capable Apple hardware - every
+        // Apple Silicon Mac on a current macOS - reports metal-3; measured
+        // 2026-08-12 on an M4 Pro.
+        architecture: webgpuData?.architecture
+            || (derivedWebGPUVendor === 'apple' ? 'metal-3' : ''),
+        device: webgpuData?.device ?? '',
+        // Real macOS Chrome reports an EMPTY description. Naming the chip here
+        // would contradict the Mac it claims to be as directly as naming
+        // SwiftShader would.
+        description: webgpuData?.description ?? '',
+    };
+    if (derivedWebGPUVendor === 'apple') {
+        surface.subgroupMinSize = APPLE_WEBGPU_ADAPTER.subgroupMinSize;
+        surface.subgroupMaxSize = APPLE_WEBGPU_ADAPTER.subgroupMaxSize;
+        surface.features = [...APPLE_WEBGPU_ADAPTER.features];
+        surface.limits = { ...APPLE_WEBGPU_ADAPTER.limits };
+    }
+    return surface;
+}
+/** Build the screen surface, keeping it coherent with the claimed platform. Pure. */
+function buildScreenSurface(fp) {
     const screen = fp.screen;
-    // User agent from headers (most accurate source)
-    const userAgent = headers['user-agent']
-        ?? fp.navigator?.userAgent
-        ?? '';
+    const isMac = /Mac/i.test(fp.navigator?.platform ?? '');
+    // colorDepth is NOT capped at 24. The previous cap carried the comment
+    // "real Chrome privacy-reduces to 24 regardless of display HDR capability".
+    // Measured 2026-08-10 against real Google Chrome 151.0.7922.108 on macOS
+    // 26.5.2: it reports 30, on colorDepth and pixelDepth alike. Capping made
+    // it impossible for a profile claiming a modern wide-gamut Mac to report
+    // what such a Mac reports, while every other screen field said Mac.
+    const colorDepth = screen?.colorDepth ?? (isMac ? 30 : 24);
+    // Every Apple Silicon Mac is Retina: devicePixelRatio is 2. A MacIntel
+    // platform with an Apple Metal renderer and devicePixelRatio 1 is a
+    // combination no real machine produces, and it is one line to check.
+    const rawRatio = screen?.devicePixelRatio;
+    const pixelRatio = isMac ? Math.max(rawRatio ?? 2, 2) : (rawRatio ?? 1);
+    // macOS always reserves the menu bar, so availHeight is strictly less than
+    // height. Measured 33px on a real Mac; the old blanket -40 is a Windows
+    // taskbar shape.
+    const height = screen?.height ?? (isMac ? 1117 : 1080);
+    const reserved = isMac ? 33 : 40;
+    // The reserve is enforced, not merely defaulted. A pool profile that reports
+    // availHeight EQUAL to height used to pass straight through, and a session
+    // claiming macOS then said its screen has no menu bar - which no Mac does,
+    // and which is one comparison to check. Measured on the platform 2026-08-12:
+    // screen 1680x1050 with availHeight 1050 against a MacIntel platform.
+    const providedAvailHeight = screen?.availHeight;
+    const availHeight = isMac
+        ? Math.min(providedAvailHeight ?? height - reserved, height - reserved)
+        : providedAvailHeight ?? height - reserved;
+    return {
+        width: screen?.width ?? (isMac ? 1728 : 1920),
+        height,
+        availWidth: screen?.availWidth ?? screen?.width ?? (isMac ? 1728 : 1920),
+        availHeight,
+        colorDepth,
+        pixelRatio,
+    };
+}
+/**
+ * Resolve the (navigator.language, navigator.languages, timezone) triple the
+ * config advertises. Prefers the pre-resolved locale (explicit-intent path),
+ * else a seeded plausible default. Pure.
+ */
+function buildLocaleSurface(headers, resolvedLocale, seed) {
     // Accept-language: prefer the pre-resolved triple (so a user-supplied locale wins)
     // and fall back to fingerprint headers when no resolution happened.
     //
     // Important: the C++ FingerprintConfig reader splits this string on commas and
     // feeds each entry verbatim into `navigator.languages` (the JS array). Real Chrome's
-    // navigator.languages never carries q-values — those are HTTP Accept-Language
+    // navigator.languages never carries q-values - those are HTTP Accept-Language
     // semantics only. If we leave `"en-US,en;q=0.9"` in the config, the JS array leaks
     // `"en;q=0.9"` which is an instant detectable anomaly. Strip q-values here so the
     // config field is the clean list; the HTTP header flows from the same field and
     // will also be q-less, which is a valid (if less common) real-browser pattern.
-    const rawAcceptLanguage = resolvedLocale?.languages
-        ?? headers['accept-language']
-        ?? headers['Accept-Language'];
-    const acceptLanguage = rawAcceptLanguage
-        ? rawAcceptLanguage.split(',').map((l) => l.split(';')[0].trim()).filter(Boolean).join(',')
-        : undefined;
-    const navLanguage = resolvedLocale?.locale;
-    const timezone = resolvedLocale?.timezone;
-    // Primary brand name — extract from UA-CH brands or derive from User-Agent
-    const brandName = extractBrandName(uaBrands, userAgent);
-    // Battery — generate realistic values based on target platform.
-    // Uses UA-CH platform names ('Windows'|'macOS'|'Linux') for the desktop/mac checks.
-    const battery = generateBatteryConfig(uaChPlatform, seed);
-    // deviceMemory: spec requires the value be one of {0.25, 0.5, 1, 2, 4, 8}
-    // (https://www.w3.org/TR/device-memory/#sec-device-memory-js-api). Exposing
-    // anything outside this set — in particular the real 32 on a 32 GB machine —
-    // is an immediate "bot" signal for any vendor that checks.
-    const rawDeviceMemory = fp.navigator?.deviceMemory ?? 8;
-    const deviceMemory = clampDeviceMemoryToSpecBuckets(rawDeviceMemory);
-    // colorDepth: real Chrome privacy-reduces to 24 regardless of display HDR
-    // capability. 30 is the raw macOS value that leaks through when we don't cap.
-    const rawColorDepth = screen?.colorDepth ?? 24;
-    const colorDepth = Math.min(rawColorDepth, 24);
+    if (resolvedLocale) {
+        // User specified a locale (fingerprintOptions.locale) or one was derived
+        // from the proxy session. Honour it verbatim - this is the explicit-intent
+        // path and the source of truth for navigator.language / Accept-Language /
+        // timezone propagation.
+        const raw = resolvedLocale.languages
+            ?? headers['accept-language']
+            ?? headers['Accept-Language'];
+        const languages = raw
+            ? raw.split(',').map((l) => l.split(';')[0].trim()).filter(Boolean).join(',')
+            : undefined;
+        return { language: resolvedLocale.locale, languages, timezone: resolvedLocale.timezone };
+    }
+    // ─── No-intent fallback ─────────────────────────────────────────────
+    // Without a resolvedLocale, the fingerprint-generator's Accept-Language
+    // header reflects the HOST machine (Mac dev box in Prague → cs-CZ
+    // header). Using it would leak the host locale through navigator.languages
+    // and the Worker's Intl/Date paths regardless of what UA the spoof
+    // claims. CreepJS Worker probe flags this as "lang/timezone confidence:
+    // high" on the host's value - instant detection.
+    //
+    // Pin a seeded-but-plausible default so the seed deterministically picks
+    // a coherent (locale, languages, timezone) triple. Pool entries are
+    // common English-speaking combos that match the macOS UA-Reduction
+    // freeze; identical seed → identical triple, so Mac-on-Mac and
+    // Mac-on-Linux runs are diff-stable.
+    const FALLBACK_POOL = [
+        { locale: 'en-US', languages: 'en-US,en', timezone: 'America/Los_Angeles' },
+        { locale: 'en-US', languages: 'en-US,en', timezone: 'America/New_York' },
+        { locale: 'en-US', languages: 'en-US,en', timezone: 'America/Chicago' },
+        { locale: 'en-US', languages: 'en-US,en', timezone: 'America/Denver' },
+        { locale: 'en-GB', languages: 'en-GB,en', timezone: 'Europe/London' },
+        { locale: 'en-CA', languages: 'en-CA,en', timezone: 'America/Toronto' },
+        { locale: 'en-AU', languages: 'en-AU,en', timezone: 'Australia/Sydney' },
+    ];
+    const idx = Math.abs(Math.trunc(seed)) % FALLBACK_POOL.length;
+    const fb = FALLBACK_POOL[idx];
+    return { language: fb.locale, languages: fb.languages, timezone: fb.timezone };
+}
+/**
+ * Derive the canvas text-rendering-mode hint from the WebGL family so canvas2D
+ * text rasterisation matches the OS we claim. Pure.
+ */
+function buildCanvasSurface(family) {
+    // M6: the C++ FingerprintConfig parser ALSO derives the same default when
+    // canvas is omitted entirely, so this is belt-and-suspenders - but writing
+    // it from here means the JSON config is self-describing and a reader can
+    // see exactly which mode + font allowlist the session ships with.
+    if (!family)
+        return undefined;
+    const textRenderingMode = (() => {
+        switch (family) {
+            // Grayscale, not LCD striped, and matching the C++ default for this
+            // family rather than contradicting it. macOS has not used subpixel
+            // antialiasing since 10.14 Mojave, so a 2026 Mac claim asking for
+            // striped edges describes a machine that stopped existing in 2018.
+            //
+            // Measured before changing: for canvas2D specifically this is inert,
+            // because Chromium never takes the LCD path on a canvas surface - the
+            // container returned grayscale edges (max channel delta 1, which is
+            // the pixel noise) under both modes. It is page text rasterisation
+            // and any screenshot of it that the striped mode would have reached.
+            // Corrected regardless: the JSON is read by operators as the
+            // description of the identity, and this half of it said pre-Mojave.
+            case 'apple_metal': return 'grayscale_aa_no_hinting';
+            case 'windows_d3d_nvidia':
+            case 'windows_d3d_amd':
+            case 'windows_d3d_intel':
+                return 'lcd_subpixel_full_hinting';
+            case 'linux_mesa_amd':
+            case 'linux_mesa_nvidia':
+            case 'linux_mesa_intel':
+                return 'rgb_subpixel_slight_hinting';
+            default:
+                return undefined;
+        }
+    })();
+    return textRenderingMode ? { textRenderingMode } : undefined;
+}
+/**
+ * Generate a FingerprintConfig JSON object from fingerprint-generator output.
+ *
+ * Composed from per-surface pure builders (navigator / webgl / webgpu / screen /
+ * locale / battery / network / audio / canvas). The narrow public signature is
+ * the module interface - the builders stay private so callers assemble the whole
+ * config in one call.
+ *
+ * @param fingerprint - BrowserFingerprintWithHeaders from fingerprint-generator
+ * @param sessionId - Session identifier used to derive the seed (proxy session ID, etc.)
+ * @param resolvedLocale - Pre-resolved locale/languages/timezone triple. When provided,
+ *   these values win over anything derived from fingerprint-generator headers so that a
+ *   user-supplied `locale: 'ko-KR'` coherently propagates to every locale surface
+ *   (Accept-Language, navigator.language, Intl defaults, timezone).
+ */
+export function generateFingerprintConfig(fingerprint, sessionId, resolvedLocale) {
+    const fp = fingerprint.fingerprint;
+    const { headers } = fingerprint;
+    const seed = deriveSeed(sessionId, fp.navigator?.userAgent ?? '');
+    const locale = buildLocaleSurface(headers, resolvedLocale, seed);
+    const nav = buildNavigatorSurface(fp, headers, seed, locale);
+    const webglSurface = buildWebglSurface(fp);
     const config = {
         version: 1,
         seed,
-        brandName,
-        ...(timezone && { timezone }),
-        navigator: {
-            platform, // legacy form: 'MacIntel' | 'Win32' | 'Linux x86_64'
-            ...(navLanguage && { language: navLanguage }),
-            ...(acceptLanguage && { languages: acceptLanguage }),
-            hardwareConcurrency: fp.navigator?.hardwareConcurrency ?? 8,
-            deviceMemory,
-            userAgent,
-            ...(uaBrands.length > 0 && {
-                userAgentData: {
-                    brands: uaBrands,
-                    mobile: uaData?.mobile ?? false,
-                    platform: uaData?.platform ?? uaChPlatform,
-                    platformVersion: uaData?.platformVersion ?? '15.0.0',
-                    architecture: uaData?.architecture ?? 'x86',
-                    bitness: uaData?.bitness ?? '64',
-                    model: uaData?.model ?? '',
-                    uaFullVersion: uaData?.uaFullVersion ?? extractFullVersion(userAgent),
-                    fullVersionList: uaBrands,
-                },
-            }),
-        },
-        webgl: {
-            vendor: webglVendor,
-            renderer: webglRenderer,
-        },
-        screen: {
-            width: screen?.width ?? 1920,
-            height: screen?.height ?? 1080,
-            availWidth: screen?.availWidth ?? screen?.width ?? 1920,
-            availHeight: screen?.availHeight ?? (screen?.height ? screen.height - 40 : 1040),
-            colorDepth,
-            pixelRatio: screen?.devicePixelRatio ?? 1,
-        },
-        battery,
+        brandName: nav.brandName,
+        ...(locale.timezone && { timezone: locale.timezone }),
+        navigator: nav.navigator,
+        webgl: webglSurface.webgl,
+        screen: buildScreenSurface(fp),
+        // Battery - generate realistic values based on target platform.
+        // Uses UA-CH platform names ('Windows'|'macOS'|'Linux') for the desktop/mac checks.
+        battery: generateBatteryConfig(nav.uaChPlatform, seed),
         noise: {
             canvas: true,
             audio: true,
@@ -166,18 +493,19 @@ export function generateFingerprintConfig(fingerprint, sessionId, resolvedLocale
             performanceNowResolutionMs: 1,
         },
     };
-    // WebGPU — from explicit webgpu field on fingerprint (non-Apify profiles), or
-    // derived from WebGL vendor as a fallback (Apify fingerprints have no webgpu data).
-    const webgpuData = fp.webgpu;
-    const derivedWebGPUVendor = webgpuData?.vendor ?? deriveWebGPUVendorFromWebGL(webglVendor);
-    if (derivedWebGPUVendor) {
-        config.webgpu = {
-            vendor: derivedWebGPUVendor,
-            architecture: webgpuData?.architecture ?? '',
-            device: webgpuData?.device ?? '',
-            description: webgpuData?.description ?? '',
-        };
-    }
+    const webgpu = buildWebgpuSurface(fp, webglSurface.vendor);
+    if (webgpu)
+        config.webgpu = webgpu;
+    // navigator.connection - prevent datacenter rtt/downlink leak. Same seed
+    // → same values, so Mac and Linux Docker hosts running the same profile
+    // report the same connection metrics.
+    config.network = deriveNetwork(seed);
+    // AudioContext.sampleRate hint matched to platform. Consumed by the C++
+    // base_audio_context.h getter when the binding-layer override lands.
+    config.audio = { sampleRate: deriveAudioSampleRate(nav.platform) };
+    const canvas = buildCanvasSurface(webglSurface.family);
+    if (canvas)
+        config.canvas = canvas;
     return config;
 }
 /**
@@ -199,33 +527,10 @@ export async function cleanupTempFingerprintConfig(filePath) {
         await fs.unlink(filePath);
     }
     catch {
-        // Non-fatal — temp file will be cleaned by OS eventually
+        // Non-fatal - temp file will be cleaned by OS eventually
     }
 }
 // ─── Helpers ──────────────────────────────────────────────────────────────────
-/**
- * Clamp a raw device-memory-in-GB value to the buckets required by the
- * Device Memory API spec (https://www.w3.org/TR/device-memory/). Chrome
- * always quantizes to {0.25, 0.5, 1, 2, 4, 8}. Returning anything outside
- * this set — especially the real value on >8 GB machines — is an instant
- * anti-bot detection signal.
- *
- * Rule (per spec): the returned value is the closest bucket that is less
- * than or equal to the actual value, capped at 8.
- */
-function clampDeviceMemoryToSpecBuckets(raw) {
-    const buckets = [0.25, 0.5, 1, 2, 4, 8];
-    if (!Number.isFinite(raw) || raw <= 0)
-        return 8;
-    if (raw >= 8)
-        return 8;
-    let bucket = buckets[0];
-    for (const b of buckets) {
-        if (b <= raw)
-            bucket = b;
-    }
-    return bucket;
-}
 /** Extract full Chrome version string from User-Agent (e.g. "Chrome/136.0.7103.0") */
 function extractFullVersion(userAgent) {
     const match = userAgent.match(/Chrome\/(\d+\.\d+\.\d+\.\d+)/);
@@ -304,7 +609,7 @@ function seedRng(seed) {
     return () => {
         s = (s + 0x6D2B79F5) | 0;
         let t = Math.imul(s ^ (s >>> 15), 1 | s);
-        t = (t + Math.imul(t ^ (t >>> 7), 61 | t)) ^ t;
+        t ^= t + Math.imul(t ^ (t >>> 7), 61 | t);
         return ((t ^ (t >>> 14)) >>> 0) / 4294967296;
     };
 }