cdp-driver 0.0.0-stage → 0.5.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2025 Rakibul Yeasin
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -1,3 +1,193 @@
-# Temporary Holding Version
+# cdp-driver (Node / Deno / Bun)
 
-This version is a temporary placeholder for this package. An operational version to replace this has been submitted for review and is awaiting a staged release.
+napi-rs bindings for the [`cdp-driver`](https://crates.io/crates/cdp-driver)
+Rust crate: a Chrome DevTools Protocol client. WebSocket transport and the tokio
+runtime run in native Rust; JS gets Promises and TypeScript types.
+
+Connects to a Chrome/Chromium already listening on a debug port. It does not
+spawn the browser:
+
+```bash
+google-chrome --headless=new --remote-debugging-port=9222 --no-first-run
+```
+
+## Install
+
+```bash
+npm i cdp-driver      # Node / Bun
+```
+
+```ts
+import { CdpClient } from 'npm:cdp-driver'   // Deno
+```
+
+Rust snake_case maps to JS camelCase automatically (`connect_to_page` →
+`connectToPage`). The per-platform native addon is resolved at runtime.
+
+Runtime support (all load the same `.node` via Node-API):
+
+- **Node** ≥ 16  fully tested (`npm run test`, `npm run load-test`).
+- **Deno** 2.x  the native binding loads. Deno's static CJS analysis does not
+  see the addon's dynamically-assigned exports, so use `createRequire` (or the
+  `npm:` specifier) rather than a static named `import`:
+  ```ts
+  import { createRequire } from 'node:module'
+  const require = createRequire(import.meta.url)
+  const { CdpClient } = require('cdp-driver')
+  ```
+- **Bun**  supports Node-API and should load the same addon; not yet verified
+  locally.
+
+## Three classes
+
+### `CdpClient`  low-level CDP client
+
+```js
+import { CdpClient } from 'cdp-driver'
+
+const client = await CdpClient.connectToPage('127.0.0.1', 9222)
+await client.enableDomain('Page')
+await client.enableDomain('Runtime')
+
+await client.navigateAndWait('https://example.com', 10_000)
+const title = await client.eval('document.title')
+const png = await client.screenshot()          // Buffer
+const cookies = await client.getCookies()       // JSON
+await client.close()
+```
+
+Statics: `connect(wsUrl)`, `connectToPage(host, port)`, `getVersion`,
+`listTargets`, `createTab`.
+
+Instance methods, by area:
+
+- **Navigation / eval**: `enableDomain`, `navigate`, `navigateAndWait`, `eval`,
+  `evaluate`, `waitForEvent`, `callFunctionOn`.
+- **DOM**: `getDocument`, `querySelector`, `getOuterHtml`, `setAttribute`,
+  `setOuterHtml`, `removeNode`.
+- **Capture**: `screenshot`, `screenshotToFile`, `fullPageScreenshot`,
+  `fullPageScreenshotToFile`, `printToPdf`, `setViewport`.
+- **Network**: `getCookies`, `setCookie`, `deleteCookies`, `setExtraHeaders`,
+  `blockUrls`, `getResponseBody`, `interceptRequests`, `continueRequest`,
+  `fulfillRequest`.
+- **Page / emulation**: `setContent`, `addInitScript`, `removeInitScript`,
+  `setUserAgent`, `setGeolocation`, `setOffline`.
+- `close`.
+
+This tracks the Rust `CdpClient` surface (client + `network` + `page` modules).
+The Rust-only `blocking` feature has no JS equivalent (JS is async already).
+
+### `BrowserAgent`  high-level actions (auto-enables Page/Runtime/DOM/Network)
+
+```js
+import { BrowserAgent } from 'cdp-driver'
+
+const agent = await BrowserAgent.connect('127.0.0.1', 9222)
+await agent.navigate('https://example.com')
+console.log((await agent.getTitle()).value)
+
+const results = await agent.executeMany([
+  { action: 'fill', selector: '#q', value: 'hello' },
+  { action: 'press_key', key: 'Enter' },
+  { action: 'wait_for_selector', selector: '.result', timeout_ms: 5000 },
+  { action: 'get_links' },
+])
+await agent.close()
+```
+
+Every action returns `{ success, value, error }`. Actions accept an object or a
+JSON string (`execute`, `executeJson`, `executeMany`). Action names:
+
+`navigate` · `back` · `forward` · `reload` · `click` · `type` · `fill` ·
+`submit` · `press_key` · `get_title` · `get_url` · `get_text` · `get_content` ·
+`get_links` · `get_attributes` · `exists` · `screenshot` · `evaluate` · `wait` ·
+`wait_for_selector` · `scroll` · `set_viewport` · `get_metrics`
+
+### `Cluster`  fixed-size pool, one tab per worker
+
+```js
+import { Cluster } from 'cdp-driver'
+
+const cluster = await Cluster.create({
+  host: '127.0.0.1', port: 9222, concurrency: 4, retries: 1,
+})
+
+const tasks = await Promise.all(
+  urls.map((url) =>
+    cluster.execute([
+      { action: 'navigate', url },
+      { action: 'get_title' },
+    ]),
+  ),
+)
+// each: { success, results: ActionResult[], elapsedMs, attempts, error }
+await cluster.close()
+```
+
+A worker is checked out per `execute` call, capped by `concurrency`; the batch
+aborts on the first failed action and the whole batch retries up to `retries`
+times. If any worker fails to start, `create` closes the tabs it already opened
+before throwing (no leaked tabs).
+
+> Note: this `Cluster` is a purpose-built, action-batch pool for JS. It is not a
+> binding of the Rust `cdp_driver::cluster::Cluster`, whose generic
+> closure-based API cannot cross the FFI boundary. Behavior is intentionally
+> batch-oriented rather than a 1:1 port.
+
+## Errors
+
+Rejections are `Error` objects whose `message` is prefixed with a stable code:
+
+```js
+try {
+  await client.navigateAndWait(url, 1000)
+} catch (err) {
+  if (err.message.startsWith('[TIMEOUT]')) retry()
+}
+```
+
+Codes: `[WEBSOCKET]` `[HTTP]` `[JSON]` `[IO]` `[INVALID_URL]` `[PROTOCOL]`
+`[TIMEOUT]` `[NO_TARGET]` (mapped from the Rust `CdpError` variants).
+
+## Examples
+
+Mirror the Rust `examples/`. Need Chrome on `:9222` and a built addon.
+
+```bash
+npm run example:basic        # low-level CdpClient
+npm run example:agent        # BrowserAgent: object + JSON actions, batches
+npm run example:cluster      # worker pool with retries
+npm run example:industrial   # fresh tab per page, bounded concurrency
+```
+
+## Build from source
+
+```bash
+npm install
+npm run build          # release; emits index.js, index.d.ts, *.node
+node test.mjs          # smoke test (needs Chrome on :9222)
+```
+
+`napi build` generates `index.js` (loader picking the right prebuilt `.node`)
+and `index.d.ts` (typings derived from the `#[napi]` attributes).
+
+## Load test
+
+`npm run load-test` stresses the native async boundary (the shared-`&self` +
+`Arc`-clone pattern) against a real Chrome. Local run (linux-x64, headless):
+
+| Scenario | Result |
+| --- | --- |
+| 3000 concurrent `eval()` on one shared client | 0 mismatches, ~48k ops/s |
+| Cluster (12 workers, 600 tasks), per-task title check | 600/600 ok, 0 cross-talk |
+| 200 concurrent screenshots (Buffer marshaling) | 200/200 ok, 0 empty |
+| Memory | RSS stable ~52→74 MB, no leak |
+
+Confirms the pending-request map is race-free, workers don't cross-talk, and
+`Buffer` returns are thread-safe under load.
+
+## Publishing
+
+CI (`.github/workflows/node-bindings.yml`) builds one `.node` per platform, then
+on a `node-v*` tag runs `napi prepublish` + `npm publish`. Per-platform binaries
+ship as `@scope`-style optional dependencies of the meta package.

