capiumbrowser 1.1.8 → 1.2.0

package/README.md

@@ -35,10 +35,10 @@ Not a patched config. Not a JavaScript injection. A real Chromium binary whose f
 > Using Python? The same browser ships as a [PyPI package](https://pypi.org/project/capiumbrowser/) with the same options.
 
 - **Source-level C++ stealth** — User-Agent & UA-CH, WebGL/GPU, canvas, audio, screen, hardware, fonts, voices, WebRTC, `navigator.webdriver`, DevTools, pointer, client-rects — all rewritten **in the browser's own source**, below the JavaScript layer.
-- **Coherent per-seed identities** — one integer **seed** derives a complete, self-consistent device (OS, GPU, cores, memory, screen, fonts, UA). Same seed ⇒ same machine, on any host, every run.
+- **Repeatable per-seed identities** — one integer **seed** selects OS, GPU, cores, memory, screen, fonts and UA settings. Rendering still depends on the host; the same seed does not reproduce the same physical device across hosts.
 - **`humanize: true`** — attaches `page.humanMove` / `humanClick` / `humanType` / `humanScroll`: curved, human-timed mouse, keyboard, and scroll input.
 - **`geoip: true`** — the binary resolves its own exit IP through your proxy and pins timezone, WebRTC IP, geolocation, and `navigator.languages` to match. The clock, locale, and IP all tell one story.
-- **Plain drivers over CDP** — no patched driver, no init-script signature, no `Object.defineProperty` shim to detect. Update the engine with `npm i -U playwright-core` (or `puppeteer-core`).
+- **Plain drivers over CDP** — no patched driver or fingerprint `Object.defineProperty` shim. Update the driver with `npm i -U playwright-core` (or `puppeteer-core`); select the Capium browser binary separately.
 - **Always the latest binary** — one license key fetches the newest checksum-verified build for your platform and reuses it thereafter.
 - **Free tier — 1 concurrent session.** Paid tiers raise the concurrent-session cap. [Start free →](https://capiumbrowser.com)
 
@@ -142,13 +142,14 @@ Puppeteer `Browser`:
 - **Config-level stealth breaks.** `puppeteer-extra-plugin-stealth`, patched drivers, and
   friends inject JavaScript or flip flags. Every Chrome update breaks them, and modern
   anti-bot ML detects the patches themselves — the very act of hiding trips the alarm.
-- **Capium patches Chromium source.** Fingerprints are modified at the C++ level and compiled
-  into the binary. Detection sites see a real browser because it *is* one — no init script,
-  no `toString` tampering, no CDP hooks to sniff.
-- **Coherence is the product.** A convincing device isn't one clean signal; it's *every*
-  signal telling the same story. Capium derives GPU, screen, fonts, UA-CH, timezone, locale,
-  and WebRTC from a single seed + your proxy's geography, so nothing contradicts anything else.
-- **Same behavior everywhere.** Local, Docker, VPS, Lambda — no environment-specific config.
+- **Capium patches Chromium source.** Fingerprint changes are compiled into the browser at the C++
+  level. SDK evaluation and exposed bindings can still reveal driver behavior; see the measured
+  [Chrome 155 audit](../../docs/SDK-GPU-AUDIT.md).
+- **Coherence needs measurement.** A seed selects identity settings, and optional proxy geography
+  aligns network-related settings. Native rendering, fonts and server classifications still depend
+  on the host and launch policy; matching the persona to the host performs better in the current audit.
+- **Common launch API.** Local, Docker, VPS and Lambda deployments need their own display, graphics
+  dependency and proxy checks.
 - **Works with your stack.** Drop-in stealth for Crawlee, @playwright/test,
   puppeteer-cluster, and anything that speaks CDP. See [integrations](#framework-integrations).
 
@@ -184,11 +185,11 @@ See **[capiumbrowser.com/#pricing](https://capiumbrowser.com/#pricing)** for cur
 ### Get a key
 
 1. Create an account at **[capiumbrowser.com](https://capiumbrowser.com)** and create a license (start with the
-   free 1-session tier). Keys look like `cap_XXXXXXXXXXXXXXXXXXXXXXXX`.
+   free 1-session tier). Keys look like `cap_your_license_key`.
 2. Make it available to the SDK any one way (checked in this order):
 
    ```bash
-   export CAPIUM_LICENSE_KEY="cap_xxxxxxxxxxxxxxxxxxxx"
+   export CAPIUM_LICENSE_KEY="cap_your_license_key"
    # optional — defaults to https://license.capzy.ai
    export CAPIUM_LICENSE_SERVER="https://license.capzy.ai"
    ```
@@ -213,8 +214,17 @@ Handle license errors with typed error classes — `CapiumSeatLimitError`, `Capi
 
 ## What a persona reads
 
-On a **matching-OS host** (a Windows persona on Windows, a macOS persona on macOS), a Capium persona reads
-clean against a modern fingerprinting suite — with the correct GPU, fonts, and voices for the claimed device:
+The table below retains historical Chrome 152 observations. These are examples,
+not guarantees for every seed, SDK driver, host or detector revision.
+The [Chrome 155 SDK/proxy audit](../../docs/reports/sdk-public-audit-155-2026-10-09.html)
+records current BrowserScan and Fingerprint observations through Node Playwright/
+Puppeteer and Python sync/async on all three hosts. Matched Windows/Mac personas
+have clean tampering observations; Linux and cross-OS cases remain flagged.
+Local API checks do not establish a public verdict or certify a seeded GPU as
+physical hardware.
+The active Rebrowser checks also detect driver stack labels, main-world DOM calls
+and exposed bindings. A clean launch observation does not cover every script's
+behavior or make `page.evaluate()` / `exposeFunction()` invisible to the page.
 
 | Signal | Stock driver Chromium | Capium |
 |---|---|---|
@@ -228,11 +238,13 @@ clean against a modern fingerprinting suite — with the correct GPU, fonts, and
 | JA4 TLS fingerprint | differs from Chrome | **matches stock Chrome** |
 | WebRTC IP behind a proxy | real IP leaks | **pinned to the proxy exit** |
 
-> **Honesty matters more than a green screenshot.** A **GPU-less headless Linux** box makes WebGL fall back
-> to SwiftShader, which any modern suite (and stock Chrome) flags as `virtual_machine` / `anti_detect` — an
-> artifact of the *host*, not the browser. Run **headed** (Xvfb is fine) on a GPU-backed, matching-OS host
-> for the clean verdict. And `os_mismatch` is a **network** signal — genuine Chrome trips it behind some
-> proxies/NATs too, so treat it as a routing concern, not a browser one.
+> Software rendering can initialize WebGL without reproducing a hardware GPU.
+> A seeded renderer name does not change the actual device or establish a clean
+> detector verdict. On the tested 155 Linux/Xvfb stack, defaults provide headless
+> WebGL but headed contexts are absent; explicit Mesa flags initialize both modes.
+> Use matched stock/native controls and verify the assigned browser proxy exit
+> before and after each public target. Keep unavailable contexts and unmeasured
+> server verdicts explicit.
 
 ---
 
@@ -652,16 +664,21 @@ launches **headed**, which reads cleaner than headless.
 
 | Platform | Distro tag | Notes |
 |---|---|---|
-| Windows x86_64 | `windows-x64` | Native GPU/fonts back a Windows persona flawlessly |
-| macOS arm64 (Apple Silicon) | `macos-arm64` | M1–M4 by design (covers 2020+ Macs); a Windows persona uses installed Windows fonts for fallback |
-| Linux x86_64 | `linux-x64` | Defaults to a Windows persona; supply Windows fonts for the cleanest result |
-| Linux arm64 | `linux-arm64` | Same as Linux x64 for aarch64 hosts |
+| Windows x86_64 | `windows-x64` | Native Windows GPU/fonts support a matching persona; seeded hardware fidelity still requires measurement |
+| macOS arm64 (Apple Silicon) | `macos-arm64` | Native Apple graphics support a matching persona; cross-OS identities need separate checks |
+| Linux x86_64 | `linux-x64` | Defaults to a Windows persona; select a matching Linux persona and verify the deployment's graphics stack |
+| Linux arm64 | `linux-arm64` | Declared in the manifest; not yet published or covered by the three-host audit |
 
 The SDK auto-detects your host and downloads the matching tag; macOS Intel and Windows ARM are **not**
-published and throw a clear error. Capium currently targets **Chromium 152**.
+published and throw a clear error. The **1.2.0** manifest selects **Chromium 155.0.8059.39, revision 1** on the three
+supported hosts. This release is prepared as a draft; downloads become available when the browser
+artifacts are published. Linux arm64 remains unpublished.
 
 ---
 
+The 1.2.0 launch APIs wait for the packaged browser's licensing decision before
+returning a handle. Invalid keys raise a typed error during launch.
+
 ## CLI & environment
 
 ```bash
@@ -695,12 +712,13 @@ license key; it prints a fix for anything missing and exits non-zero if the envi
 | `no license configured` | Set `CAPIUM_LICENSE_KEY`, pass `licenseKey: '…'`, or create `~/.capium/license` (`KEY=cap_…`). |
 | `playwright-core is not installed` | `npm install playwright-core` (or `puppeteer-core`) — the driver is a peer dependency you choose. |
 | `CapiumSeatLimitError` | Free tier is 1 concurrent session — close the other Capium browser (or upgrade the tier). |
-| Still blocked on aggressive sites | Run **headed** (`headless: false` under Xvfb) + a **residential** proxy + `geoip: true` + humanized input. Most blocks are IP reputation or a mismatched clock, not fingerprint. |
+| Still blocked on aggressive sites | Compare a matching persona with stock Chrome through assigned proxies. Check route, timezone, graphics availability and detector fields separately; headed mode under Xvfb also needs a working graphics backend. |
 | Intermittent 403s on reCAPTCHA Enterprise sites | Prefer the **Playwright** front-end — Puppeteer's CDP protocol usage leaks more automation signals (a Puppeteer limitation, not a Capium one). |
-| FPJS `tampering: true` | Cross-OS persona on a mismatched host, or per-seed noise unmasked — run on a matching-OS host; `--fingerprint-noise=false` is the default. |
+| FPJS `tampering: true` | Prefer a matching-OS host and keep the default `--fingerprint-noise=false`. The current Linux audit remains flagged even with hardware Vulkan; ML zero alone does not clear tampering or anomaly. See the [audit](../../docs/SDK-GPU-AUDIT.md). |
 | "Windows persona but missing fonts" | Supply real `C:\Windows\Fonts\*.ttf` (see [Fonts](#fonts)) or set `CAPIUM_SUPPRESS_FONT_WARNING=1`. |
 | `os_mismatch: true` | A network/transport signal (genuine Chrome shows it too behind some proxies) — a routing concern, not the browser. |
 | Headed browser won't start on a server | Run under `Xvfb` and export `DISPLAY=:99`. |
+| Chrome 155 dev: intermittent headed Puppeteer startup on macOS | The owned-origin matrix reproduced launch timeouts with both WebSocket and pipe transport. An active process sample waited in the licensing startup gate before page probes; the exact cause remains unresolved. Python and Node Playwright headed launches, and Puppeteer headless launches, completed in the matrix. |
 
 More: [docs.capiumbrowser.com](https://docs.capiumbrowser.com).
 

package/lib/channels.json

@@ -1,31 +1,32 @@
 {
   "_comment": "SINGLE SOURCE OF TRUTH for the current stable Capium browser build per OS/arch. Each OS reaches stable independently -- edit one entry without touching the others. This file ships inside the wheel (the SDK reads it to pick each host's stable build) AND is published to the download server by the release pipeline. `version` is the Chromium version (what the browser reports to the customer -- unchanged by the revision); `revision` is our packaging counter -- the served R2 folder is chromium-v<version>.<revision>/, ALWAYS dotted-suffixed starting at 1 (chromium-v<version>.1/ is the first build, .2/ a same-engine re-spin), so publishing a re-spin never overwrites the artifact older SDKs still fetch. `published: false` means the tag is declared but no artifact exists yet -- the SDK raises a clear 'not published yet' error instead of a raw 404.",
   "schema": 1,
-  "updated": "2026-10-08",
+  "updated": "2026-10-10",
   "channels": {
     "stable": {
       "windows-x64": {
-        "version": "153.0.8010.53",
-        "engine_version": "153.0.8010.52",
-        "revision": 5,
-        "sha256": "3f53b86f80a3b145cb75995615f19c957a74d6a1a0ae1151ff64517b3a931d67",
-        "published": true
+        "version": "155.0.8059.39",
+        "revision": 1,
+        "sha256": "d973e2460ce05e99f7e5c1dddc319ae96733434d9986dadc4cec5bac1c2597fb",
+        "published": true,
+        "license_status_protocol": 1
       },
       "macos-arm64": {
-        "version": "153.0.8010.53",
-        "engine_version": "153.0.8010.52",
-        "revision": 6,
-        "sha256": "eca400433d74e5ac3b59fa1764bba783674a05cfc5a34598c8c1d2f02c708e18",
-        "published": true
+        "version": "155.0.8059.39",
+        "revision": 1,
+        "sha256": "f07d54b88feb6644388196d6b91c9787592c1f6e07a8122344f47faed76b9262",
+        "published": true,
+        "license_status_protocol": 1
       },
       "linux-x64": {
-        "version": "153.0.8010.52",
-        "revision": 5,
-        "sha256": "f65f11a2b15dea523ee95e35cadbbd43c77aba4751cdc0f96f8c138143f041bb",
-        "published": true
+        "version": "155.0.8059.39",
+        "revision": 1,
+        "sha256": "a15cd395e1f8b792d9539c8284edcd589c6b91ef77f8b1fa5ea408f1f220b540",
+        "published": true,
+        "license_status_protocol": 1
       },
       "linux-arm64": {
-        "version": "153.0.8010.52",
+        "version": "155.0.8059.39",
         "revision": 1,
         "sha256": null,
         "published": false

package/lib/config.js

@@ -2,14 +2,11 @@
  * config -- default stealth arguments and binary discovery.
  *
  * The capium binary is driven through its `capium` bash wrapper (executablePath), which
- * adds the GL/Metal backend, geoip, font, bluetooth/share and storage-quota flags per platform.
+ * supports explicit backend selection and platform flags; geoip remains opt-in.
  * This module only builds the *fingerprint-level* Chrome flags and locates that wrapper.
  *
- * Design note (why no stealth plugin): capium's own source patches make a vanilla driver
- * stealthy --
- *   001 (disable Runtime.enable console-reporting)  -> FingerprintJS developer_tools = false
- *   009 (webdriver)                                 -> navigator.webdriver = false
- * so we launch with plain Playwright / Puppeteer and let the binary do the CDP hardening.
+ * The binary handles CDP isolation and console masking, plus the webdriver surface.
+ * We launch with plain drivers; detector outcomes still require native host tests.
  */
 'use strict';
 
@@ -20,29 +17,23 @@ const path = require('path');
 // Playwright/Puppeteer default args to SUPPRESS (ignoreDefaultArgs): these leak automation
 // or force a software render.
 //   --enable-automation         : exposes navigator.webdriver=true + an automation banner.
-//   --enable-unsafe-swiftshader : the driver adds this so headless WebGL "works", but it ENABLES
-//                                 the (for us, broken-ICD) bundled SwiftShader path -> getContext
-//                                 ('webgl')=null headless / a software-raster tell. Stripping it
-//                                 forces Chromium onto the real GPU (GPU host) or system Mesa.
+//   --enable-unsafe-swiftshader : permits a software fallback. Keep that choice
+//                                 explicit instead of inheriting a driver's default.
+//                                 The historical 153 package lacked its ICD manifest;
+//                                 the 155 packager includes it. Validate drawing in
+//                                 the deployed environment for either backend.
 const IGNORE_DEFAULT_ARGS = ['--enable-automation', '--enable-unsafe-swiftshader'];
 
-// Headless default screen/viewport. Headless has no real display, so the per-seed device-pool
-// screen (e.g. 2560x1440) has no window manager to size a matching window against -- the
-// framebuffer would stay at Chromium's small headless default and screen != viewport (a
-// browserscan VM tell). Instead model the single MOST COMMON real setup: a maximized Chrome
-// window on a 1080p Windows monitor -- screen 1920x1080, viewport 1920x947 (1040 avail height
-// minus ~93px of tab/omnibox/bookmark chrome). Dominant real-world viewport, so a headless
-// instance blends in, and screen > viewport stays coherent. Applied only in headless and only
-// when the caller pins no screen (an explicit --fingerprint-screen-* / --window-size opts out).
+// The 155 engine selects a seeded screen within these default bounds. Start
+// headless windows small enough to fit its modes without replacing the screen.
+// Explicit screen/window flags take
+// precedence. HEADLESS_SCREEN remains the upper bound for existing consumers.
 const HEADLESS_SCREEN = [1920, 1080];
-const HEADLESS_VIEWPORT = [1920, 947];
+const HEADLESS_VIEWPORT = [800, 600];
 
 function getHeadlessDefaultArgs() {
-  const [sw, sh] = HEADLESS_SCREEN;
   const [vw, vh] = HEADLESS_VIEWPORT;
   return [
-    `--fingerprint-screen-width=${sw}`,
-    `--fingerprint-screen-height=${sh}`,
     `--window-size=${vw},${vh}`,
   ];
 }
@@ -58,12 +49,10 @@ function hasScreenOverride(extra) {
  *
  * seed:     int identity seed (a stable, coherent device per seed). Random if null.
  * platform: "windows" | "macos" | "linux" -- the spoofed OS persona.
- * screen:   DEFAULT null -> use the seed's COHERENT per-seed device screen from the binary's
- *           device pool (GPU-matched resolution + realistic dpr); fitWindow then sizes the window
- *           to it so viewport ~= screen. Passing an explicit [w,h] FORCES that resolution on every
- *           seed (all instances share one screen AND can pair e.g. an RTX 5080 with 1440x900) --
- *           only for a fixed-kiosk scenario. (Previously defaulted to [1440,900], a cross-instance
- *           correlation + GPU-incoherence tell -- now matches the python SDK's screen=None.)
+ * screen:   null uses the binary's seeded screen and DPR. Development 155 defaults
+ *           vary within 1920x1080. Headless starts with an 800x600 window; its screen
+ *           remains independent of the viewport. An explicit [w,h] overrides the screen
+ *           and startup window, including sizes above the default cap.
  */
 function getDefaultStealthArgs(seed = null, platform = 'windows', screen = null) {
   const args = [];
@@ -91,17 +80,15 @@ function getDefaultStealthArgs(seed = null, platform = 'windows', screen = null)
       'primaryPointerType=4,availablePointerTypes=4',
     '--no-first-run',
     '--no-default-browser-check',
-    // NOTE: capium "CDP stealth" (isolated-world eval + console-API masking that make a vanilla
-    // driver behave like patchright vs DataDome/rebrowser) is ON BY DEFAULT in the binary -- no
-    // flag needed. To opt out (e.g. a solver needing page.evaluate to read the page's own
-    // main-world window globals, which the isolated world can't see), pass
-    // extra: ['--capium-disable-cdp-stealth'].
+    // Engine 155 honors the requested execution world by default. Its console
+    // event policy is independent of page evaluation. Engine 153 retains the
+    // older default isolation behavior; --capium-isolate-cdp-eval explicitly
+    // requests that legacy mode on 155. See docs/SDK-GPU-AUDIT.md for measured
+    // page-global, object-handle and binding compatibility.
   );
-  // Patch 001 makes developer_tools always false, which unmasks FingerprintJS's
-  // tampering ML: per-seed canvas/audio NOISE would then read as tampering, so
-  // default it OFF (measured clean: tampering=false, ml~0.05, anti_detect=false).
-  // Trade-off: personas on the same host share its real canvas (no per-seed canvas
-  // uniqueness) -- pass --fingerprint-noise=true to restore it (accepts tampering).
+  // Keep injected canvas/audio/rectangle noise opt-in. Device fonts and the
+  // actual renderer can still affect pixels; noise=false does not guarantee
+  // identical canvases across personas or a particular detector classification.
   args.push('--fingerprint-noise=false');
   // A Windows persona's font metrics must match real Windows (needs Windows fonts
   // present on the host); harmless elsewhere, so gate it to the windows persona.
@@ -110,8 +97,8 @@ function getDefaultStealthArgs(seed = null, platform = 'windows', screen = null)
   // screen (e.g. 2560x1080) mismatches the actual small browser viewport (e.g.
   // 945x939) -- browserscan flags "screen dimensions don't match viewport" as a
   // virtual machine. Pin the spoofed screen to a window we also size, so
-  // screen == window == viewport in every environment (headless/container too),
-  // since the --window-size flag applies at launch without a window manager.
+  // --window-size requests the outer window; the inner viewport excludes Chrome's
+  // frame/UI and must be measured rather than assumed equal to screen dimensions.
   if (screen) {
     const sw = Math.trunc(Number(screen[0]));
     const sh = Math.trunc(Number(screen[1]));

package/lib/errors.js

@@ -96,6 +96,7 @@ function readLaunchStatus(statusPath) {
   if (!raw.trim()) return null;
   const nl = raw.indexOf('\n');
   const code = (nl === -1 ? raw : raw.slice(0, nl)).trim();
+  if (code === '0') return null;
   const msg = (nl === -1 ? '' : raw.slice(nl + 1)).trim() ||
     'the browser refused to start for a licensing reason';
   const Cls = STATUS_CODES[code] || CapiumLicenseError;

package/lib/launch-common.js

@@ -44,8 +44,8 @@ function buildArgs({ seed, platform, stealthArgs, timezone, locale, extensionPat
   let args = [];
   if (stealthArgs) {
     args = args.concat(config.getDefaultStealthArgs(seed, platform));
-    // Headless: pin the maximized-1080p-Windows screen/viewport (see config), unless the
-    // caller already set their own screen/window via extra args.
+    // Keep the engine's seeded screen. Use initial window bounds only when
+    // the caller has not provided screen/window flags.
     if (headless && !config.hasScreenOverride(extra)) {
       args = args.concat(config.getHeadlessDefaultArgs());
     }

package/lib/license-readiness.js

@@ -0,0 +1,55 @@
+'use strict';
+const fs = require('node:fs');
+const path = require('node:path');
+const { readLaunchStatus, CapiumServerDownError } = require('./errors');
+
+function required(binary) {
+  let directory = path.dirname(path.resolve(binary));
+  for (let i = 0; i < 8; i++) {
+    try {
+      const info = fs.readFileSync(path.join(directory, 'CAPIUM_BUILD_INFO'), 'utf8');
+      return /^license_status_protocol\s*:\s*1\s*$/m.test(info);
+    } catch (error) {
+      if (error.code !== 'ENOENT') throw error;
+      const parent = path.dirname(directory);
+      if (parent === directory) break;
+      directory = parent;
+    }
+  }
+  return false;
+}
+
+async function wait(binary, statusPath, timeoutMs = 30000, signal = null) {
+  if (!required(binary)) return;
+  const deadline = Date.now() + (timeoutMs || 30000);
+  for (;;) {
+    if (signal?.aborted) return;
+    const error = readLaunchStatus(statusPath);
+    if (error) throw error;
+    try {
+      if (fs.readFileSync(statusPath, 'utf8').trim() === '0\nCAPIUM_LICENSE_READY') return;
+    } catch (error) {
+      if (error.code !== 'ENOENT') throw error;
+    }
+    if (Date.now() >= deadline) {
+      throw new CapiumServerDownError('Timed out waiting for the browser license startup decision');
+    }
+    await new Promise(resolve => setTimeout(resolve, 20));
+  }
+}
+// Drivers may leave startup pending after the native process refuses the license.
+// Observe the native decision while the driver connects, so rejection cannot hang.
+async function withLaunch(pending, binary, statusPath, timeoutMs) {
+  const controller = new AbortController();
+  try {
+    const [handle] = await Promise.all([
+      pending, wait(binary, statusPath, timeoutMs, controller.signal),
+    ]);
+    return handle;
+  } finally {
+    // A driver can reject before the native decision is written. Do not keep
+    // polling a removed status file, or keep Node alive until the deadline.
+    controller.abort();
+  }
+}
+module.exports = { required, wait, withLaunch };

package/lib/version.js

@@ -25,12 +25,12 @@ const SDK_VERSION = require('../package.json').version;
 // Used only if channels.json can't be read (corrupt/removed install). ensureBinary() raises a
 // clear error long before the "unsupported platform" case matters; this keeps lookups total.
 const FALLBACK_VERSIONS = {
-  'windows-x64': '153.0.8010.52', // real Chrome 152 stable per OS (win/mac .65, linux .64)
-  'macos-arm64': '153.0.8010.52',
-  'linux-x64': '153.0.8010.52',
-  'linux-arm64': '153.0.8010.52', // declared; not yet published (see channels.json)
+  'windows-x64': '155.0.8059.39', // Chromium 155 release candidate on all supported hosts
+  'macos-arm64': '155.0.8059.39',
+  'linux-x64': '155.0.8059.39',
+  'linux-arm64': '155.0.8059.39', // declared; not yet published (see channels.json)
 };
-const DEFAULT_BINARY_VERSION = '153.0.8010.52';
+const DEFAULT_BINARY_VERSION = '155.0.8059.39';
 
 function loadStable() {
   // The `channels.stable` map from the bundled manifest, or null if unreadable.

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "capiumbrowser",
-  "version": "1.1.8",
+  "version": "1.2.0",
   "description": "Drop-in stealth browser SDK on top of Playwright or Puppeteer (Capium Chromium).",
   "license": "SEE LICENSE IN LICENSE",
   "author": "Capzy (https://capzy.ai)",

package/playwright.js

@@ -25,6 +25,7 @@ const config = require('./lib/config');
 const download = require('./lib/download');
 const human = require('./lib/human');
 const license = require('./lib/license');
+const readiness = require('./lib/license-readiness');
 const { CapiumError, translateLaunchError, readLaunchStatus } = require('./lib/errors');
 const { proxyAndGeoArgs, buildArgs, newStatusFile, clearStatusFile } =
   require('./lib/launch-common');
@@ -181,12 +182,17 @@ async function launch(opts = {}) {
   const pw = requireDriver();
   let browser;
   try {
-    browser = await pw.chromium.launch({
+    const pending = pw.chromium.launch({
       executablePath: prep.binPath, headless, args: prep.launchArgs, env: prep.env,
       ignoreDefaultArgs: config.IGNORE_DEFAULT_ARGS,   // strip automation + forced-software WebGL defaults
       ...prep.launchOptions, ...rest,
-    });
+    }).then(handle => { browser = handle; return handle; });
+    await readiness.withLaunch(pending, prep.binPath, prep.statusPath, rest.timeout);
   } catch (e) {
+    // A native refusal terminates the process; closing its dead CDP connection can hang.
+    if (!readLaunchStatus(prep.statusPath) && browser) {
+      try { await browser.close(); } catch {}
+    }
     await throwTranslated(e, prep.statusPath);
   }
   clearStatusFile(prep.statusPath);
@@ -215,12 +221,17 @@ async function launchPersistentContext(userDataDir, opts = {}) {
   const pw = requireDriver();
   let ctx;
   try {
-    ctx = await pw.chromium.launchPersistentContext(userDataDir, {
+    const pending = pw.chromium.launchPersistentContext(userDataDir, {
       executablePath: prep.binPath, headless, args: prep.launchArgs, env: prep.env,
       ignoreDefaultArgs: config.IGNORE_DEFAULT_ARGS,   // strip automation + forced-software WebGL defaults
       ...prep.launchOptions, ...rest,
-    });
+    }).then(handle => { ctx = handle; return handle; });
+    await readiness.withLaunch(pending, prep.binPath, prep.statusPath, rest.timeout);
   } catch (e) {
+    // A native refusal terminates the process; closing its dead CDP connection can hang.
+    if (!readLaunchStatus(prep.statusPath) && ctx) {
+      try { await ctx.close(); } catch {}
+    }
     await throwTranslated(e, prep.statusPath);
   }
   clearStatusFile(prep.statusPath);

package/puppeteer.js

@@ -29,6 +29,7 @@ const config = require('./lib/config');
 const download = require('./lib/download');
 const human = require('./lib/human');
 const license = require('./lib/license');
+const readiness = require('./lib/license-readiness');
 const { CapiumError, translateLaunchError, readLaunchStatus } = require('./lib/errors');
 const { proxyAndGeoArgs, buildArgs, newStatusFile, clearStatusFile } =
   require('./lib/launch-common');
@@ -181,9 +182,11 @@ async function launch(opts = {}) {
   }
   // Strip automation + forced-software WebGL defaults unless the caller took over ignoreDefaultArgs.
   const ida = ignoreDefaultArgs === undefined ? config.IGNORE_DEFAULT_ARGS : ignoreDefaultArgs;
+  const nativeGate = readiness.required(prep.binPath);
+  const waitForInitialPage = rest.waitForInitialPage !== false;
   let browser;
   try {
-    browser = await puppeteer.launch({
+    const pending = puppeteer.launch({
       executablePath: prep.binPath,
       headless,
       args: launchArgs,
@@ -191,8 +194,22 @@ async function launch(opts = {}) {
       defaultViewport: 'defaultViewport' in rest ? rest.defaultViewport : null,
       ignoreDefaultArgs: ida,
       ...rest,
-    });
+      // A rejected native gate never creates a page. Obtain the transport first,
+      // so Puppeteer does not leave its initial-page timer running after refusal.
+      waitForInitialPage: nativeGate ? false : waitForInitialPage,
+    }).then(handle => { browser = handle; return handle; });
+    await readiness.withLaunch(pending, prep.binPath, prep.statusPath, rest.timeout);
+    if (nativeGate && waitForInitialPage) {
+      await browser.waitForTarget(target => target.type() === 'page', {
+        timeout: rest.timeout === undefined ? 30000 : rest.timeout,
+        signal: rest.signal,
+      });
+    }
   } catch (e) {
+    // A native refusal terminates the process; closing its dead CDP connection can hang.
+    if (!readLaunchStatus(prep.statusPath) && browser) {
+      try { await browser.close(); } catch {}
+    }
     await throwTranslated(e, prep.statusPath);
   }
   clearStatusFile(prep.statusPath);