@orkestrel/browser 0.0.1

package/dist/src/server/index.cjs

@@ -0,0 +1,1172 @@
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+let _src_core = require("../core/index.cjs");
+let node_fs = require("node:fs");
+let node_path = require("node:path");
+let node_child_process = require("node:child_process");
+let _orkestrel_contract = require("@orkestrel/contract");
+let node_crypto = require("node:crypto");
+let node_http = require("node:http");
+let _orkestrel_emitter = require("@orkestrel/emitter");
+let _orkestrel_websocket = require("@orkestrel/websocket");
+let node_fs_promises = require("node:fs/promises");
+//#region src/server/constants.ts
+/** Default CDP port probed for an existing browser and used for launches. */
+var BROWSER_DEFAULT_CDP_PORT = 9222;
+/** Default host probed for an existing browser and used for launches (avoids `localhost` resolving to `::1` when Chromium binds `127.0.0.1`). */
+var BROWSER_DEFAULT_HOST = "127.0.0.1";
+/** Protocol prefix for CDP discovery requests. */
+var BROWSER_CDP_PROTOCOL = "http";
+/** Path appended to the CDP host to fetch version metadata (endpoint discovery). */
+var BROWSER_CDP_VERSION_PATH = "/json/version";
+/** Path appended to the CDP host to list open targets (pages, workers, etc). */
+var BROWSER_CDP_LIST_PATH = "/json/list";
+/** Sentinel result returned by discovery when no browser is reachable. */
+var BROWSER_NOT_FOUND_RESULT = Object.freeze({
+	found: false,
+	endpoint: void 0,
+	browser: void 0,
+	connection: void 0
+});
+/** Flags always passed to a launched browser process, alongside the caller's own. */
+var BROWSER_LAUNCH_ARGS = Object.freeze(["--no-first-run", "--no-default-browser-check"]);
+/** Flag enabling headless mode on a launched browser process. */
+var BROWSER_HEADLESS_ARG = "--headless=new";
+/** Grace period after SIGTERM before a launched process is escalated to SIGKILL during teardown. */
+var BROWSER_KILL_GRACE_MS = 3e3;
+/** Bound for the `discover: false` port-occupancy probe before launching — short, since it only needs to detect an already-listening CDP endpoint, not perform full discovery. */
+var BROWSER_PORT_PROBE_TIMEOUT_MS = 200;
+/** Brief defer applied once when a transport loss is observed on an owned process, giving a near-simultaneous process-exit event (which libuv may reap slightly later than the socket close) first say over the diagnosis. */
+var BROWSER_TRANSPORT_LOSS_DEFER_MS = 50;
+/** Environment variables checked (in order) for an explicit browser executable path override. */
+var BROWSER_ENV_PATH_KEYS = Object.freeze(["PLAYWRIGHT_EXECUTABLE_PATH", "CHROME_PATH"]);
+/** Well-known Chrome/Chromium/Edge executable paths with no platform-specific root, keyed by `process.platform`. */
+var BROWSER_EXECUTABLE_PATHS = Object.freeze({
+	linux: Object.freeze([
+		"/usr/bin/google-chrome",
+		"/usr/bin/google-chrome-stable",
+		"/usr/bin/microsoft-edge",
+		"/usr/bin/microsoft-edge-stable",
+		"/usr/bin/chromium",
+		"/usr/bin/chromium-browser",
+		"/snap/bin/chromium",
+		"/opt/google/chrome/chrome",
+		"/opt/microsoft/msedge/msedge"
+	]),
+	darwin: Object.freeze([
+		"/Applications/Google Chrome.app/Contents/MacOS/Google Chrome",
+		"/Applications/Microsoft Edge.app/Contents/MacOS/Microsoft Edge",
+		"/Applications/Chromium.app/Contents/MacOS/Chromium"
+	]),
+	win32: Object.freeze([])
+});
+/** Windows install-root-relative suffixes for Chrome/Edge/Chromium, joined against each candidate root (`PROGRAMFILES`, `PROGRAMFILES(X86)`, `LOCALAPPDATA`). */
+var BROWSER_WINDOWS_SUFFIXES = Object.freeze([
+	"Google\\Chrome\\Application\\chrome.exe",
+	"Microsoft\\Edge\\Application\\msedge.exe",
+	"Chromium\\Application\\chrome.exe"
+]);
+/** Fallback Windows install roots used when the corresponding environment variable is absent. */
+var BROWSER_WINDOWS_ROOT_FALLBACKS = Object.freeze({
+	PROGRAMFILES: "C:\\Program Files",
+	"PROGRAMFILES(X86)": "C:\\Program Files (x86)"
+});
+/** Command names probed on PATH when no well-known executable path exists. */
+var BROWSER_EXECUTABLE_NAMES = Object.freeze([
+	"google-chrome",
+	"google-chrome-stable",
+	"msedge",
+	"microsoft-edge",
+	"chromium",
+	"chromium-browser",
+	"chrome"
+]);
+/** Environment variable naming an additional Playwright browser store base directory. */
+var BROWSER_STORE_ENV_KEY = "PLAYWRIGHT_BROWSERS_PATH";
+/** Well-known Playwright browser store base directories checked in addition to `PLAYWRIGHT_BROWSERS_PATH`. */
+var BROWSER_STORE_DEFAULT_DIRS = Object.freeze(["/opt/pw-browsers"]);
+/** Per-OS default Playwright browser cache directory, relative to the home directory (win32 uses `LOCALAPPDATA` directly). */
+var BROWSER_STORE_CACHE_DIRS = Object.freeze({
+	linux: ".cache/ms-playwright",
+	darwin: "Library/Caches/ms-playwright"
+});
+/** Name of the top-level Chromium symlink/binary Playwright maintains inside a browser store base. */
+var BROWSER_STORE_LINK_NAME = "chromium";
+/**
+* Case-insensitive substrings identifying an executable path/name's browser
+* engine, checked by `parseBrowserEngine` in the order `edge` → `chromium` → `chrome`.
+*/
+var BROWSER_ENGINE_HINTS = Object.freeze({
+	edge: Object.freeze([
+		"msedge",
+		"microsoft-edge",
+		"edge"
+	]),
+	chromium: Object.freeze([
+		"chromium",
+		"pw-browsers",
+		"chrome-linux",
+		"chrome-win",
+		"chrome-mac",
+		"chrome_headless"
+	]),
+	chrome: Object.freeze([
+		"google-chrome",
+		"google/chrome",
+		"google\\chrome",
+		"chrome"
+	])
+});
+/** Glob pattern (relative to a store base) matching a versioned Chromium binary, keyed by `process.platform`. */
+var BROWSER_STORE_GLOBS = Object.freeze({
+	linux: "chromium-*/chrome-linux*/chrome",
+	darwin: "chromium-*/chrome-mac*/Chromium.app/Contents/MacOS/Chromium",
+	win32: "chromium-*/chrome-win*/chrome.exe"
+});
+//#endregion
+//#region src/server/errors.ts
+/**
+* A CDP connection, discovery, or launch attempt failed.
+*/
+var BrowserConnectionError = class extends _src_core.BrowserError {
+	constructor(message, context) {
+		super(message, "BROWSER_CONNECTION_ERROR", context);
+		this.name = "BrowserConnectionError";
+	}
+};
+/**
+* An operation requiring an active connection was attempted while disconnected.
+*/
+var BrowserNotConnectedError = class extends _src_core.BrowserError {
+	constructor(context) {
+		super("Browser is not connected", "BROWSER_NOT_CONNECTED_ERROR", context);
+		this.name = "BrowserNotConnectedError";
+	}
+};
+/**
+* An operation was attempted after the Browser was destroyed.
+*/
+var BrowserDestroyedError = class extends _src_core.BrowserError {
+	constructor(context) {
+		super("Browser has been destroyed", "BROWSER_DESTROYED_ERROR", context);
+		this.name = "BrowserDestroyedError";
+	}
+};
+/**
+* Narrow an unknown value to BrowserConnectionError.
+*
+* @param value - Value to check
+* @returns True when value is a BrowserConnectionError instance
+*/
+function isBrowserConnectionError(value) {
+	return value instanceof BrowserConnectionError;
+}
+/**
+* Narrow an unknown value to BrowserNotConnectedError.
+*
+* @param value - Value to check
+* @returns True when value is a BrowserNotConnectedError instance
+*/
+function isBrowserNotConnectedError(value) {
+	return value instanceof BrowserNotConnectedError;
+}
+/**
+* Narrow an unknown value to BrowserDestroyedError.
+*
+* @param value - Value to check
+* @returns True when value is a BrowserDestroyedError instance
+*/
+function isBrowserDestroyedError(value) {
+	return value instanceof BrowserDestroyedError;
+}
+//#endregion
+//#region src/server/helpers.ts
+/**
+* Enumerate every Chrome/Chromium/Edge executable discoverable on this
+* machine, deduplicated by normalized absolute path.
+*
+* @remarks
+* Resolution precedence (candidates appended in this order):
+* 1. `PLAYWRIGHT_EXECUTABLE_PATH`, then `CHROME_PATH` — explicit environment
+*    overrides that exist on disk
+* 2. Well-known platform install locations (Chrome, Edge, Chromium); Windows
+*    roots are derived from `PROGRAMFILES` / `PROGRAMFILES(X86)` / `LOCALAPPDATA`
+* 3. PATH probe for known command names (`which` on POSIX, `where` on Windows)
+* 4. Playwright-managed browser stores (`PLAYWRIGHT_BROWSERS_PATH`, `/opt/pw-browsers`,
+*    and the per-OS Playwright cache directory) — the top-level `chromium`
+*    link/binary, then the highest-revision `chromium-*` install found
+*
+* Each candidate is classified into a {@link BrowserEngine} via
+* `parseBrowserEngine` (unclassifiable candidates default to `'chromium'`),
+* and `options.engine` (when given) narrows the result to that engine.
+*
+* @param options - Overrides for the candidate sources; see {@link SystemBrowserOptions}
+* @returns Every discovered browser, in resolution-precedence order
+*/
+function findSystemBrowsers(options) {
+	const platform = process.platform;
+	const env = options?.env ?? process.env;
+	const candidates = [];
+	candidates.push(...findAllEnvOverrides(env));
+	const paths = options?.paths ?? defaultInstallPaths(platform, env);
+	candidates.push(...findAllInstallPaths(paths));
+	const names = options?.names ?? BROWSER_EXECUTABLE_NAMES;
+	candidates.push(...probeAllPathNames(names, platform));
+	const stores = options?.stores ?? defaultStoreBases(env, platform);
+	for (const store of stores) candidates.push(...findAllInStore(store, platform));
+	const seen = /* @__PURE__ */ new Set();
+	const browsers = [];
+	for (const executable of candidates) {
+		const key = normalizeExecutablePath(executable, platform);
+		if (seen.has(key)) continue;
+		seen.add(key);
+		const engine = parseBrowserEngine(executable) ?? "chromium";
+		if (options?.engine !== void 0 && engine !== options.engine) continue;
+		browsers.push({
+			executable,
+			engine
+		});
+	}
+	return browsers;
+}
+/**
+* Locate a Chrome/Chromium/Edge executable on this machine — the first entry
+* of {@link findSystemBrowsers}.
+*
+* @param options - Overrides for the candidate sources; see {@link SystemBrowserOptions}
+* @returns The first discovered browser, or undefined
+*/
+function findSystemBrowser(options) {
+	return findSystemBrowsers(options)[0];
+}
+/**
+* Classify an executable path/name into a {@link BrowserEngine} by
+* case-insensitive hint, checked in the order edge → chromium → chrome.
+*
+* @param executable - Executable path or command name to classify
+* @returns The classified engine, or undefined when no hint matches
+*/
+function parseBrowserEngine(executable) {
+	const lower = executable.toLowerCase();
+	for (const engine of [
+		"edge",
+		"chromium",
+		"chrome"
+	]) if (BROWSER_ENGINE_HINTS[engine].some((hint) => lower.includes(hint))) return engine;
+}
+/** Normalize an executable path for cross-source deduplication (case-insensitive on Windows). */
+function normalizeExecutablePath(path, platform) {
+	const normalized = platform === "win32" ? node_path.win32.normalize(path) : node_path.posix.normalize(path);
+	return platform === "win32" ? normalized.toLowerCase() : normalized;
+}
+/** Classify a `/json/version` `Browser` string into a {@link BrowserEngine} (`Edg/` → edge, `Chrome/` → chrome, else chromium). */
+function browserToEngine(browser) {
+	if (browser.includes("Edg/")) return "edge";
+	if (browser.includes("Chrome/")) return "chrome";
+	return "chromium";
+}
+/** Check the env-override keys (`PLAYWRIGHT_EXECUTABLE_PATH`, `CHROME_PATH`) in order for an existing file. */
+function findEnvOverride(env) {
+	return findAllEnvOverrides(env)[0];
+}
+/** Check the env-override keys (`PLAYWRIGHT_EXECUTABLE_PATH`, `CHROME_PATH`) in order, returning every one that exists. */
+function findAllEnvOverrides(env) {
+	const found = [];
+	for (const key of BROWSER_ENV_PATH_KEYS) {
+		const value = env[key];
+		if (value !== void 0 && value.length > 0 && (0, node_fs.existsSync)(value)) found.push(value);
+	}
+	return found;
+}
+/** Build the default well-known install-path candidates for a platform, deriving Windows roots from env vars. */
+function defaultInstallPaths(platform, env) {
+	if (platform !== "win32") return BROWSER_EXECUTABLE_PATHS[platform] ?? [];
+	const roots = windowsRoots(env);
+	const paths = [];
+	for (const root of roots) for (const suffix of BROWSER_WINDOWS_SUFFIXES) paths.push(node_path.win32.join(root, suffix));
+	return paths;
+}
+/** Derive Windows install roots from env vars, falling back to well-known literals when absent. */
+function windowsRoots(env) {
+	return [
+		env["PROGRAMFILES"] ?? BROWSER_WINDOWS_ROOT_FALLBACKS["PROGRAMFILES"],
+		env["PROGRAMFILES(X86)"] ?? BROWSER_WINDOWS_ROOT_FALLBACKS["PROGRAMFILES(X86)"],
+		env["LOCALAPPDATA"]
+	].filter((root) => root !== void 0);
+}
+/** Return the first candidate path that exists on disk. */
+function findInstallPath(paths) {
+	return findAllInstallPaths(paths)[0];
+}
+/** Return every candidate path that exists on disk, in the given order. */
+function findAllInstallPaths(paths) {
+	return paths.filter((path) => (0, node_fs.existsSync)(path));
+}
+/** Probe PATH (`which`/`where`) for the first resolvable command name. */
+function probePathNames(names, platform) {
+	return probeAllPathNames(names, platform)[0];
+}
+/** Probe PATH (`which`/`where`) for every resolvable command name, in the given order. */
+function probeAllPathNames(names, platform) {
+	const finder = platform === "win32" ? "where" : "which";
+	const found = [];
+	for (const name of names) {
+		const result = (0, node_child_process.spawnSync)(finder, [name], { stdio: "pipe" });
+		if (result.status === 0) {
+			const output = result.stdout.toString("utf-8").trim().split("\n")[0];
+			if (output !== void 0 && output.length > 0) found.push(output);
+		}
+	}
+	return found;
+}
+/** Build the default Playwright browser store base directories to search for a managed Chromium. */
+function defaultStoreBases(env, platform) {
+	const bases = [];
+	const envBase = env[BROWSER_STORE_ENV_KEY];
+	if (envBase !== void 0 && envBase.length > 0) bases.push(envBase);
+	bases.push(...BROWSER_STORE_DEFAULT_DIRS);
+	if (platform === "win32") {
+		const localAppData = env["LOCALAPPDATA"];
+		if (localAppData !== void 0) bases.push(node_path.win32.join(localAppData, "ms-playwright"));
+	} else {
+		const cacheDir = BROWSER_STORE_CACHE_DIRS[platform];
+		const home = env["HOME"];
+		if (cacheDir !== void 0 && home !== void 0) bases.push(node_path.posix.join(home, cacheDir));
+	}
+	return bases;
+}
+/** Search one store base for the top-level `chromium` link, else the highest-revision `chromium-*` install. */
+function findInStore(base, platform) {
+	return findAllInStore(base, platform)[0];
+}
+/** Search one store base for the top-level `chromium` link and every `chromium-*` install, highest revision first. */
+function findAllInStore(base, platform) {
+	const joiner = platform === "win32" ? node_path.win32.join : node_path.posix.join;
+	const found = [];
+	const linkPath = joiner(base, BROWSER_STORE_LINK_NAME);
+	if ((0, node_fs.existsSync)(linkPath)) found.push(linkPath);
+	const glob = BROWSER_STORE_GLOBS[platform];
+	if (glob === void 0) return found;
+	const matches = (0, node_fs.globSync)(`${base.replaceAll("\\", "/")}/${glob}`).filter((match) => (0, node_fs.existsSync)(match));
+	matches.sort((a, b) => a < b ? 1 : a > b ? -1 : 0);
+	found.push(...matches);
+	return found;
+}
+/**
+* Launch a browser process with raw-CDP debugging flags.
+*
+* @param executable - Absolute path to the browser executable
+* @param port - Port the browser exposes its CDP endpoint on
+* @param headless - Whether to launch in headless mode
+* @param profile - Optional user-data-dir for a persistent profile
+* @param extra - Additional command-line flags
+* @returns The spawned ChildProcess
+*/
+function launchBrowserProcess(executable, port, headless, profile, extra) {
+	const args = [];
+	if (extra !== void 0) args.push(...extra);
+	args.push(`--remote-debugging-port=${port}`, ...BROWSER_LAUNCH_ARGS);
+	if (headless) args.push(BROWSER_HEADLESS_ARG);
+	if (profile !== void 0) args.push(`--user-data-dir=${profile}`);
+	return (0, node_child_process.spawn)(executable, args, { stdio: "ignore" });
+}
+/**
+* Poll a browser's CDP version endpoint until it responds or the timeout elapses.
+*
+* @param port - Port the browser exposes its CDP endpoint on
+* @param timeout - Maximum time to wait in milliseconds
+* @param host - Host the browser exposes its CDP endpoint on (default `127.0.0.1`)
+* @returns The browser's WebSocket debugger URL
+*
+* @throws When the endpoint does not become ready before the timeout
+*/
+async function waitForCdpReady(port, timeout, host = BROWSER_DEFAULT_HOST) {
+	const url = `${BROWSER_CDP_PROTOCOL}://${host}:${port}${BROWSER_CDP_VERSION_PATH}`;
+	const deadline = Date.now() + timeout;
+	while (Date.now() < deadline) {
+		const remaining = Math.max(0, deadline - Date.now());
+		const controller = new AbortController();
+		const timer = setTimeout(() => controller.abort(), remaining);
+		try {
+			const response = await fetch(url, { signal: controller.signal });
+			if (response.ok) {
+				const info = await response.json();
+				if ((0, _orkestrel_contract.isRecord)(info) && (0, _orkestrel_contract.isString)(info["webSocketDebuggerUrl"])) return info["webSocketDebuggerUrl"];
+			}
+		} catch {} finally {
+			clearTimeout(timer);
+		}
+		await new Promise((resolve) => setTimeout(resolve, _src_core.BROWSER_WAIT_POLL_INTERVAL_MS));
+	}
+	throw new Error(`CDP endpoint on port ${port} did not become ready within ${timeout}ms`);
+}
+/**
+* Fetch the current CDP target list from a browser's `/json/list` endpoint.
+*
+* @param port - Port the browser exposes its CDP endpoint on
+* @param timeout - Request timeout in milliseconds
+* @param host - Host the browser exposes its CDP endpoint on (default `127.0.0.1`)
+* @returns Normalized CDP targets
+*/
+async function fetchCdpTargets(port, timeout, host = BROWSER_DEFAULT_HOST) {
+	const url = `${BROWSER_CDP_PROTOCOL}://${host}:${port}${BROWSER_CDP_LIST_PATH}`;
+	const controller = new AbortController();
+	const timer = setTimeout(() => controller.abort(), timeout);
+	try {
+		const response = await fetch(url, { signal: controller.signal });
+		if (!response.ok) return [];
+		const list = await response.json();
+		if (!Array.isArray(list)) return [];
+		const targets = [];
+		for (const entry of list) {
+			if (!(0, _orkestrel_contract.isRecord)(entry)) continue;
+			if (!(0, _orkestrel_contract.isString)(entry["id"]) || !(0, _orkestrel_contract.isString)(entry["type"])) continue;
+			targets.push({
+				id: entry["id"],
+				type: entry["type"],
+				title: (0, _orkestrel_contract.isString)(entry["title"]) ? entry["title"] : "",
+				url: (0, _orkestrel_contract.isString)(entry["url"]) ? entry["url"] : ""
+			});
+		}
+		return targets;
+	} catch {
+		return [];
+	} finally {
+		clearTimeout(timer);
+	}
+}
+//#endregion
+//#region src/server/transports/WebSocketCDPTransport.ts
+/**
+* `@orkestrel/websocket`-backed {@link CDPTransportInterface} — the dumb text
+* pipe a {@link import('@src/core').CDPClientInterface} sends and receives
+* JSON-RPC frames over.
+*
+* @remarks
+* `start()` hand-rolls the RFC 6455 client handshake: it opens a `node:http`
+* `GET` carrying `Connection: Upgrade` / `Upgrade: websocket` / a random
+* `Sec-WebSocket-Key` / `Sec-WebSocket-Version`, awaits the client `'upgrade'`
+* event, and validates `Sec-WebSocket-Accept === computeWebSocketAccept(key)`
+* — a mismatch (or a connection/request error, or a timeout) rejects `start()`
+* with a coded {@link BrowserConnectionError} and cleans up the socket. On
+* success it wraps the raw upgraded socket in `createNodeWebSocket({ socket,
+* head })` (CLIENT mode — no `key` — so outgoing frames are masked per RFC
+* 6455 §5.3) and bridges its `message`/`close`/`error` events onto this
+* transport's emitter. `start()` opens a fresh socket each call (safe to call
+* again after `close()` — a new request/socket/NodeWebSocket triple is
+* created every time, which is what `CDPClient.reconnect()` depends on). CDP
+* frames are text-only, so `message` always carries a `string`.
+*/
+var WebSocketCDPTransport = class {
+	#emitter;
+	#url;
+	#timeout;
+	#socket;
+	#connecting;
+	constructor(options) {
+		this.#emitter = new _orkestrel_emitter.Emitter();
+		this.#url = options.url;
+		this.#timeout = options.timeout ?? _src_core.BROWSER_DEFAULT_TIMEOUT_MS;
+	}
+	get emitter() {
+		return this.#emitter;
+	}
+	async start() {
+		const url = new URL(this.#url);
+		const key = (0, node_crypto.randomBytes)(16).toString("base64");
+		const ws = await new Promise((resolve, reject) => {
+			const settle = (fn) => {
+				this.#connecting = void 0;
+				fn();
+			};
+			const timer = setTimeout(() => {
+				request.destroy();
+				settle(() => reject(new BrowserConnectionError(`WebSocket CDP connection to ${this.#url} timed out after ${this.#timeout}ms`, {
+					url: this.#url,
+					timeout: this.#timeout
+				})));
+			}, this.#timeout);
+			const request = (0, node_http.request)({
+				hostname: url.hostname,
+				port: url.port.length > 0 ? Number(url.port) : 80,
+				path: `${url.pathname}${url.search}`,
+				headers: {
+					Connection: "Upgrade",
+					Upgrade: "websocket",
+					"Sec-WebSocket-Key": key,
+					"Sec-WebSocket-Version": _orkestrel_websocket.WEBSOCKET_VERSION
+				}
+			});
+			request.on("upgrade", (response, socket, head) => {
+				clearTimeout(timer);
+				const accept = response.headers["sec-websocket-accept"];
+				if (!(0, _orkestrel_contract.isString)(accept) || accept !== (0, _orkestrel_websocket.computeWebSocketAccept)(key)) {
+					socket.destroy();
+					settle(() => reject(new BrowserConnectionError(`WebSocket CDP connection to ${this.#url} failed: Sec-WebSocket-Accept mismatch`, { url: this.#url })));
+					return;
+				}
+				settle(() => resolve((0, _orkestrel_websocket.createNodeWebSocket)({
+					socket,
+					head
+				})));
+			});
+			request.on("response", (response) => {
+				clearTimeout(timer);
+				response.resume();
+				settle(() => reject(new BrowserConnectionError(`WebSocket CDP connection to ${this.#url} failed: upgrade declined with status ${response.statusCode ?? 0}`, { url: this.#url })));
+			});
+			request.on("error", (error) => {
+				clearTimeout(timer);
+				settle(() => reject(new BrowserConnectionError(`WebSocket CDP connection to ${this.#url} failed: ${error.message}`, { url: this.#url })));
+			});
+			this.#connecting = {
+				abort: () => request.destroy(),
+				timer,
+				reject: (error) => settle(() => reject(error))
+			};
+			request.end();
+		});
+		this.#socket = ws;
+		this.#bind(ws);
+	}
+	async send(data) {
+		const socket = this.#socket;
+		if (socket === void 0 || socket.readyState !== _orkestrel_websocket.WEBSOCKET_READY_OPEN) throw new Error("WebSocket CDP transport is not open");
+		socket.send(data);
+	}
+	async close() {
+		const connecting = this.#connecting;
+		if (connecting !== void 0) {
+			clearTimeout(connecting.timer);
+			this.#connecting = void 0;
+			connecting.abort();
+			connecting.reject(new BrowserConnectionError(`WebSocket CDP connection to ${this.#url} was closed before it finished connecting`, { url: this.#url }));
+			return;
+		}
+		const socket = this.#socket;
+		if (socket === void 0) return;
+		this.#socket = void 0;
+		await new Promise((resolve) => {
+			socket.emitter.on("close", () => resolve());
+			socket.close();
+		});
+	}
+	#bind(ws) {
+		ws.emitter.on("message", (data) => {
+			this.#emitter.emit("message", data);
+		});
+		ws.emitter.on("close", () => {
+			this.#emitter.emit("close");
+		});
+		ws.emitter.on("error", (error) => {
+			this.#emitter.emit("error", error);
+		});
+	}
+};
+//#endregion
+//#region src/server/factories.ts
+/**
+* Create a raw-CDP Browser façade.
+*
+* @param options - Connection, launch, and viewport configuration
+* @returns A {@link BrowserInterface}
+*
+* @example
+* ```ts
+* import { createBrowser } from '@src/server'
+*
+* const browser = createBrowser()
+* await browser.connect()
+* ```
+*/
+function createBrowser(options) {
+	return new Browser(options);
+}
+/**
+* Create a Node `WebSocket`-backed CDP transport.
+*
+* @param options - The CDP WebSocket debugger URL (and optional timeout)
+* @returns A {@link CDPTransportInterface}
+*/
+function createCDPTransport(options) {
+	return new WebSocketCDPTransport(options);
+}
+/**
+* Create a filesystem-backed screenshot writer.
+*
+* @returns A {@link ScreenshotWriterInterface} that persists bytes via `node:fs/promises`
+*/
+function createScreenshotWriter() {
+	return { async write(path, data) {
+		await (0, node_fs_promises.mkdir)((0, node_path.dirname)(path), { recursive: true });
+		await (0, node_fs_promises.writeFile)(path, data);
+	} };
+}
+//#endregion
+//#region src/server/Browser.ts
+var Browser = class {
+	#emitter;
+	#options;
+	#engine;
+	#status = "idle";
+	#connection;
+	#client;
+	#process;
+	#cdpPort;
+	#cdpHost;
+	#contexts = [];
+	#destroyed = false;
+	#transportUnbind;
+	#processUnbind;
+	#lastPid;
+	constructor(options) {
+		this.#emitter = new _orkestrel_emitter.Emitter({ on: options?.on });
+		this.#options = options ?? {};
+		this.#engine = this.#options.engine ?? (this.#options.executable !== void 0 ? parseBrowserEngine(this.#options.executable) ?? "chromium" : "chromium");
+		this.#cdpPort = this.#options.cdp?.port ?? 9222;
+		this.#cdpHost = this.#options.cdp?.host ?? "127.0.0.1";
+		queueMicrotask(() => this.#emitter.emit("idle"));
+	}
+	get emitter() {
+		return this.#emitter;
+	}
+	get engine() {
+		return this.#engine;
+	}
+	get status() {
+		return this.#status;
+	}
+	get connection() {
+		return this.#connection;
+	}
+	get connected() {
+		return this.#status === "connected";
+	}
+	get pid() {
+		return this.#process?.pid ?? this.#lastPid;
+	}
+	async discover() {
+		const result = await this.#discoverCdp();
+		this.#emitter.emit("discover", result);
+		return result;
+	}
+	async connect() {
+		if (this.#destroyed) throw new BrowserDestroyedError();
+		if (this.#status === "connected") return;
+		this.#assertNotAborted();
+		this.#status = "connecting";
+		try {
+			const cdpEndpoint = this.#options.cdp?.endpoint;
+			if (cdpEndpoint !== void 0) {
+				await this.#connectCdp(cdpEndpoint);
+				return;
+			}
+			if (this.#options.cdp?.discover ?? true) {
+				this.#assertNotAborted();
+				const discovery = await this.#raceAbort(this.#discoverCdp());
+				if (discovery.found && discovery.endpoint !== void 0) {
+					this.#engine = browserToEngine(discovery.browser ?? "");
+					await this.#connectCdp(discovery.endpoint);
+					return;
+				}
+			} else {
+				this.#assertNotAborted();
+				await this.#raceAbort(this.#assertPortFree());
+			}
+			this.#assertNotAborted();
+			await this.#launch();
+		} catch (thrown) {
+			this.#status = "error";
+			this.#emitter.emit("error", thrown);
+			if (thrown instanceof BrowserConnectionError) throw thrown;
+			throw new BrowserConnectionError(thrown instanceof Error ? thrown.message : String(thrown), { executable: this.#options.executable });
+		}
+	}
+	async disconnect() {
+		if (this.#destroyed || this.#status !== "connected") return;
+		if (this.#connection === "launch") throw new BrowserConnectionError("Cannot disconnect() an ephemeral launch — no persistent profile to reattach to; ephemeral launches must use destroy() to release it", { connection: this.#connection });
+		this.#unbindTransport();
+		this.#unbindProcess();
+		const client = this.#client;
+		if (client !== void 0) try {
+			await client.close();
+		} catch {}
+		if (this.#process?.pid !== void 0) this.#lastPid = this.#process.pid;
+		this.#process = void 0;
+		this.#reset();
+		this.#emitter.emit("disconnect");
+		this.#emitter.emit("idle");
+	}
+	context(index) {
+		const i = index ?? 0;
+		if (i < 0 || i >= this.#contexts.length) return void 0;
+		return this.#contexts[i];
+	}
+	contexts() {
+		return [...this.#contexts];
+	}
+	async create(options) {
+		if (this.#destroyed) throw new BrowserDestroyedError();
+		if (this.#status !== "connected" || this.#client === void 0) throw new BrowserNotConnectedError();
+		let ctx = this.#contexts[0];
+		if (ctx === void 0) {
+			ctx = new _src_core.BrowserContext(this.#client, void 0, this.#options.viewport, createScreenshotWriter());
+			this.#contexts.push(ctx);
+		}
+		const page = await ctx.create(options);
+		this.#emitter.emit("page", page);
+		return page;
+	}
+	async destroy() {
+		if (this.#destroyed) return;
+		this.#destroyed = true;
+		try {
+			this.#unbindTransport();
+			this.#unbindProcess();
+			if (this.#process !== void 0) for (const ctx of this.#contexts) try {
+				await ctx.close();
+			} catch {}
+			this.#contexts = [];
+			await this.#terminate(this.#process);
+			this.#process = void 0;
+			if (this.#client !== void 0) {
+				try {
+					await this.#client.close();
+				} catch {}
+				this.#client = void 0;
+			}
+		} finally {
+			this.#status = "disconnected";
+			this.#connection = void 0;
+			this.#lastPid = void 0;
+			this.#emitter.emit("destroy");
+			this.#emitter.destroy();
+		}
+	}
+	/**
+	* Gracefully shut down the remote browser, whether this instance owns its
+	* process or merely attached to it via CDP.
+	*
+	* @remarks
+	* Sends CDP `Browser.close` best-effort; on an owned browser also awaits
+	* the process's exit (bounded by the kill-escalation grace period,
+	* escalating to a kill only if it does not exit in time). Ends in the
+	* same local-cleanup state as `destroy()`.
+	*/
+	async close() {
+		if (this.#destroyed) return;
+		this.#destroyed = true;
+		try {
+			this.#unbindTransport();
+			this.#unbindProcess();
+			const client = this.#client;
+			if (client !== void 0) try {
+				await client.send("Browser.close");
+			} catch {}
+			const process = this.#process;
+			if (process !== void 0) {
+				const exited = new Promise((resolve) => {
+					process.once("exit", () => resolve());
+				});
+				let timer;
+				const timedOut = await Promise.race([exited.then(() => false), new Promise((resolve) => {
+					timer = setTimeout(() => resolve(true), BROWSER_KILL_GRACE_MS);
+				})]);
+				if (timer !== void 0) clearTimeout(timer);
+				if (timedOut) await this.#terminate(process);
+				this.#process = void 0;
+			}
+			for (const ctx of this.#contexts) try {
+				await ctx.close();
+			} catch {}
+			this.#contexts = [];
+			if (client !== void 0) {
+				try {
+					await client.close();
+				} catch {}
+				this.#client = void 0;
+			}
+		} finally {
+			this.#status = "disconnected";
+			this.#connection = void 0;
+			this.#lastPid = void 0;
+			this.#emitter.emit("destroy");
+			this.#emitter.destroy();
+		}
+	}
+	#assertNotAborted() {
+		if (this.#options.signal?.aborted) throw new BrowserConnectionError("Connection aborted");
+	}
+	/**
+	* Race a promise against the connection's external AbortSignal (if any),
+	* rejecting promptly with a coded BrowserConnectionError when it fires.
+	*/
+	async #raceAbort(promise) {
+		const signal = this.#options.signal;
+		if (signal === void 0) return promise;
+		if (signal.aborted) throw new BrowserConnectionError("Connection aborted");
+		let abortWon = false;
+		return await new Promise((resolve, reject) => {
+			const onAbort = () => {
+				abortWon = true;
+				cleanup();
+				reject(new BrowserConnectionError("Connection aborted"));
+			};
+			const cleanup = () => signal.removeEventListener("abort", onAbort);
+			signal.addEventListener("abort", onAbort, { once: true });
+			promise.then((value) => {
+				cleanup();
+				resolve(value);
+			}, (error) => {
+				cleanup();
+				reject(error);
+			});
+		}).catch((error) => {
+			if (abortWon) promise.catch(() => void 0);
+			throw error;
+		});
+	}
+	#reset() {
+		this.#contexts = [];
+		this.#status = "disconnected";
+		this.#connection = void 0;
+		this.#client = void 0;
+	}
+	/**
+	* Handle the owned process exiting on its own (not via destroy()/close()).
+	* The process is already gone — no kill is attempted. Cleans up orphaned
+	* state so the next connect() call can start fresh, and emits a coded
+	* `error` (cause: process exit) before `disconnect`.
+	*/
+	#handleProcessExit() {
+		if (this.#destroyed) return;
+		if (this.#status !== "connected") return;
+		this.#unbindTransport();
+		this.#unbindProcess();
+		const client = this.#client;
+		this.#process = void 0;
+		this.#lastPid = void 0;
+		this.#reset();
+		if (client !== void 0) client.close().catch(() => void 0);
+		this.#emitter.emit("error", new BrowserConnectionError("The browser process exited unexpectedly", { cause: "process-exit" }));
+		this.#emitter.emit("disconnect");
+		this.#emitter.emit("idle");
+	}
+	/**
+	* Handle a transport close/error while the owned process (if any) is
+	* still alive, or the connection is CDP-attached. Never kills the
+	* process — only the local client is reset, so the SAME instance can
+	* reconnect (e.g. rediscover on the port and reattach). Emits a coded
+	* `error` (cause: connection loss) before `disconnect`.
+	*/
+	#handleTransportLoss(deferred = false) {
+		if (this.#destroyed) return;
+		if (this.#status !== "connected") return;
+		const process = this.#process;
+		if (process !== void 0 && (process.exitCode !== null || process.signalCode !== null)) {
+			this.#handleProcessExit();
+			return;
+		}
+		if (process !== void 0 && !deferred) {
+			setTimeout(() => this.#handleTransportLoss(true), 50);
+			return;
+		}
+		if (process !== void 0 && process.pid !== void 0) try {
+			process.kill(0);
+		} catch {
+			this.#handleProcessExit();
+			return;
+		}
+		this.#unbindTransport();
+		const client = this.#client;
+		this.#reset();
+		if (client !== void 0) client.close().catch(() => void 0);
+		this.#emitter.emit("error", new BrowserConnectionError("The CDP transport connection was lost", { cause: "connection-loss" }));
+		this.#emitter.emit("disconnect");
+		this.#emitter.emit("idle");
+	}
+	/** Subscribe to the CDP transport's close/error events for deterministic transport-loss detection. */
+	#bindTransport(transport) {
+		const onClose = () => this.#handleTransportLoss();
+		const onError = () => this.#handleTransportLoss();
+		transport.emitter.on("close", onClose);
+		transport.emitter.on("error", onError);
+		this.#transportUnbind = () => {
+			transport.emitter.off("close", onClose);
+			transport.emitter.off("error", onError);
+		};
+	}
+	#unbindTransport() {
+		this.#transportUnbind?.();
+		this.#transportUnbind = void 0;
+	}
+	/** Subscribe to a launched process's exit event for deterministic process-exit detection. */
+	#bindProcess(process) {
+		const onExit = () => this.#handleProcessExit();
+		process.once("exit", onExit);
+		this.#processUnbind = () => process.off("exit", onExit);
+	}
+	#unbindProcess() {
+		this.#processUnbind?.();
+		this.#processUnbind = void 0;
+	}
+	#timeout() {
+		return this.#options.timeout ?? _src_core.BROWSER_DEFAULT_TIMEOUT_MS;
+	}
+	async #discoverCdp() {
+		const port = this.#cdpPort;
+		const url = `${BROWSER_CDP_PROTOCOL}://${this.#cdpHost}:${port}${BROWSER_CDP_VERSION_PATH}`;
+		const controller = new AbortController();
+		const timer = setTimeout(() => controller.abort(), this.#timeout());
+		try {
+			const response = await fetch(url, { signal: controller.signal });
+			if (!response.ok) return this.#notFoundResult();
+			const info = await response.json();
+			if (!(0, _orkestrel_contract.isRecord)(info)) return this.#notFoundResult();
+			const endpoint = (0, _orkestrel_contract.isString)(info["webSocketDebuggerUrl"]) ? info["webSocketDebuggerUrl"] : void 0;
+			const browserName = (0, _orkestrel_contract.isString)(info["Browser"]) ? info["Browser"] : void 0;
+			return {
+				found: endpoint !== void 0,
+				endpoint,
+				browser: browserName,
+				connection: endpoint !== void 0 ? "cdp" : void 0
+			};
+		} catch {
+			return this.#notFoundResult();
+		} finally {
+			clearTimeout(timer);
+		}
+	}
+	#notFoundResult() {
+		return {
+			found: false,
+			endpoint: void 0,
+			browser: void 0,
+			connection: void 0
+		};
+	}
+	/**
+	* Reject when something is already listening on the configured CDP port —
+	* used ahead of a `discover: false` launch, so a caller demanding a fresh
+	* browser never silently attaches to a stranger already on that port.
+	*/
+	async #assertPortFree() {
+		if (await this.#probePort()) throw new BrowserConnectionError(`Port ${this.#cdpPort} on ${this.#cdpHost} is already occupied by another CDP endpoint`, {
+			port: this.#cdpPort,
+			host: this.#cdpHost
+		});
+	}
+	/** Very short probe of the CDP version endpoint — just enough to detect an occupied port, not full discovery. */
+	async #probePort() {
+		const url = `${BROWSER_CDP_PROTOCOL}://${this.#cdpHost}:${this.#cdpPort}${BROWSER_CDP_VERSION_PATH}`;
+		const controller = new AbortController();
+		const timer = setTimeout(() => controller.abort(), 200);
+		try {
+			return (await fetch(url, { signal: controller.signal })).ok;
+		} catch {
+			return false;
+		} finally {
+			clearTimeout(timer);
+		}
+	}
+	async #connectCdp(endpoint) {
+		const transport = createCDPTransport({
+			url: endpoint,
+			timeout: this.#timeout()
+		});
+		const client = new _src_core.CDPClient({
+			transport,
+			timeout: this.#timeout()
+		});
+		try {
+			await this.#raceAbort(client.connect());
+			this.#client = client;
+			this.#connection = "cdp";
+			this.#status = "connected";
+			this.#bindTransport(transport);
+			await this.#syncContexts();
+			this.#emitter.emit("connect", "cdp");
+		} catch (error) {
+			try {
+				await client.close();
+			} catch {}
+			throw error;
+		}
+	}
+	async #launch() {
+		if (this.#process !== void 0) throw new BrowserConnectionError("A browser process is already active on this instance");
+		const requestedEngine = this.#options.engine ?? this.#options.browsers?.engine;
+		let executable = this.#options.executable;
+		let resolvedEngine;
+		if (executable !== void 0) resolvedEngine = parseBrowserEngine(executable) ?? "chromium";
+		else {
+			const found = findSystemBrowser({
+				...this.#options.browsers,
+				engine: requestedEngine
+			});
+			executable = found?.executable;
+			resolvedEngine = found?.engine;
+		}
+		if (executable === void 0) throw new BrowserConnectionError("No Chromium browser found. Install Chrome, Edge, or Chromium.", requestedEngine !== void 0 ? { engine: requestedEngine } : void 0);
+		this.#engine = resolvedEngine ?? "chromium";
+		const headless = this.#options.headless ?? true;
+		const profile = this.#options.profile;
+		const extra = this.#options.args;
+		const process = launchBrowserProcess(executable, this.#cdpPort, headless, profile, extra);
+		this.#process = process;
+		let transport;
+		let client;
+		try {
+			transport = createCDPTransport({
+				url: await this.#raceAbort(this.#waitForLaunch(process, executable, extra)),
+				timeout: this.#timeout()
+			});
+			client = new _src_core.CDPClient({
+				transport,
+				timeout: this.#timeout()
+			});
+			await this.#raceAbort(client.connect());
+			this.#client = client;
+			this.#connection = profile !== void 0 ? "persistent" : "launch";
+			this.#status = "connected";
+			this.#bindTransport(transport);
+			this.#bindProcess(process);
+			await this.#syncContexts();
+			this.#emitter.emit("launch", this.#engine);
+			this.#emitter.emit("connect", this.#connection);
+		} catch (error) {
+			if (client !== void 0) try {
+				await client.close();
+			} catch {}
+			await this.#terminate(process);
+			this.#process = void 0;
+			throw error;
+		}
+	}
+	async #waitForLaunch(process, executable, args) {
+		const context = {
+			executable,
+			args
+		};
+		return await new Promise((resolve, reject) => {
+			let settled = false;
+			const finish = (callback) => {
+				if (settled) return;
+				settled = true;
+				process.off("error", onError);
+				process.off("exit", onExit);
+				callback();
+			};
+			const onError = (error) => {
+				finish(() => reject(new BrowserConnectionError(error.message, context)));
+			};
+			const onExit = (code, signal) => {
+				finish(() => reject(new BrowserConnectionError(this.#formatLaunchExit(code, signal), context)));
+			};
+			process.once("error", onError);
+			process.once("exit", onExit);
+			waitForCdpReady(this.#cdpPort, this.#timeout(), this.#cdpHost).then((wsUrl) => {
+				finish(() => resolve(wsUrl));
+			}, (error) => {
+				const message = error instanceof Error ? error.message : String(error);
+				finish(() => reject(new BrowserConnectionError(message, context)));
+			});
+		});
+	}
+	#formatLaunchExit(code, signal) {
+		if (signal !== null) return `Browser process exited before CDP became ready (signal: ${signal})`;
+		if (code !== null) return `Browser process exited before CDP became ready (code: ${code})`;
+		return "Browser process exited before CDP became ready";
+	}
+	async #syncContexts() {
+		if (this.#client === void 0) return;
+		const pageTargets = (await fetchCdpTargets(this.#cdpPort, this.#timeout(), this.#cdpHost)).filter((t) => t.type === "page");
+		if (pageTargets.length > 0 && this.#contexts.length === 0) {
+			const ctx = new _src_core.BrowserContext(this.#client, void 0, this.#options.viewport, createScreenshotWriter());
+			await ctx.sync(pageTargets);
+			this.#contexts.push(ctx);
+		}
+	}
+	/**
+	* Terminate a browser process, escalating from SIGTERM to SIGKILL if it
+	* does not exit within the grace period. Tolerates a process that has
+	* already exited (ESRCH).
+	*/
+	async #terminate(process) {
+		if (process === void 0) return;
+		if (process.exitCode !== null || process.signalCode !== null) return;
+		const exited = new Promise((resolve) => {
+			process.once("exit", () => resolve());
+		});
+		try {
+			process.kill("SIGTERM");
+		} catch {
+			return;
+		}
+		let timer;
+		const timedOut = await Promise.race([exited.then(() => false), new Promise((resolve) => {
+			timer = setTimeout(() => resolve(true), BROWSER_KILL_GRACE_MS);
+		})]);
+		if (timer !== void 0) clearTimeout(timer);
+		if (timedOut) {
+			try {
+				process.kill("SIGKILL");
+			} catch {}
+			await exited;
+		}
+	}
+};
+//#endregion
+exports.BROWSER_CDP_LIST_PATH = BROWSER_CDP_LIST_PATH;
+exports.BROWSER_CDP_PROTOCOL = BROWSER_CDP_PROTOCOL;
+exports.BROWSER_CDP_VERSION_PATH = BROWSER_CDP_VERSION_PATH;
+exports.BROWSER_DEFAULT_CDP_PORT = BROWSER_DEFAULT_CDP_PORT;
+exports.BROWSER_DEFAULT_HOST = BROWSER_DEFAULT_HOST;
+exports.BROWSER_ENGINE_HINTS = BROWSER_ENGINE_HINTS;
+exports.BROWSER_ENV_PATH_KEYS = BROWSER_ENV_PATH_KEYS;
+exports.BROWSER_EXECUTABLE_NAMES = BROWSER_EXECUTABLE_NAMES;
+exports.BROWSER_EXECUTABLE_PATHS = BROWSER_EXECUTABLE_PATHS;
+exports.BROWSER_HEADLESS_ARG = BROWSER_HEADLESS_ARG;
+exports.BROWSER_KILL_GRACE_MS = BROWSER_KILL_GRACE_MS;
+exports.BROWSER_LAUNCH_ARGS = BROWSER_LAUNCH_ARGS;
+exports.BROWSER_NOT_FOUND_RESULT = BROWSER_NOT_FOUND_RESULT;
+exports.BROWSER_PORT_PROBE_TIMEOUT_MS = BROWSER_PORT_PROBE_TIMEOUT_MS;
+exports.BROWSER_STORE_CACHE_DIRS = BROWSER_STORE_CACHE_DIRS;
+exports.BROWSER_STORE_DEFAULT_DIRS = BROWSER_STORE_DEFAULT_DIRS;
+exports.BROWSER_STORE_ENV_KEY = BROWSER_STORE_ENV_KEY;
+exports.BROWSER_STORE_GLOBS = BROWSER_STORE_GLOBS;
+exports.BROWSER_STORE_LINK_NAME = BROWSER_STORE_LINK_NAME;
+exports.BROWSER_TRANSPORT_LOSS_DEFER_MS = BROWSER_TRANSPORT_LOSS_DEFER_MS;
+exports.BROWSER_WINDOWS_ROOT_FALLBACKS = BROWSER_WINDOWS_ROOT_FALLBACKS;
+exports.BROWSER_WINDOWS_SUFFIXES = BROWSER_WINDOWS_SUFFIXES;
+exports.Browser = Browser;
+exports.BrowserConnectionError = BrowserConnectionError;
+exports.BrowserDestroyedError = BrowserDestroyedError;
+exports.BrowserNotConnectedError = BrowserNotConnectedError;
+exports.WebSocketCDPTransport = WebSocketCDPTransport;
+exports.browserToEngine = browserToEngine;
+exports.createBrowser = createBrowser;
+exports.createCDPTransport = createCDPTransport;
+exports.createScreenshotWriter = createScreenshotWriter;
+exports.defaultInstallPaths = defaultInstallPaths;
+exports.defaultStoreBases = defaultStoreBases;
+exports.fetchCdpTargets = fetchCdpTargets;
+exports.findAllEnvOverrides = findAllEnvOverrides;
+exports.findAllInStore = findAllInStore;
+exports.findAllInstallPaths = findAllInstallPaths;
+exports.findEnvOverride = findEnvOverride;
+exports.findInStore = findInStore;
+exports.findInstallPath = findInstallPath;
+exports.findSystemBrowser = findSystemBrowser;
+exports.findSystemBrowsers = findSystemBrowsers;
+exports.isBrowserConnectionError = isBrowserConnectionError;
+exports.isBrowserDestroyedError = isBrowserDestroyedError;
+exports.isBrowserNotConnectedError = isBrowserNotConnectedError;
+exports.launchBrowserProcess = launchBrowserProcess;
+exports.normalizeExecutablePath = normalizeExecutablePath;
+exports.parseBrowserEngine = parseBrowserEngine;
+exports.probeAllPathNames = probeAllPathNames;
+exports.probePathNames = probePathNames;
+exports.waitForCdpReady = waitForCdpReady;
+exports.windowsRoots = windowsRoots;
+
+//# sourceMappingURL=index.cjs.map