package/index.d.ts

@@ -0,0 +1,205 @@
+/* auto-generated by NAPI-RS */
+/* eslint-disable */
+
+/**
+ * Which binding artifact the generated loader actually loaded: `'native'` for
+ * a native addon, otherwise the `platformArchABI` of the WASI flavor. Every
+ * flavor napi-rs can build is listed, because `NAPI_RS_NATIVE_LIBRARY_PATH`
+ * can point the loader at a WASI artifact this package does not build itself.
+ */
+export declare const __napiBindingTarget: 'native' | 'wasm32-wasi' | 'wasm32-wasip1'
+
+/**
+ * High-level action runner. Enables `Page`, `Runtime`, `DOM`, `Network` on connect.
+ *
+ * Actions are plain objects, e.g. `{ action: 'navigate', url: 'https://...' }`.
+ * See the README for the full action list.
+ */
+export declare class BrowserAgent {
+  /** Connect to the first `page` target on `host:port` and enable the core domains. */
+  static connect(host: string, port: number): Promise<BrowserAgent>
+  /** Connect using a [`Config`] (also applies the viewport). */
+  static connectWithConfig(config: Config): Promise<BrowserAgent>
+  /** Run one action given as an object, e.g. `{ action: 'navigate', url }`. */
+  execute(action: any): Promise<ActionResult>
+  /** Run a JSON string action (`{ "action": "navigate", "url": "..." }`). */
+  executeJson(json: string): Promise<ActionResult>
+  /** Run an array of action objects sequentially. */
+  executeMany(actions: Array<any>): Promise<Array<ActionResult>>
+  /** Convenience: navigate. */
+  navigate(url: string): Promise<ActionResult>
+  /** Convenience: click a selector. */
+  click(selector: string): Promise<ActionResult>
+  /** Convenience: fill an input. */
+  fill(selector: string, value: string): Promise<ActionResult>
+  /** Convenience: press a key. */
+  pressKey(key: string): Promise<ActionResult>
+  /** Convenience: page title. */
+  getTitle(): Promise<ActionResult>
+  /** Convenience: visible text. */
+  getText(): Promise<ActionResult>
+  /** Convenience: `[{ href, text }]` for every anchor. */
+  getLinks(): Promise<ActionResult>
+  /** Convenience: does a selector match? */
+  exists(selector: string): Promise<ActionResult>
+  /** Convenience: wait until a selector appears or timeout. */
+  waitForSelector(selector: string, timeoutMs: number): Promise<ActionResult>
+  /** Convenience: full-page screenshot to `path` (returns byte count if omitted). */
+  screenshot(path?: string | undefined | null): Promise<ActionResult>
+  /** Convenience: evaluate a JS expression, return its JSON value. */
+  evaluate(expression: string): Promise<ActionResult>
+  /** Close the underlying tab. */
+  close(): Promise<void>
+}
+
+/**
+ * Chrome DevTools Protocol client.
+ *
+ * Connects to a Chrome/Chromium already listening with
+ * `--remote-debugging-port`. It does not spawn the browser.
+ */
+export declare class CdpClient {
+  /** Connect to a target WebSocket debugger URL. */
+  static connect(wsUrl: string): Promise<CdpClient>
+  /** Discover the first `page` target on `host:port` and connect to it. */
+  static connectToPage(host: string, port: number): Promise<CdpClient>
+  /** `GET /json/version`  browser + protocol version. */
+  static getVersion(host: string, port: number): Promise<any>
+  /** `GET /json/list`  all inspectable targets. */
+  static listTargets(host: string, port: number): Promise<any>
+  /** `PUT /json/new`  open a new tab, optionally at `url`. */
+  static createTab(host: string, port: number, url?: string | undefined | null): Promise<any>
+  /** Enable a CDP domain, e.g. `"Page"`, `"Runtime"`, `"DOM"`, `"Network"`. */
+  enableDomain(domain: string): Promise<void>
+  /** Navigate to `url`; returns the CDP frameId. */
+  navigate(url: string): Promise<string>
+  /** Navigate and resolve once `Page.loadEventFired` arrives (needs `Page` enabled). */
+  navigateAndWait(url: string, timeoutMs: number): Promise<string>
+  /** Evaluate a JS expression, returning the value coerced to a string. */
+  eval(expression: string): Promise<string>
+  /** Evaluate a JS expression, returning the full result as a JSON value. */
+  evaluate(expression: string): Promise<any>
+  /** Wait for a CDP event `method`, returning its params (needs the domain enabled). */
+  waitForEvent(method: string, timeoutMs: number): Promise<any>
+  /**
+   * `DOM.querySelector` from the document root; returns the matched nodeId,
+   * or `null` when nothing matches.
+   */
+  querySelector(selector: string): Promise<number | null>
+  /** `DOM.getOuterHTML` for a nodeId. */
+  getOuterHtml(nodeId: number): Promise<string>
+  /** PNG screenshot of the current viewport. */
+  screenshot(): Promise<Buffer>
+  /** Write a viewport PNG screenshot to `path`. */
+  screenshotToFile(path: string): Promise<void>
+  /** Full-page PNG screenshot. */
+  fullPageScreenshot(): Promise<Buffer>
+  /** Write a full-page PNG screenshot to `path`. */
+  fullPageScreenshotToFile(path: string): Promise<void>
+  /** Override device metrics (viewport). */
+  setViewport(width: number, height: number, mobile: boolean): Promise<void>
+  /** `DOM.getDocument` root node. */
+  getDocument(): Promise<any>
+  /** `Network.getCookies`. */
+  getCookies(): Promise<any>
+  /** `Network.setCookie`. */
+  setCookie(name: string, value: string, url?: string | undefined | null, domain?: string | undefined | null, path?: string | undefined | null): Promise<void>
+  /** `Network.deleteCookies`. */
+  deleteCookies(name: string, url?: string | undefined | null): Promise<void>
+  /** `Network.setExtraHTTPHeaders`. */
+  setExtraHeaders(headers: Record<string, string>): Promise<void>
+  /** `Network.setBlockedURLs`. */
+  blockUrls(patterns: Array<string>): Promise<void>
+  /** `Network.getResponseBody` (base64 payloads are decoded to text). */
+  getResponseBody(requestId: string): Promise<string>
+  /** Enable `Fetch` request interception for the given URL patterns. */
+  interceptRequests(urlPatterns: Array<string>): Promise<void>
+  /** `Fetch.continueRequest`. */
+  continueRequest(requestId: string): Promise<void>
+  /** `Fetch.fulfillRequest` with a canned response body. */
+  fulfillRequest(requestId: string, status: number, body: string, contentType: string): Promise<void>
+  /** Replace the document HTML (`Page.setDocumentContent`). */
+  setContent(html: string): Promise<void>
+  /** Print the page to a PDF file (`Page.printToPDF`). */
+  printToPdf(path: string): Promise<void>
+  /** Register a script to run on every new document; returns its identifier. */
+  addInitScript(source: string): Promise<string>
+  /** Remove a previously registered init script. */
+  removeInitScript(identifier: string): Promise<void>
+  /** Override the User-Agent string. */
+  setUserAgent(ua: string): Promise<void>
+  /** Override geolocation. */
+  setGeolocation(latitude: number, longitude: number, accuracy: number): Promise<void>
+  /** Toggle offline network emulation. */
+  setOffline(offline: boolean): Promise<void>
+  /** `DOM.setAttributeValue`. */
+  setAttribute(nodeId: number, name: string, value: string): Promise<void>
+  /** `DOM.setOuterHTML`. */
+  setOuterHtml(nodeId: number, html: string): Promise<void>
+  /** `DOM.removeNode`. */
+  removeNode(nodeId: number): Promise<void>
+  /** `Runtime.callFunctionOn` for a remote object id; returns the JSON value. */
+  callFunctionOn(objectId: string, functionDeclaration: string): Promise<any>
+  /** Close the current tab. */
+  close(): Promise<void>
+}
+
+/**
+ * Fixed-size pool of worker tabs, one [`BrowserAgent`] each.
+ *
+ * This is a purpose-built, action-batch oriented pool for JS, NOT a binding of
+ * the Rust `cdp_driver::cluster::Cluster` (whose generic closure-based `run`
+ * cannot cross the FFI boundary). Semantics: [`Cluster.execute`] checks out one
+ * worker, runs the action batch in order, aborts the batch on the first failed
+ * action, and retries the whole batch up to `retries` times.
+ */
+export declare class Cluster {
+  /**
+   * Open `concurrency` tabs and wrap each as a worker agent.
+   *
+   * If any worker fails to come up, every tab already opened is closed before
+   * returning the error, so a partial init never leaks tabs.
+   */
+  static create(opts: ClusterOptions): Promise<Cluster>
+  /** Run one action batch on a free worker, with retries. */
+  execute(actions: Array<any>): Promise<TaskResult>
+  /** Close every worker tab. */
+  close(): Promise<void>
+}
+
+/** Result of one browser action. */
+export interface ActionResult {
+  success: boolean
+  /** Action output as a JSON value (`null` when the action returns nothing). */
+  value?: any
+  error?: string
+}
+
+/** Options for [`Cluster.create`]. */
+export interface ClusterOptions {
+  host: string
+  port: number
+  /** Number of tabs / concurrent workers. */
+  concurrency: number
+  /** Retries per task on failure (default 0). */
+  retries?: number
+  viewportWidth?: number
+  viewportHeight?: number
+}
+
+/** Connection / viewport configuration. */
+export interface Config {
+  host: string
+  port: number
+  viewportWidth: number
+  viewportHeight: number
+}
+
+/** Result of one clustered task. */
+export interface TaskResult {
+  success: boolean
+  results: Array<ActionResult>
+  elapsedMs: number
+  attempts: number
+  error?: string
+}

package/index.js

@@ -0,0 +1,840 @@
+/* eslint-disable */
+// @ts-nocheck
+/* auto-generated by NAPI-RS */
+
+const { readFileSync } = require('fs')
+let nativeBinding = null
+// Which artifact actually loaded. The WASI fallback chain overwrites it with
+// the flavor it resolved; the late native retry below leaves it alone because
+// it only runs while no WASI candidate has been loaded. The take-over check
+// after the load-failure block can also set it.
+let __napiLoadedBindingTarget = 'native'
+// What this loader's own `requireNative()` calls returned. The check after
+// the load-failure block compares it with `nativeBinding` to tell a binding
+// this loader loaded from one that code outside it put in its place.
+let __napiRequiredNativeBinding = null
+const loadErrors = []
+
+const isMusl = () => {
+  let musl = false
+  if (process.platform === 'linux') {
+    musl = isMuslFromFilesystem()
+    if (musl === null) {
+      musl = isMuslFromReport()
+    }
+    if (musl === null) {
+      musl = isMuslFromChildProcess()
+    }
+  }
+  return musl
+}
+
+const isFileMusl = (f) => f.includes('libc.musl-') || f.includes('ld-musl-')
+
+const isMuslFromFilesystem = () => {
+  try {
+    return readFileSync('/usr/bin/ldd', 'utf-8').includes('musl')
+  } catch {
+    return null
+  }
+}
+
+const isMuslFromReport = () => {
+  let report = null
+  if (process.report && typeof process.report.getReport === 'function') {
+    process.report.excludeNetwork = true
+    report = process.report.getReport()
+  }
+  if (!report) {
+    return null
+  }
+  if (report.header && report.header.glibcVersionRuntime) {
+    return false
+  }
+  if (Array.isArray(report.sharedObjects)) {
+    if (report.sharedObjects.some(isFileMusl)) {
+      return true
+    }
+  }
+  return false
+}
+
+const isMuslFromChildProcess = () => {
+  try {
+    return require('child_process').execSync('ldd --version', { encoding: 'utf8' }).includes('musl')
+  } catch (e) {
+    // If we reach this case, we don't know if the system is musl or not, so is better to just fallback to false
+    return false
+  }
+}
+
+function requireNative() {
+  if (process.env.NAPI_RS_NATIVE_LIBRARY_PATH) {
+    try {
+      const overrideBinding = require(process.env.NAPI_RS_NATIVE_LIBRARY_PATH)
+      // The override may be a generated WASI loader, which already reports its
+      // own flavor. Adopt it: `module.exports` aliases this object, so claiming
+      // 'native' would both misreport the artifact and overwrite the loader's
+      // marker through the alias.
+      __napiLoadedBindingTarget =
+        overrideBinding && typeof overrideBinding.__napiBindingTarget === 'string'
+          ? overrideBinding.__napiBindingTarget
+          : 'native'
+      return overrideBinding
+    } catch (err) {
+      loadErrors.push(err)
+    }
+  } else if (process.platform === 'android') {
+    if (process.arch === 'arm64') {
+      try {
+        return require('./cdp-driver.android-arm64.node')
+      } catch (e) {
+        loadErrors.push(e)
+      }
+      try {
+        const binding = require('cdp-driver-android-arm64')
+        const bindingPackageVersion = require('cdp-driver-android-arm64/package.json').version
+        if (bindingPackageVersion !== '0.5.0' && process.env.NAPI_RS_ENFORCE_VERSION_CHECK && process.env.NAPI_RS_ENFORCE_VERSION_CHECK !== '0') {
+          throw new Error(`Native binding package version mismatch, expected 0.5.0 but got ${bindingPackageVersion}. You can reinstall dependencies to fix this issue.`)
+        }
+        return binding
+      } catch (e) {
+        loadErrors.push(e)
+      }
+    } else if (process.arch === 'arm') {
+      try {
+        return require('./cdp-driver.android-arm-eabi.node')
+      } catch (e) {
+        loadErrors.push(e)
+      }
+      try {
+        const binding = require('cdp-driver-android-arm-eabi')
+        const bindingPackageVersion = require('cdp-driver-android-arm-eabi/package.json').version
+        if (bindingPackageVersion !== '0.5.0' && process.env.NAPI_RS_ENFORCE_VERSION_CHECK && process.env.NAPI_RS_ENFORCE_VERSION_CHECK !== '0') {
+          throw new Error(`Native binding package version mismatch, expected 0.5.0 but got ${bindingPackageVersion}. You can reinstall dependencies to fix this issue.`)
+        }
+        return binding
+      } catch (e) {
+        loadErrors.push(e)
+      }
+    } else {
+      loadErrors.push(new Error(`Unsupported architecture on Android ${process.arch}`))
+    }
+  } else if (process.platform === 'win32') {
+    if (process.arch === 'x64') {
+      if ((process.config && process.config.variables && process.config.variables.shlib_suffix === 'dll.a') || (process.config && process.config.variables && process.config.variables.node_target_type === 'shared_library')) {
+        try {
+          return require('./cdp-driver.win32-x64-gnu.node')
+        } catch (e) {
+          loadErrors.push(e)
+        }
+        try {
+          const binding = require('cdp-driver-win32-x64-gnu')
+          const bindingPackageVersion = require('cdp-driver-win32-x64-gnu/package.json').version
+          if (bindingPackageVersion !== '0.5.0' && process.env.NAPI_RS_ENFORCE_VERSION_CHECK && process.env.NAPI_RS_ENFORCE_VERSION_CHECK !== '0') {
+            throw new Error(`Native binding package version mismatch, expected 0.5.0 but got ${bindingPackageVersion}. You can reinstall dependencies to fix this issue.`)
+          }
+          return binding
+        } catch (e) {
+          loadErrors.push(e)
+        }
+      } else {
+        try {
+          return require('./cdp-driver.win32-x64-msvc.node')
+        } catch (e) {
+          loadErrors.push(e)
+        }
+        try {
+          const binding = require('cdp-driver-win32-x64-msvc')
+          const bindingPackageVersion = require('cdp-driver-win32-x64-msvc/package.json').version
+          if (bindingPackageVersion !== '0.5.0' && process.env.NAPI_RS_ENFORCE_VERSION_CHECK && process.env.NAPI_RS_ENFORCE_VERSION_CHECK !== '0') {
+            throw new Error(`Native binding package version mismatch, expected 0.5.0 but got ${bindingPackageVersion}. You can reinstall dependencies to fix this issue.`)
+          }
+          return binding
+        } catch (e) {
+          loadErrors.push(e)
+        }
+      }
+    } else if (process.arch === 'ia32') {
+      try {
+        return require('./cdp-driver.win32-ia32-msvc.node')
+      } catch (e) {
+        loadErrors.push(e)
+      }
+      try {
+        const binding = require('cdp-driver-win32-ia32-msvc')
+        const bindingPackageVersion = require('cdp-driver-win32-ia32-msvc/package.json').version
+        if (bindingPackageVersion !== '0.5.0' && process.env.NAPI_RS_ENFORCE_VERSION_CHECK && process.env.NAPI_RS_ENFORCE_VERSION_CHECK !== '0') {
+          throw new Error(`Native binding package version mismatch, expected 0.5.0 but got ${bindingPackageVersion}. You can reinstall dependencies to fix this issue.`)
+        }
+        return binding
+      } catch (e) {
+        loadErrors.push(e)
+      }
+    } else if (process.arch === 'arm64') {
+      try {
+        return require('./cdp-driver.win32-arm64-msvc.node')
+      } catch (e) {
+        loadErrors.push(e)
+      }
+      try {
+        const binding = require('cdp-driver-win32-arm64-msvc')
+        const bindingPackageVersion = require('cdp-driver-win32-arm64-msvc/package.json').version
+        if (bindingPackageVersion !== '0.5.0' && process.env.NAPI_RS_ENFORCE_VERSION_CHECK && process.env.NAPI_RS_ENFORCE_VERSION_CHECK !== '0') {
+          throw new Error(`Native binding package version mismatch, expected 0.5.0 but got ${bindingPackageVersion}. You can reinstall dependencies to fix this issue.`)
+        }
+        return binding
+      } catch (e) {
+        loadErrors.push(e)
+      }
+    } else {
+      loadErrors.push(new Error(`Unsupported architecture on Windows: ${process.arch}`))
+    }
+  } else if (process.platform === 'darwin') {
+    try {
+      return require('./cdp-driver.darwin-universal.node')
+    } catch (e) {
+      loadErrors.push(e)
+    }
+    try {
+      const binding = require('cdp-driver-darwin-universal')
+      const bindingPackageVersion = require('cdp-driver-darwin-universal/package.json').version
+      if (bindingPackageVersion !== '0.5.0' && process.env.NAPI_RS_ENFORCE_VERSION_CHECK && process.env.NAPI_RS_ENFORCE_VERSION_CHECK !== '0') {
+        throw new Error(`Native binding package version mismatch, expected 0.5.0 but got ${bindingPackageVersion}. You can reinstall dependencies to fix this issue.`)
+      }
+      return binding
+    } catch (e) {
+      loadErrors.push(e)
+    }
+    if (process.arch === 'x64') {
+      try {
+        return require('./cdp-driver.darwin-x64.node')
+      } catch (e) {
+        loadErrors.push(e)
+      }
+      try {
+        const binding = require('cdp-driver-darwin-x64')
+        const bindingPackageVersion = require('cdp-driver-darwin-x64/package.json').version
+        if (bindingPackageVersion !== '0.5.0' && process.env.NAPI_RS_ENFORCE_VERSION_CHECK && process.env.NAPI_RS_ENFORCE_VERSION_CHECK !== '0') {
+          throw new Error(`Native binding package version mismatch, expected 0.5.0 but got ${bindingPackageVersion}. You can reinstall dependencies to fix this issue.`)
+        }
+        return binding
+      } catch (e) {
+        loadErrors.push(e)
+      }
+    } else if (process.arch === 'arm64') {
+      try {
+        return require('./cdp-driver.darwin-arm64.node')
+      } catch (e) {
+        loadErrors.push(e)
+      }
+      try {
+        const binding = require('cdp-driver-darwin-arm64')
+        const bindingPackageVersion = require('cdp-driver-darwin-arm64/package.json').version
+        if (bindingPackageVersion !== '0.5.0' && process.env.NAPI_RS_ENFORCE_VERSION_CHECK && process.env.NAPI_RS_ENFORCE_VERSION_CHECK !== '0') {
+          throw new Error(`Native binding package version mismatch, expected 0.5.0 but got ${bindingPackageVersion}. You can reinstall dependencies to fix this issue.`)
+        }
+        return binding
+      } catch (e) {
+        loadErrors.push(e)
+      }
+    } else {
+      loadErrors.push(new Error(`Unsupported architecture on macOS: ${process.arch}`))
+    }
+  } else if (process.platform === 'freebsd') {
+    if (process.arch === 'x64') {
+      try {
+        return require('./cdp-driver.freebsd-x64.node')
+      } catch (e) {
+        loadErrors.push(e)
+      }
+      try {
+        const binding = require('cdp-driver-freebsd-x64')
+        const bindingPackageVersion = require('cdp-driver-freebsd-x64/package.json').version
+        if (bindingPackageVersion !== '0.5.0' && process.env.NAPI_RS_ENFORCE_VERSION_CHECK && process.env.NAPI_RS_ENFORCE_VERSION_CHECK !== '0') {
+          throw new Error(`Native binding package version mismatch, expected 0.5.0 but got ${bindingPackageVersion}. You can reinstall dependencies to fix this issue.`)
+        }
+        return binding
+      } catch (e) {
+        loadErrors.push(e)
+      }
+    } else if (process.arch === 'arm64') {
+      try {
+        return require('./cdp-driver.freebsd-arm64.node')
+      } catch (e) {
+        loadErrors.push(e)
+      }
+      try {
+        const binding = require('cdp-driver-freebsd-arm64')
+        const bindingPackageVersion = require('cdp-driver-freebsd-arm64/package.json').version
+        if (bindingPackageVersion !== '0.5.0' && process.env.NAPI_RS_ENFORCE_VERSION_CHECK && process.env.NAPI_RS_ENFORCE_VERSION_CHECK !== '0') {
+          throw new Error(`Native binding package version mismatch, expected 0.5.0 but got ${bindingPackageVersion}. You can reinstall dependencies to fix this issue.`)
+        }
+        return binding
+      } catch (e) {
+        loadErrors.push(e)
+      }
+    } else if (process.arch === 'ppc64') {
+      try {
+        return require('./cdp-driver.freebsd-ppc64.node')
+      } catch (e) {
+        loadErrors.push(e)
+      }
+      try {
+        const binding = require('cdp-driver-freebsd-ppc64')
+        const bindingPackageVersion = require('cdp-driver-freebsd-ppc64/package.json').version
+        if (bindingPackageVersion !== '0.5.0' && process.env.NAPI_RS_ENFORCE_VERSION_CHECK && process.env.NAPI_RS_ENFORCE_VERSION_CHECK !== '0') {
+          throw new Error(`Native binding package version mismatch, expected 0.5.0 but got ${bindingPackageVersion}. You can reinstall dependencies to fix this issue.`)
+        }
+        return binding
+      } catch (e) {
+        loadErrors.push(e)
+      }
+    } else {
+      loadErrors.push(new Error(`Unsupported architecture on FreeBSD: ${process.arch}`))
+    }
+  } else if (process.platform === 'linux') {
+    if (process.arch === 'x64') {
+      if (isMusl()) {
+        try {
+          return require('./cdp-driver.linux-x64-musl.node')
+        } catch (e) {
+          loadErrors.push(e)
+        }
+        try {
+          const binding = require('cdp-driver-linux-x64-musl')
+          const bindingPackageVersion = require('cdp-driver-linux-x64-musl/package.json').version
+          if (bindingPackageVersion !== '0.5.0' && process.env.NAPI_RS_ENFORCE_VERSION_CHECK && process.env.NAPI_RS_ENFORCE_VERSION_CHECK !== '0') {
+            throw new Error(`Native binding package version mismatch, expected 0.5.0 but got ${bindingPackageVersion}. You can reinstall dependencies to fix this issue.`)
+          }
+          return binding
+        } catch (e) {
+          loadErrors.push(e)
+        }
+      } else {
+        try {
+          return require('./cdp-driver.linux-x64-gnu.node')
+        } catch (e) {
+          loadErrors.push(e)
+        }
+        try {
+          const binding = require('cdp-driver-linux-x64-gnu')
+          const bindingPackageVersion = require('cdp-driver-linux-x64-gnu/package.json').version
+          if (bindingPackageVersion !== '0.5.0' && process.env.NAPI_RS_ENFORCE_VERSION_CHECK && process.env.NAPI_RS_ENFORCE_VERSION_CHECK !== '0') {
+            throw new Error(`Native binding package version mismatch, expected 0.5.0 but got ${bindingPackageVersion}. You can reinstall dependencies to fix this issue.`)
+          }
+          return binding
+        } catch (e) {
+          loadErrors.push(e)
+        }
+      }
+    } else if (process.arch === 'arm64') {
+      if (isMusl()) {
+        try {
+          return require('./cdp-driver.linux-arm64-musl.node')
+        } catch (e) {
+          loadErrors.push(e)
+        }
+        try {
+          const binding = require('cdp-driver-linux-arm64-musl')
+          const bindingPackageVersion = require('cdp-driver-linux-arm64-musl/package.json').version
+          if (bindingPackageVersion !== '0.5.0' && process.env.NAPI_RS_ENFORCE_VERSION_CHECK && process.env.NAPI_RS_ENFORCE_VERSION_CHECK !== '0') {
+            throw new Error(`Native binding package version mismatch, expected 0.5.0 but got ${bindingPackageVersion}. You can reinstall dependencies to fix this issue.`)
+          }
+          return binding
+        } catch (e) {
+          loadErrors.push(e)
+        }
+      } else {
+        try {
+          return require('./cdp-driver.linux-arm64-gnu.node')
+        } catch (e) {
+          loadErrors.push(e)
+        }
+        try {
+          const binding = require('cdp-driver-linux-arm64-gnu')
+          const bindingPackageVersion = require('cdp-driver-linux-arm64-gnu/package.json').version
+          if (bindingPackageVersion !== '0.5.0' && process.env.NAPI_RS_ENFORCE_VERSION_CHECK && process.env.NAPI_RS_ENFORCE_VERSION_CHECK !== '0') {
+            throw new Error(`Native binding package version mismatch, expected 0.5.0 but got ${bindingPackageVersion}. You can reinstall dependencies to fix this issue.`)
+          }
+          return binding
+        } catch (e) {
+          loadErrors.push(e)
+        }
+      }
+    } else if (process.arch === 'arm') {
+      if (isMusl()) {
+        try {
+          return require('./cdp-driver.linux-arm-musleabihf.node')
+        } catch (e) {
+          loadErrors.push(e)
+        }
+        try {
+          const binding = require('cdp-driver-linux-arm-musleabihf')
+          const bindingPackageVersion = require('cdp-driver-linux-arm-musleabihf/package.json').version
+          if (bindingPackageVersion !== '0.5.0' && process.env.NAPI_RS_ENFORCE_VERSION_CHECK && process.env.NAPI_RS_ENFORCE_VERSION_CHECK !== '0') {
+            throw new Error(`Native binding package version mismatch, expected 0.5.0 but got ${bindingPackageVersion}. You can reinstall dependencies to fix this issue.`)
+          }
+          return binding
+        } catch (e) {
+          loadErrors.push(e)
+        }
+      } else {
+        try {
+          return require('./cdp-driver.linux-arm-gnueabihf.node')
+        } catch (e) {
+          loadErrors.push(e)
+        }
+        try {
+          const binding = require('cdp-driver-linux-arm-gnueabihf')
+          const bindingPackageVersion = require('cdp-driver-linux-arm-gnueabihf/package.json').version
+          if (bindingPackageVersion !== '0.5.0' && process.env.NAPI_RS_ENFORCE_VERSION_CHECK && process.env.NAPI_RS_ENFORCE_VERSION_CHECK !== '0') {
+            throw new Error(`Native binding package version mismatch, expected 0.5.0 but got ${bindingPackageVersion}. You can reinstall dependencies to fix this issue.`)
+          }
+          return binding
+        } catch (e) {
+          loadErrors.push(e)
+        }
+      }
+    } else if (process.arch === 'loong64') {
+      if (isMusl()) {
+        try {
+          return require('./cdp-driver.linux-loong64-musl.node')
+        } catch (e) {
+          loadErrors.push(e)
+        }
+        try {
+          const binding = require('cdp-driver-linux-loong64-musl')
+          const bindingPackageVersion = require('cdp-driver-linux-loong64-musl/package.json').version
+          if (bindingPackageVersion !== '0.5.0' && process.env.NAPI_RS_ENFORCE_VERSION_CHECK && process.env.NAPI_RS_ENFORCE_VERSION_CHECK !== '0') {
+            throw new Error(`Native binding package version mismatch, expected 0.5.0 but got ${bindingPackageVersion}. You can reinstall dependencies to fix this issue.`)
+          }
+          return binding
+        } catch (e) {
+          loadErrors.push(e)
+        }
+      } else {
+        try {
+          return require('./cdp-driver.linux-loong64-gnu.node')
+        } catch (e) {
+          loadErrors.push(e)
+        }
+        try {
+          const binding = require('cdp-driver-linux-loong64-gnu')
+          const bindingPackageVersion = require('cdp-driver-linux-loong64-gnu/package.json').version
+          if (bindingPackageVersion !== '0.5.0' && process.env.NAPI_RS_ENFORCE_VERSION_CHECK && process.env.NAPI_RS_ENFORCE_VERSION_CHECK !== '0') {
+            throw new Error(`Native binding package version mismatch, expected 0.5.0 but got ${bindingPackageVersion}. You can reinstall dependencies to fix this issue.`)
+          }
+          return binding
+        } catch (e) {
+          loadErrors.push(e)
+        }
+      }
+    } else if (process.arch === 'riscv64') {
+      if (isMusl()) {
+        try {
+          return require('./cdp-driver.linux-riscv64-musl.node')
+        } catch (e) {
+          loadErrors.push(e)
+        }
+        try {
+          const binding = require('cdp-driver-linux-riscv64-musl')
+          const bindingPackageVersion = require('cdp-driver-linux-riscv64-musl/package.json').version
+          if (bindingPackageVersion !== '0.5.0' && process.env.NAPI_RS_ENFORCE_VERSION_CHECK && process.env.NAPI_RS_ENFORCE_VERSION_CHECK !== '0') {
+            throw new Error(`Native binding package version mismatch, expected 0.5.0 but got ${bindingPackageVersion}. You can reinstall dependencies to fix this issue.`)
+          }
+          return binding
+        } catch (e) {
+          loadErrors.push(e)
+        }
+      } else {
+        try {
+          return require('./cdp-driver.linux-riscv64-gnu.node')
+        } catch (e) {
+          loadErrors.push(e)
+        }
+        try {
+          const binding = require('cdp-driver-linux-riscv64-gnu')
+          const bindingPackageVersion = require('cdp-driver-linux-riscv64-gnu/package.json').version
+          if (bindingPackageVersion !== '0.5.0' && process.env.NAPI_RS_ENFORCE_VERSION_CHECK && process.env.NAPI_RS_ENFORCE_VERSION_CHECK !== '0') {
+            throw new Error(`Native binding package version mismatch, expected 0.5.0 but got ${bindingPackageVersion}. You can reinstall dependencies to fix this issue.`)
+          }
+          return binding
+        } catch (e) {
+          loadErrors.push(e)
+        }
+      }
+    } else if (process.arch === 'ppc64') {
+      try {
+        return require('./cdp-driver.linux-ppc64-gnu.node')
+      } catch (e) {
+        loadErrors.push(e)
+      }
+      try {
+        const binding = require('cdp-driver-linux-ppc64-gnu')
+        const bindingPackageVersion = require('cdp-driver-linux-ppc64-gnu/package.json').version
+        if (bindingPackageVersion !== '0.5.0' && process.env.NAPI_RS_ENFORCE_VERSION_CHECK && process.env.NAPI_RS_ENFORCE_VERSION_CHECK !== '0') {
+          throw new Error(`Native binding package version mismatch, expected 0.5.0 but got ${bindingPackageVersion}. You can reinstall dependencies to fix this issue.`)
+        }
+        return binding
+      } catch (e) {
+        loadErrors.push(e)
+      }
+    } else if (process.arch === 's390x') {
+      try {
+        return require('./cdp-driver.linux-s390x-gnu.node')
+      } catch (e) {
+        loadErrors.push(e)
+      }
+      try {
+        const binding = require('cdp-driver-linux-s390x-gnu')
+        const bindingPackageVersion = require('cdp-driver-linux-s390x-gnu/package.json').version
+        if (bindingPackageVersion !== '0.5.0' && process.env.NAPI_RS_ENFORCE_VERSION_CHECK && process.env.NAPI_RS_ENFORCE_VERSION_CHECK !== '0') {
+          throw new Error(`Native binding package version mismatch, expected 0.5.0 but got ${bindingPackageVersion}. You can reinstall dependencies to fix this issue.`)
+        }
+        return binding
+      } catch (e) {
+        loadErrors.push(e)
+      }
+    } else {
+      loadErrors.push(new Error(`Unsupported architecture on Linux: ${process.arch}`))
+    }
+  } else if (process.platform === 'openharmony') {
+    if (process.arch === 'arm64') {
+      try {
+        return require('./cdp-driver.openharmony-arm64.node')
+      } catch (e) {
+        loadErrors.push(e)
+      }
+      try {
+        const binding = require('cdp-driver-openharmony-arm64')
+        const bindingPackageVersion = require('cdp-driver-openharmony-arm64/package.json').version
+        if (bindingPackageVersion !== '0.5.0' && process.env.NAPI_RS_ENFORCE_VERSION_CHECK && process.env.NAPI_RS_ENFORCE_VERSION_CHECK !== '0') {
+          throw new Error(`Native binding package version mismatch, expected 0.5.0 but got ${bindingPackageVersion}. You can reinstall dependencies to fix this issue.`)
+        }
+        return binding
+      } catch (e) {
+        loadErrors.push(e)
+      }
+    } else if (process.arch === 'x64') {
+      try {
+        return require('./cdp-driver.openharmony-x64.node')
+      } catch (e) {
+        loadErrors.push(e)
+      }
+      try {
+        const binding = require('cdp-driver-openharmony-x64')
+        const bindingPackageVersion = require('cdp-driver-openharmony-x64/package.json').version
+        if (bindingPackageVersion !== '0.5.0' && process.env.NAPI_RS_ENFORCE_VERSION_CHECK && process.env.NAPI_RS_ENFORCE_VERSION_CHECK !== '0') {
+          throw new Error(`Native binding package version mismatch, expected 0.5.0 but got ${bindingPackageVersion}. You can reinstall dependencies to fix this issue.`)
+        }
+        return binding
+      } catch (e) {
+        loadErrors.push(e)
+      }
+    } else if (process.arch === 'arm') {
+      try {
+        return require('./cdp-driver.openharmony-arm.node')
+      } catch (e) {
+        loadErrors.push(e)
+      }
+      try {
+        const binding = require('cdp-driver-openharmony-arm')
+        const bindingPackageVersion = require('cdp-driver-openharmony-arm/package.json').version
+        if (bindingPackageVersion !== '0.5.0' && process.env.NAPI_RS_ENFORCE_VERSION_CHECK && process.env.NAPI_RS_ENFORCE_VERSION_CHECK !== '0') {
+          throw new Error(`Native binding package version mismatch, expected 0.5.0 but got ${bindingPackageVersion}. You can reinstall dependencies to fix this issue.`)
+        }
+        return binding
+      } catch (e) {
+        loadErrors.push(e)
+      }
+    } else {
+      loadErrors.push(new Error(`Unsupported architecture on OpenHarmony: ${process.arch}`))
+    }
+  } else {
+    loadErrors.push(new Error(`Unsupported OS: ${process.platform}, architecture: ${process.arch}`))
+  }
+}
+
+function createLoadErrorChain(errors) {
+  return errors.reduce((previous, current) => {
+    let message
+    try {
+      message =
+        current && typeof current.message === 'string'
+          ? current.message
+          : String(current)
+    } catch {
+      message = 'Unknown error'
+    }
+    const error = new Error(message)
+    error.cause = previous
+    return error
+  }, null)
+}
+
+// NAPI_RS_FORCE_WASI is a tri-state flag:
+//   unset / any other value → native binding preferred, WASI is only a fallback
+//   'true'                   → prefer WASI, but retain native as a lazy fallback
+//   'error'                  → require WASI without initializing a native fallback
+// Treating any non-empty string as truthy (the historical behavior) meant
+// NAPI_RS_FORCE_WASI=false, NAPI_RS_FORCE_WASI=0, etc. inadvertently triggered
+// the WASI path, causing ENOENT for packages shipped without a .wasi.cjs file.
+//
+// NAPI_RS_WASI_FLAVOR selects one exact generated flavor and implies strict
+// WASI loading. It never crosses into another flavor or falls back to native.
+const __napiWasiFlavors = ['wasm32-wasi']
+const __napiWasiFlavor = process.env.NAPI_RS_WASI_FLAVOR
+const __napiWasiFlavorRequested =
+  typeof __napiWasiFlavor === 'string' && __napiWasiFlavor.length > 0
+if (
+  __napiWasiFlavorRequested &&
+  __napiWasiFlavors.indexOf(__napiWasiFlavor) === -1
+) {
+  throw new Error(
+    'Unsupported WASI flavor "' +
+      __napiWasiFlavor +
+      '". Available flavors: ' +
+      __napiWasiFlavors.join(', '),
+  )
+}
+const forceWasiError = process.env.NAPI_RS_FORCE_WASI === 'error'
+const forceWasi =
+  process.env.NAPI_RS_FORCE_WASI === 'true' ||
+  forceWasiError ||
+  __napiWasiFlavorRequested
+
+if (!forceWasi) {
+  nativeBinding = requireNative()
+  __napiRequiredNativeBinding = nativeBinding
+}
+
+if (!nativeBinding || forceWasi) {
+  let wasiBinding = null
+  let wasiBindingLoaded = false
+  const wasiBindingErrors = []
+  const __napiWasiResolveCandidate = (specifier, isPackage, localArtifacts) => {
+    try {
+      require.resolve(specifier)
+    } catch (resolveError) {
+      if (!resolveError || resolveError.code !== 'MODULE_NOT_FOUND') {
+        throw resolveError
+      }
+      if (isPackage) {
+        try {
+          require.resolve(specifier + '/package.json')
+        } catch (packageError) {
+          if (packageError && packageError.code === 'MODULE_NOT_FOUND') {
+            return resolveError
+          }
+          // An exports restriction proves the package exists even when its
+          // package.json is not public. Preserve the root resolution failure.
+          throw resolveError
+        }
+        // The package exists but its main/export target is broken.
+        throw resolveError
+      }
+      return resolveError
+    }
+    if (localArtifacts) {
+      let artifactError = null
+      for (let i = 0; i < localArtifacts.length; i++) {
+        try {
+          require.resolve(localArtifacts[i])
+          return null
+        } catch (resolveError) {
+          if (!resolveError || resolveError.code !== 'MODULE_NOT_FOUND') {
+            throw resolveError
+          }
+          artifactError = resolveError
+        }
+      }
+      return artifactError
+    }
+    return null
+  }
+  if (!wasiBindingLoaded && (!__napiWasiFlavorRequested || __napiWasiFlavor === 'wasm32-wasi')) {
+    let candidateError = null
+    let candidateFailed = false
+    try {
+      candidateError = __napiWasiResolveCandidate('./cdp-driver.wasi.cjs', false, ['./cdp-driver.wasm32-wasi.debug.wasm', './cdp-driver.wasm32-wasi.wasm'])
+      candidateFailed = candidateError !== null
+      if (!candidateFailed) {
+        wasiBinding = require('./cdp-driver.wasi.cjs')
+        nativeBinding = wasiBinding
+        __napiLoadedBindingTarget = 'wasm32-wasi'
+        wasiBindingLoaded = true
+      }
+    } catch (err) {
+      candidateError = err
+      candidateFailed = true
+    }
+    if (candidateFailed) {
+      wasiBindingErrors.push(candidateError)
+      loadErrors.push(candidateError)
+    }
+  }
+  if (!wasiBindingLoaded && (!__napiWasiFlavorRequested || __napiWasiFlavor === 'wasm32-wasi')) {
+    let candidateError = null
+    let candidateFailed = false
+    try {
+      candidateError = __napiWasiResolveCandidate('cdp-driver-wasm32-wasi', true, undefined)
+      candidateFailed = candidateError !== null
+      if (!candidateFailed) {
+        if (process.env.NAPI_RS_ENFORCE_VERSION_CHECK && process.env.NAPI_RS_ENFORCE_VERSION_CHECK !== '0') {
+          const bindingPackageVersion = require('cdp-driver-wasm32-wasi/package.json').version
+          if (bindingPackageVersion !== '0.5.0') {
+            throw new Error(`WASI binding package version mismatch, expected 0.5.0 but got ${bindingPackageVersion}. You can reinstall dependencies to fix this issue.`)
+          }
+        }
+        wasiBinding = require('cdp-driver-wasm32-wasi')
+        nativeBinding = wasiBinding
+        __napiLoadedBindingTarget = 'wasm32-wasi'
+        wasiBindingLoaded = true
+      }
+    } catch (err) {
+      candidateError = err
+      candidateFailed = true
+    }
+    if (candidateFailed) {
+      wasiBindingErrors.push(candidateError)
+      loadErrors.push(candidateError)
+    }
+  }
+  if (
+    !wasiBindingLoaded &&
+    forceWasi &&
+    !forceWasiError &&
+    !__napiWasiFlavorRequested
+  ) {
+    nativeBinding = requireNative()
+    __napiRequiredNativeBinding = nativeBinding
+  }
+  if ((forceWasiError || __napiWasiFlavorRequested) && !wasiBindingLoaded) {
+    const error = new Error(
+      __napiWasiFlavorRequested
+        ? 'WASI binding for flavor "' + __napiWasiFlavor + '" not found'
+        : 'WASI binding not found and NAPI_RS_FORCE_WASI is set to error',
+    )
+    error.cause = createLoadErrorChain(wasiBindingErrors)
+    throw error
+  }
+}
+
+if (!nativeBinding) {
+  if (loadErrors.length > 0) {
+    const error = new Error(
+      `Cannot find native binding. ` +
+        `npm has a bug related to optional dependencies (https://github.com/npm/cli/issues/4828). ` +
+        'Please try `npm i` again after removing both package-lock.json and node_modules directory.',
+    )
+    // assign instead of the `new Error(message, { cause })` options form,
+    // which Node < 16.9 silently ignores
+    error.cause = createLoadErrorChain(loadErrors)
+    throw error
+  }
+  throw new Error(`Failed to load native binding`)
+}
+
+// A package can patch its own fallback in front of the load-failure check
+// above, e.g. a WebContainer download through `napi-postinstall/fallback`.
+// That fallback swaps `nativeBinding` for a generated WASI loader, which has
+// already stamped its own flavor, while the target above still says 'native'.
+// Take that flavor over, or the CommonJS stamp throws a conflict and the ESM
+// export reports the wrong artifact. Three limits keep the conflict check:
+// - only a binding this loader did not load itself, so a native addon whose
+//   `#[napi(module_exports)]` hook claims the name is still rejected;
+// - only an own data property, read through its descriptor, so no addon
+//   getter runs here, and it must read back the same, as the stamp reads it;
+// - only a flavor in `__napiWasiFlavors`, the ones this loader's own WASI
+//   chain can report ('wasm32-wasi' for a package without a WASI target).
+// This is metadata and never fails a load: a throwing Proxy trap keeps 'native'.
+if (
+  __napiLoadedBindingTarget === 'native' &&
+  nativeBinding !== __napiRequiredNativeBinding
+) {
+  try {
+    const __napiBindingTargetDescriptor = Object.getOwnPropertyDescriptor(
+      nativeBinding,
+      '__napiBindingTarget',
+    )
+    if (
+      __napiBindingTargetDescriptor &&
+      __napiWasiFlavors.indexOf(__napiBindingTargetDescriptor.value) !== -1 &&
+      nativeBinding.__napiBindingTarget === __napiBindingTargetDescriptor.value
+    ) {
+      __napiLoadedBindingTarget = __napiBindingTargetDescriptor.value
+    }
+  } catch {
+    // keep 'native'
+  }
+}
+
+function __napiStampBindingTarget(exportsObject, target) {
+  if (
+    Object.prototype.hasOwnProperty.call(exportsObject, '__napiBindingTarget')
+  ) {
+    if (exportsObject.__napiBindingTarget === target) {
+      // Already ours: the root entry aliases the object it loaded, so a WASI
+      // fallback candidate — or a `NAPI_RS_NATIVE_LIBRARY_PATH` override that
+      // is a generated loader — arrives already stamped with this same value.
+      return target
+    }
+    const error = new Error(
+      '`__napiBindingTarget` is reserved by the generated binding loader, but the loaded binding already exports it. Rename the export, e.g. #[napi(js_name = "...")].',
+    )
+    error.code = 'ERR_NAPI_BINDING_TARGET_CONFLICT'
+    throw error
+  }
+  if (!Object.isExtensible(exportsObject)) {
+    // A `#[napi(module_exports)]` hook may seal or freeze this object
+    // (`Object::seal` / `Object::freeze`). Reporting the artifact is metadata,
+    // never a reason to fail an otherwise successful load, so the stamp is
+    // skipped. What a consumer still sees then follows the entry point: the
+    // browser and deferred loaders declare `__napiBindingTarget` at module
+    // level and go on reporting it, while the CommonJS entries hand back this
+    // very object as `module.exports`, so there the value is absent.
+    return target
+  }
+  try {
+    // [[Define]], not [[Set]]: an ordinary assignment walks the prototype
+    // chain, so an inherited accessor could swallow the value or throw and
+    // fail an otherwise successful load. The descriptor is what a successful
+    // assignment would have produced.
+    Object.defineProperty(exportsObject, '__napiBindingTarget', {
+      configurable: true,
+      enumerable: true,
+      value: target,
+      writable: true,
+    })
+  } catch {
+    // Same rule as the non-extensible skip above: reporting the artifact is
+    // metadata, never a reason to fail an otherwise successful load. An exotic
+    // object (a Proxy whose defineProperty trap refuses) is skipped, not
+    // thrown over.
+  }
+  // The CommonJS loaders assign this return value so `cjs-module-lexer` — and
+  // therefore Node's CJS -> ESM named export detection — can see
+  // `__napiBindingTarget` statically.
+  return target
+}
+// Stamp before the alias, not after. The guard only reads `nativeBinding`
+// (`hasOwnProperty` plus a comparison), which is safe against any addon
+// accessor; an assignment is not, because a `#[napi(module_exports)]` hook can
+// expose a getter reporting this very value and a setter that throws. So the
+// assignment lands on the loader's own `module.exports`, still the original
+// object here, and the alias below replaces it.
+//
+// The assignment is what keeps the marker a statically visible CommonJS export:
+// `cjs-module-lexer` is Node's CJS -> ESM named export detection, it cannot see
+// a bare call, and the later `module.exports = nativeBinding` does not undo the
+// detection. The assignment itself always succeeds — its target is this
+// loader's own, still extensible `module.exports` — and the alias below then
+// discards the value it wrote. What a consumer reads is whatever the guard put
+// on `nativeBinding`, so on a frozen binding, where the guard skips, the
+// linked import resolves to `undefined`.
+module.exports.__napiBindingTarget = __napiStampBindingTarget(nativeBinding, __napiLoadedBindingTarget)
+module.exports = nativeBinding
+module.exports.BrowserAgent = nativeBinding.BrowserAgent
+module.exports.CdpClient = nativeBinding.CdpClient
+module.exports.Cluster = nativeBinding.Cluster

package/package.json

@@ -1,6 +1,57 @@
 {
   "name": "cdp-driver",
-  "version": "0.0.0-stage",
-  "stub": true,
-  "description": "Temporary package placeholder for staged publishing"
-}
+  "version": "0.5.0",
+  "description": "Chrome DevTools Protocol client for Node/Deno/Bun, powered by Rust (napi-rs)",
+  "main": "index.js",
+  "types": "index.d.ts",
+  "license": "MIT",
+  "author": "Rakibul Yeasin <ryeasin03@gmail.com>",
+  "repository": "https://github.com/dreygur/cdp-protocol",
+  "keywords": [
+    "cdp",
+    "chrome-devtools-protocol",
+    "browser-automation",
+    "headless-chrome",
+    "scraping",
+    "napi-rs"
+  ],
+  "napi": {
+    "binaryName": "cdp-driver",
+    "targets": [
+      "x86_64-apple-darwin",
+      "x86_64-pc-windows-msvc",
+      "x86_64-unknown-linux-gnu",
+      "aarch64-apple-darwin",
+      "aarch64-unknown-linux-gnu"
+    ]
+  },
+  "engines": {
+    "node": ">= 16"
+  },
+  "scripts": {
+    "build": "napi build --platform --release",
+    "build:debug": "napi build --platform",
+    "prepublishOnly": "node version-check.mjs && napi prepublish -t npm",
+    "version-check": "node version-check.mjs",
+    "test": "node test.mjs",
+    "load-test": "node load-test.mjs",
+    "example:basic": "node examples/basic.mjs",
+    "example:agent": "node examples/agent.mjs",
+    "example:cluster": "node examples/cluster.mjs",
+    "example:industrial": "node examples/industrial.mjs"
+  },
+  "devDependencies": {
+    "@napi-rs/cli": "^3.10.12"
+  },
+  "files": [
+    "index.js",
+    "index.d.ts"
+  ],
+  "optionalDependencies": {
+    "cdp-driver-darwin-x64": "0.5.0",
+    "cdp-driver-win32-x64-msvc": "0.5.0",
+    "cdp-driver-linux-x64-gnu": "0.5.0",
+    "cdp-driver-darwin-arm64": "0.5.0",
+    "cdp-driver-linux-arm64-gnu": "0.5.0"
+  }
+}