reverseport 0.0.0-stage → 1.2.0

package/dist/cli-runtime/ElectronFileScope-C1hUEp36.js

@@ -0,0 +1,1419 @@
+import { __esmMin } from "./rolldown-runtime-DXoylpqc.js";
+import { AnalysisCancelledError, AnalysisError, init_analysisErrorBase, init_analysisErrorCore } from "./providerOperationHealth-DSTcYPJe.js";
+import { WEB_RUNTIME_LIMITS, classifyBrowserCompleteness, compareUnicodeCodePoints, createWebTextArtifact, init_browserCompleteness, init_browserObservation, init_unicodeCodePointOrder, init_webContentArtifact, init_webRuntime, sanitizeBrowserUrl } from "./reconstructionObligationLedgerSchemas-dvp6PEnZ.js";
+import { BrowserObservationError, init_browserObservationError } from "./browserObservationError-D73SM55P.js";
+import { init_safeJson, safeParseJson } from "./safeJson-DKKACtdy.js";
+import { MAX_ASAR_HEADER_BYTES, admitAsarHeader, init_AsarHeader } from "./AsarHeader-CnzOzYEH.js";
+import { isAbsolute, join, sep } from "node:path";
+import { z } from "zod";
+import { open, realpath, stat } from "node:fs/promises";
+import { fileURLToPath } from "node:url";
+import { request } from "node:http";
+import WebSocket from "ws";
+
+//#region dist/browser/CdpEndpoint.js
+var endpointVersionSchema, endpointTargetSchema, endpointTargetsSchema, discoverCdpEndpoint, sanitizeTargetTitle, sanitizeTargetUrlAlias, sanitizeSameOriginTitleUrl, escapeRegExp, cdpTargetWebSocket, hasCdpTargetWebSocket, availableCdpTargetWebSocket, parseCdpEndpointValue, safeCdpWebSocketEndpoint, cdpWebSocketPath, pathIdentifier, targetWebSocket, readCdpJson, endpointFailure;
+function init_CdpEndpoint() {
+	return (init_CdpEndpoint = __esmMin((() => {
+		init_analysisErrorCore();
+		init_analysisErrorBase();
+		init_browserObservationError();
+		init_browserObservation();
+		init_safeJson();
+		endpointVersionSchema = z.object({
+			Browser: z.string().min(1),
+			"Protocol-Version": z.string().min(1),
+			"User-Agent": z.string(),
+			"V8-Version": z.string(),
+			"WebKit-Version": z.string(),
+			webSocketDebuggerUrl: z.string().min(1)
+		});
+		endpointTargetSchema = z.object({
+			id: z.string().min(1),
+			type: z.string().min(1),
+			title: z.string().default(""),
+			url: z.string(),
+			attached: z.boolean().nullable().optional(),
+			webSocketDebuggerUrl: z.string().min(1).optional()
+		});
+		endpointTargetsSchema = z.array(endpointTargetSchema);
+		discoverCdpEndpoint = async (endpoint, operation, signal) => {
+			const versionInput = await readCdpJson(new URL("/json/version", endpoint), operation, signal);
+			const targetsInput = await readCdpJson(new URL("/json/list", endpoint), operation, signal);
+			const version = parseCdpEndpointValue(endpointVersionSchema, versionInput, operation);
+			const targets = parseCdpEndpointValue(endpointTargetsSchema, targetsInput, operation);
+			return {
+				webSocket: safeCdpWebSocketEndpoint(endpoint, version.webSocketDebuggerUrl, operation),
+				version: {
+					product: version.Browser,
+					protocol_version: version["Protocol-Version"],
+					revision: version["WebKit-Version"],
+					user_agent: version["User-Agent"],
+					js_version: version["V8-Version"]
+				},
+				targets: targets.map((target) => ({
+					id: target.id,
+					type: target.type,
+					title: sanitizeTargetTitle(target.title, target.url),
+					url: target.url,
+					attached: target.attached ?? null,
+					...targetWebSocket(endpoint, target, operation)
+				}))
+			};
+		};
+		sanitizeTargetTitle = (value, targetUrl) => {
+			let url;
+			try {
+				url = new URL(value);
+			} catch (cause) {
+				void cause;
+				return sanitizeTargetUrlAlias(value, targetUrl);
+			}
+			return url.protocol === "http:" || url.protocol === "https:" ? sanitizeBrowserUrl(value).url : sanitizeTargetUrlAlias(value, targetUrl);
+		};
+		sanitizeTargetUrlAlias = (value, targetUrl) => {
+			let parsed;
+			try {
+				parsed = new URL(targetUrl);
+			} catch (cause) {
+				void cause;
+				return value;
+			}
+			const markers = [
+				parsed.origin,
+				`//${parsed.host}`,
+				parsed.host
+			];
+			if (parsed.pathname !== "/") markers.push(parsed.pathname);
+			const candidatePattern = new RegExp(`(?:${markers.map(escapeRegExp).join("|")})[^\\s<>"']*`, "gu");
+			return value.replace(candidatePattern, (candidate) => sanitizeSameOriginTitleUrl(candidate, parsed));
+		};
+		sanitizeSameOriginTitleUrl = (candidate, target) => {
+			let parsed;
+			try {
+				parsed = candidate.startsWith("//") ? new URL(`${target.protocol}${candidate}`) : candidate.startsWith(target.host) ? new URL(`${target.protocol}//${candidate}`) : new URL(candidate, target.origin);
+			} catch (cause) {
+				void cause;
+				return candidate;
+			}
+			return parsed.origin === target.origin && (parsed.username !== "" || parsed.password !== "") ? sanitizeBrowserUrl(candidate).url : candidate;
+		};
+		escapeRegExp = (value) => value.replaceAll(/[.*+?^${}()|[\]\\]/gu, "\\$&");
+		cdpTargetWebSocket = (discovery, target, operation) => {
+			const webSocket = availableCdpTargetWebSocket(discovery, target);
+			if (webSocket !== undefined) return webSocket;
+			throw new BrowserObservationError(operation, "invalid_endpoint_response");
+		};
+		hasCdpTargetWebSocket = (discovery, target) => availableCdpTargetWebSocket(discovery, target) !== undefined;
+		availableCdpTargetWebSocket = (discovery, target) => {
+			if (discovery.webSocket.scope === "browser") return discovery.webSocket;
+			if (target.webSocket !== undefined) return target.webSocket;
+			return discovery.webSocket.targetId === target.id ? discovery.webSocket : undefined;
+		};
+		parseCdpEndpointValue = (schema, input, operation) => {
+			const parsed = schema.safeParse(input);
+			if (!parsed.success) throw new BrowserObservationError(operation, "invalid_endpoint_response", { cause: parsed.error });
+			return parsed.data;
+		};
+		safeCdpWebSocketEndpoint = (endpoint, reported, operation) => {
+			let parsed;
+			try {
+				parsed = new URL(reported);
+			} catch (cause) {
+				throw new BrowserObservationError(operation, "invalid_endpoint_response", { cause });
+			}
+			const trustedEndpoint = new URL(endpoint);
+			const path = cdpWebSocketPath(parsed.pathname);
+			if (parsed.protocol !== "ws:" || parsed.port !== trustedEndpoint.port || parsed.username !== "" || parsed.password !== "" || parsed.search !== "" || parsed.hash !== "" || path === undefined) throw new BrowserObservationError(operation, "invalid_endpoint_response");
+			parsed.hostname = trustedEndpoint.hostname;
+			return path.scope === "browser" ? {
+				scope: "browser",
+				url: parsed.href
+			} : {
+				scope: "page",
+				targetId: path.targetId,
+				url: parsed.href
+			};
+		};
+		cdpWebSocketPath = (pathname) => {
+			const browserId = pathIdentifier(pathname, "/devtools/browser/");
+			if (browserId !== undefined) return { scope: "browser" };
+			const targetId = pathIdentifier(pathname, "/devtools/page/");
+			return targetId === undefined ? undefined : {
+				scope: "page",
+				targetId
+			};
+		};
+		pathIdentifier = (pathname, prefix) => {
+			if (!pathname.startsWith(prefix)) return undefined;
+			const identifier = pathname.slice(prefix.length);
+			return identifier.length > 0 && !identifier.includes("/") ? identifier : undefined;
+		};
+		targetWebSocket = (endpoint, target, operation) => {
+			if (target.webSocketDebuggerUrl === undefined) return {};
+			try {
+				const webSocket = safeCdpWebSocketEndpoint(endpoint, target.webSocketDebuggerUrl, operation);
+				return webSocket.scope === "page" && webSocket.targetId === target.id ? { webSocket } : {};
+			} catch (cause) {
+				void cause;
+				return {};
+			}
+		};
+		readCdpJson = async (url, operation, signal) => await new Promise((resolve, reject) => {
+			if (signal?.aborted === true) {
+				reject(new AnalysisCancelledError(operation));
+				return;
+			}
+			const request_ = request(url, {
+				method: "GET",
+				signal,
+				headers: { Accept: "application/json" }
+			}, (response) => {
+				if (response.statusCode !== 200) {
+					response.resume();
+					reject(new BrowserObservationError(operation, "invalid_endpoint_response"));
+					return;
+				}
+				const chunks = [];
+				response.on("data", (chunk) => chunks.push(chunk));
+				response.on("end", () => {
+					const parsed = safeParseJson(Buffer.concat(chunks).toString("utf8"));
+					if (!parsed.ok) {
+						reject(new BrowserObservationError(operation, "invalid_endpoint_response", { cause: parsed.cause }));
+						return;
+					}
+					resolve(parsed.value);
+				});
+				response.on("error", (cause) => reject(endpointFailure(cause, operation, signal)));
+			});
+			request_.on("error", (cause) => reject(endpointFailure(cause, operation, signal)));
+			request_.end();
+		});
+		endpointFailure = (cause, operation, signal) => {
+			if (cause instanceof AnalysisError) return cause;
+			if (signal?.aborted === true) return new AnalysisCancelledError(operation);
+			return new BrowserObservationError(operation, "endpoint_unreachable", { cause });
+		};
+	})))();
+}
+
+//#endregion
+//#region dist/browser/CdpCommandRejection.js
+var CdpCommandRejection;
+function init_CdpCommandRejection() {
+	return (init_CdpCommandRejection = __esmMin((() => {
+		init_browserObservationError();
+		CdpCommandRejection = class extends BrowserObservationError {
+			command;
+			code;
+			reportedMessage;
+			constructor(operation, command, code, reportedMessage) {
+				super(operation, "protocol_error", { detail: reportedMessage === null ? "CDP returned a malformed command error." : `CDP ${command} failed (${code === null ? "unknown code" : String(code)}): ${reportedMessage}` });
+				this.command = command;
+				this.code = code;
+				this.reportedMessage = reportedMessage;
+			}
+		};
+	})))();
+}
+
+//#endregion
+//#region dist/browser/CdpConnection.js
+var MAX_WEBSOCKET_PAYLOAD_BYTES, CdpConnection, rawText, isRecord$2, waitForOpen, terminateSocket;
+function init_CdpConnection() {
+	return (init_CdpConnection = __esmMin((() => {
+		init_analysisErrorCore();
+		init_analysisErrorBase();
+		init_browserObservationError();
+		init_CdpCommandRejection();
+		init_safeJson();
+		init_webRuntime();
+		MAX_WEBSOCKET_PAYLOAD_BYTES = 2147483647;
+		CdpConnection = class CdpConnection {
+			socket;
+			operation;
+			maxPayloadBytes;
+			#pending = new Map();
+			#listeners = new Set();
+			#disconnectListeners = new Set();
+			#protocolFailureListeners = new Set();
+			#nextId = 1;
+			#closed = false;
+			#closePromise;
+			#protocolFailed = false;
+			#transportFailure = "disconnected";
+			constructor(socket, operation, maxPayloadBytes) {
+				this.socket = socket;
+				this.operation = operation;
+				this.maxPayloadBytes = maxPayloadBytes;
+				socket.on("message", (data) => this.#receive(data));
+				socket.on("close", () => this.#disconnect());
+				socket.on("error", (cause) => this.#disconnect(isRecord$2(cause) && cause.code === "WS_ERR_UNSUPPORTED_MESSAGE_LENGTH" ? "payload_limit" : "disconnected"));
+			}
+			/** Connect to one already-validated loopback CDP WebSocket. */
+			static async connect(url, operation, signal, limits) {
+				if (signal?.aborted === true) throw new AnalysisCancelledError(operation);
+				const maxPayloadBytes = limits === undefined ? WEB_RUNTIME_LIMITS.protocolBytes : limits.maxPayloadBytes;
+				if (!Number.isSafeInteger(maxPayloadBytes) || maxPayloadBytes <= 0 || maxPayloadBytes > MAX_WEBSOCKET_PAYLOAD_BYTES) throw new RangeError(`CDP maxPayloadBytes must be a positive safe integer no greater than ${String(MAX_WEBSOCKET_PAYLOAD_BYTES)}.`);
+				const socket = new WebSocket(url, {
+					handshakeTimeout: 0,
+					maxPayload: maxPayloadBytes,
+					perMessageDeflate: false
+				});
+				await waitForOpen(socket, operation, signal);
+				return new CdpConnection(socket, operation, maxPayloadBytes);
+			}
+			/** Subscribe to validated CDP event envelopes. */
+			onEvent(listener) {
+				this.#listeners.add(listener);
+				return () => this.#listeners.delete(listener);
+			}
+			/** Subscribe to an unexpected transport loss while an operation is active. */
+			onDisconnect(listener) {
+				if (this.#closed) {
+					listener(this.#transportError(this.#transportFailure));
+					return () => undefined;
+				}
+				this.#disconnectListeners.add(listener);
+				return () => this.#disconnectListeners.delete(listener);
+			}
+			/** Notify fatal wire parsing failure even when no command is outstanding. */
+			onProtocolFailure(listener) {
+				if (this.#protocolFailed) {
+					listener(this.#transportError("protocol_error"));
+					return () => undefined;
+				}
+				this.#protocolFailureListeners.add(listener);
+				return () => this.#protocolFailureListeners.delete(listener);
+			}
+			/** Execute one command, optionally within a flat target session. */
+			async send(method, params = {}, sessionId, signal) {
+				if (this.#protocolFailed) throw new BrowserObservationError(this.operation, "protocol_error");
+				if (this.#closed || this.socket.readyState !== WebSocket.OPEN) throw this.#transportError(this.#transportFailure);
+				if (signal?.aborted === true) throw new AnalysisCancelledError(this.operation);
+				const id = this.#nextId;
+				this.#nextId += 1;
+				return await new Promise((resolve, reject) => {
+					const onAbort = () => {
+						const pending = this.#pending.get(id);
+						if (pending === undefined) return;
+						pending.removeAbort();
+						this.#pending.delete(id);
+						reject(new AnalysisCancelledError(this.operation));
+					};
+					signal?.addEventListener("abort", onAbort, { once: true });
+					this.#pending.set(id, {
+						method,
+						...sessionId === undefined ? {} : { sessionId },
+						resolve,
+						reject,
+						removeAbort: () => signal?.removeEventListener("abort", onAbort)
+					});
+					this.socket.send(JSON.stringify({
+						id,
+						method,
+						params,
+						...sessionId === undefined ? {} : { sessionId }
+					}), (error) => {
+						if (error === undefined || error === null) return;
+						const pending = this.#pending.get(id);
+						if (pending === undefined) return;
+						this.#complete(id, pending);
+						reject(new BrowserObservationError(this.operation, "disconnected", { cause: error }));
+					});
+				});
+			}
+			/** Close only REA's socket; never close the browser or selected page. */
+			close() {
+				this.#closePromise ??= this.#closeTransport().catch((cause) => {
+					this.#closePromise = undefined;
+					throw cause;
+				});
+				return this.#closePromise;
+			}
+			async #closeTransport() {
+				this.#closed = true;
+				this.#failPending("disconnected");
+				if (this.socket.readyState === WebSocket.CLOSED) return;
+				await new Promise((resolve) => {
+					const timer = setTimeout(() => {
+						this.socket.terminate();
+						resolve();
+					}, 1e3);
+					this.socket.once("close", () => {
+						clearTimeout(timer);
+						resolve();
+					});
+					this.socket.close();
+				});
+			}
+			#receive(data) {
+				if (this.#closed || this.#protocolFailed) return;
+				const parsed = safeParseJson(rawText(data));
+				if (!parsed.ok) {
+					this.#failPending("protocol_error");
+					return;
+				}
+				const message = parsed.value;
+				if (!isRecord$2(message)) {
+					this.#failPending("protocol_error");
+					return;
+				}
+				if ("id" in message) {
+					if (typeof message.id !== "number" || !Number.isSafeInteger(message.id) || message.id < 1) {
+						this.#failPending("protocol_error");
+						return;
+					}
+					this.#receiveResponse(message, message.id);
+					return;
+				}
+				if (typeof message.method !== "string" || message.method.length === 0 || "params" in message && !isRecord$2(message.params) || "sessionId" in message && typeof message.sessionId !== "string") {
+					this.#failPending("protocol_error");
+					return;
+				}
+				const event = {
+					method: message.method,
+					params: "params" in message ? message.params : {},
+					...typeof message.sessionId === "string" ? { sessionId: message.sessionId } : {}
+				};
+				for (const listener of this.#listeners) listener(event);
+			}
+			#receiveResponse(message, id) {
+				const pending = this.#pending.get(id);
+				if (pending === undefined) return;
+				const hasResult = "result" in message;
+				const hasError = "error" in message;
+				if ("sessionId" in message && (typeof message.sessionId !== "string" || message.sessionId !== pending.sessionId) || hasResult === hasError) {
+					this.#failPending("protocol_error");
+					return;
+				}
+				if (hasResult) {
+					if (!isRecord$2(message.result)) {
+						this.#failPending("protocol_error");
+						return;
+					}
+					this.#complete(id, pending);
+					pending.resolve(message.result);
+					return;
+				}
+				const reported = message.error;
+				if (!isRecord$2(reported) || typeof reported.code !== "number" || !Number.isSafeInteger(reported.code) || typeof reported.message !== "string") {
+					this.#failPending("protocol_error");
+					return;
+				}
+				this.#complete(id, pending);
+				pending.reject(new CdpCommandRejection(this.operation, pending.method, reported.code, reported.message));
+			}
+			#complete(id, pending) {
+				pending.removeAbort();
+				this.#pending.delete(id);
+			}
+			#failPending(reason) {
+				const wasProtocolFailed = this.#protocolFailed;
+				if (reason !== "protocol_error") this.#closed = true;
+				else this.#protocolFailed = true;
+				for (const [id, pending] of this.#pending) {
+					this.#complete(id, pending);
+					pending.reject(this.#transportError(reason));
+				}
+				if (reason === "protocol_error" && !wasProtocolFailed) {
+					const error = this.#transportError(reason);
+					for (const listener of this.#protocolFailureListeners) listener(error);
+					this.#protocolFailureListeners.clear();
+				}
+			}
+			#disconnect(reason = "disconnected") {
+				const wasClosed = this.#closed;
+				if (!wasClosed) this.#transportFailure = reason;
+				this.#failPending(reason);
+				if (wasClosed) return;
+				const error = this.#transportError(reason);
+				for (const listener of this.#disconnectListeners) listener(error);
+				this.#disconnectListeners.clear();
+			}
+			#transportError(reason) {
+				return new BrowserObservationError(this.operation, reason, reason === "payload_limit" ? { detail: `CDP message exceeded the selected ${String(this.maxPayloadBytes)} byte protocol budget.` } : undefined);
+			}
+		};
+		rawText = (data) => Array.isArray(data) ? Buffer.concat(data).toString("utf8") : Buffer.isBuffer(data) ? data.toString("utf8") : Buffer.from(data).toString("utf8");
+		isRecord$2 = (value) => typeof value === "object" && value !== null && !Array.isArray(value);
+		waitForOpen = async (socket, operation, signal) => await new Promise((resolve, reject) => {
+			const onOpen = () => {
+				cleanup();
+				resolve();
+			};
+			const onFailure = (cause) => {
+				cleanup();
+				reject(signal?.aborted === true ? new AnalysisCancelledError(operation) : new BrowserObservationError(operation, "endpoint_unreachable", { cause }));
+			};
+			const onClose = (code, reason) => {
+				onFailure(new Error(`CDP WebSocket closed before opening (${code}: ${reason.toString("utf8")})`));
+			};
+			const onAbort = () => {
+				terminateSocket(socket);
+				onFailure(new AnalysisCancelledError(operation));
+			};
+			const cleanup = () => {
+				socket.off("open", onOpen);
+				socket.off("error", onFailure);
+				socket.off("close", onClose);
+				signal?.removeEventListener("abort", onAbort);
+			};
+			socket.once("open", onOpen);
+			socket.once("error", onFailure);
+			socket.once("close", onClose);
+			signal?.addEventListener("abort", onAbort, { once: true });
+			if (signal?.aborted === true) onAbort();
+		});
+		terminateSocket = (socket) => {
+			socket.once("error", () => undefined);
+			socket.terminate();
+		};
+	})))();
+}
+
+//#endregion
+//#region dist/browser/CdpTargetSession.js
+var openCdpTargetSession, closeCdpTargetSession, attachedSessionId;
+function init_CdpTargetSession() {
+	return (init_CdpTargetSession = __esmMin((() => {
+		init_browserObservationError();
+		init_CdpConnection();
+		init_CdpEndpoint();
+		openCdpTargetSession = async (discovery, target, operation, signal, limits) => {
+			const webSocket = cdpTargetWebSocket(discovery, target, operation);
+			const connection = await CdpConnection.connect(webSocket.url, operation, signal, limits);
+			if (webSocket.scope === "page") return {
+				connection,
+				sessionId: undefined
+			};
+			try {
+				const attached = await connection.send("Target.attachToTarget", {
+					targetId: target.id,
+					flatten: true
+				}, undefined, signal);
+				return {
+					connection,
+					sessionId: attachedSessionId(attached, operation)
+				};
+			} catch (cause) {
+				await connection.close();
+				throw cause;
+			}
+		};
+		closeCdpTargetSession = async (targetSession, enabledDomains, signal) => {
+			const { connection, sessionId } = targetSession;
+			const cleanup = new AbortController();
+			const domainSignal = signal === undefined ? cleanup.signal : AbortSignal.any([cleanup.signal, signal]);
+			const timeout = setTimeout(() => cleanup.abort(), 1e3);
+			timeout.unref();
+			try {
+				if (signal?.aborted !== true) {
+					for (const domain of enabledDomains) {
+						if (domainSignal.aborted) break;
+						try {
+							await connection.send(`${domain}.disable`, {}, sessionId, domainSignal);
+						} catch {}
+					}
+				}
+				if (!cleanup.signal.aborted && sessionId !== undefined) try {
+					await connection.send("Target.detachFromTarget", { sessionId }, undefined, cleanup.signal);
+				} catch {}
+			} finally {
+				clearTimeout(timeout);
+				cleanup.abort();
+				await connection.close();
+			}
+		};
+		attachedSessionId = (value, operation) => {
+			if (typeof value !== "object" || value === null || !("sessionId" in value) || typeof value.sessionId !== "string" || value.sessionId.length === 0) throw new BrowserObservationError(operation, "protocol_error");
+			return value.sessionId;
+		};
+	})))();
+}
+
+//#endregion
+//#region dist/browser/CdpCaptureCompleteness.js
+var EVENT_SECTIONS, POLICY_REASONS, CdpCaptureCompleteness, emptyDropped;
+function init_CdpCaptureCompleteness() {
+	return (init_CdpCaptureCompleteness = __esmMin((() => {
+		init_browserCompleteness();
+		EVENT_SECTIONS = {
+			scripts: "scripts",
+			network_requests: "network_requests",
+			console_events: "console_events",
+			websocket_connections: "websocket_connections",
+			websocket_frames: "websocket_frames",
+			webmcp_tools: "webmcp_tools",
+			timeline_events: "timeline"
+		};
+		POLICY_REASONS = new Set([
+			"disallowed_origin",
+			"unsupported_url",
+			"unattributed_origin",
+			"not_approved",
+			"out_of_target_scope"
+		]);
+		CdpCaptureCompleteness = class {
+			#initialAttachLimited;
+			#policyFiltered = new Set();
+			#attachLimited = new Set();
+			#truncated = new Set();
+			#unavailable = new Set();
+			#excluded = new Map();
+			#dropped = emptyDropped();
+			constructor(initialAttachLimited = []) {
+				this.#initialAttachLimited = [...initialAttachLimited];
+				this.reset();
+			}
+			reset() {
+				this.#policyFiltered.clear();
+				this.#attachLimited.clear();
+				this.#truncated.clear();
+				this.#unavailable.clear();
+				this.#excluded.clear();
+				Object.assign(this.#dropped, emptyDropped());
+				for (const section of this.#initialAttachLimited) this.#attachLimited.add(section);
+			}
+			exclude(section, reason, count = 1) {
+				if (POLICY_REASONS.has(reason)) this.#policyFiltered.add(section);
+				if (reason === "provider_unavailable" || reason === "invalid_protocol_value") this.#unavailable.add(section);
+				if (reason === "resource_budget_exhausted") this.#truncated.add(section);
+				const key = `${section}\0${reason}`;
+				const existing = this.#excluded.get(key);
+				const combined = count === null || existing?.count === null ? null : (existing?.count ?? 0) + count;
+				this.#excluded.set(key, {
+					section,
+					reason,
+					count: combined
+				});
+			}
+			attachLimited(section) {
+				this.#attachLimited.add(section);
+			}
+			unavailable(section) {
+				this.#unavailable.add(section);
+				this.exclude(section, "provider_unavailable", null);
+			}
+			truncate(section) {
+				this.#truncated.add(section);
+			}
+			drop(kind, count = 1) {
+				this.#dropped[kind] += count;
+				this.#truncated.add(EVENT_SECTIONS[kind]);
+			}
+			get droppedTotal() {
+				return Object.values(this.#dropped).reduce((sum, count) => sum + count, 0);
+			}
+			snapshot() {
+				return classifyBrowserCompleteness({
+					policyFilteredSections: this.#policyFiltered,
+					attachLimitedSections: this.#attachLimited,
+					truncatedSections: this.#truncated,
+					unavailableSections: this.#unavailable,
+					excluded: [...this.#excluded.values()],
+					droppedEvents: this.#dropped
+				});
+			}
+		};
+		emptyDropped = () => ({
+			scripts: 0,
+			network_requests: 0,
+			console_events: 0,
+			websocket_connections: 0,
+			websocket_frames: 0,
+			webmcp_tools: 0,
+			timeline_events: 0
+		});
+	})))();
+}
+
+//#endregion
+//#region dist/browser/CdpCaptureValues.js
+var isRecord$1, recordValue, recordsValue, cdpStringValue, numberValue, scriptMetadataValues, requiredRecord, requiredScriptSource, isHttpUrl, allowedSanitizedUrl, sourceResult, sourceExcluded, delayWithCancellation;
+function init_CdpCaptureValues() {
+	return (init_CdpCaptureValues = __esmMin((() => {
+		init_analysisErrorCore();
+		init_browserObservationError();
+		init_browserObservation();
+		init_webContentArtifact();
+		isRecord$1 = (value) => typeof value === "object" && value !== null && !Array.isArray(value);
+		recordValue = (value) => isRecord$1(value) ? value : undefined;
+		recordsValue = (value) => Array.isArray(value) ? value.flatMap((item) => {
+			const record = recordValue(item);
+			return record === undefined ? [] : [record];
+		}) : [];
+		cdpStringValue = (value) => typeof value === "string" ? value : undefined;
+		numberValue = (value) => typeof value === "number" && Number.isFinite(value) ? value : undefined;
+		scriptMetadataValues = (value) => {
+			const length = numberValue(value?.length);
+			return {
+				hash: cdpStringValue(value?.hash) ?? null,
+				length: length !== undefined && Number.isSafeInteger(length) && length >= 0 ? length : null,
+				isModule: typeof value?.isModule === "boolean" ? value.isModule : null
+			};
+		};
+		requiredRecord = (value) => {
+			const record = recordValue(value);
+			if (record === undefined) throw new BrowserObservationError("inspect_web_page", "protocol_error");
+			return record;
+		};
+		requiredScriptSource = (value, operation) => {
+			const source = cdpStringValue(recordValue(value)?.scriptSource);
+			if (source === undefined) throw new BrowserObservationError(operation, "protocol_error", { detail: "Debugger.getScriptSource returned malformed source text: scriptSource must be a string." });
+			return source;
+		};
+		isHttpUrl = (value) => {
+			if (value === undefined) return false;
+			try {
+				const protocol = new URL(value).protocol;
+				return protocol === "http:" || protocol === "https:";
+			} catch (cause) {
+				void cause;
+				return false;
+			}
+		};
+		allowedSanitizedUrl = (value, allowedOrigins) => {
+			const text = cdpStringValue(value);
+			if (text === undefined) return undefined;
+			const sanitized = sanitizeBrowserUrl(text);
+			return sanitized.origin !== null && allowedOrigins.has(sanitized.origin) ? sanitized : undefined;
+		};
+		sourceResult = (source) => ({
+			included: true,
+			artifact: createWebTextArtifact(source, "text/javascript")
+		});
+		sourceExcluded = (reason) => ({
+			included: false,
+			reason
+		});
+		delayWithCancellation = async (durationMs, operation, signal) => {
+			const maximumTimerDelay = 2147483647;
+			let remaining = durationMs;
+			while (remaining > 0) {
+				if (signal?.aborted === true) throw new AnalysisCancelledError(operation);
+				const delay = Math.min(remaining, maximumTimerDelay);
+				await new Promise((resolve, reject) => {
+					const timer = setTimeout(() => {
+						signal?.removeEventListener("abort", onAbort);
+						resolve();
+					}, delay);
+					const onAbort = () => {
+						clearTimeout(timer);
+						signal?.removeEventListener("abort", onAbort);
+						reject(new AnalysisCancelledError(operation));
+					};
+					signal?.addEventListener("abort", onAbort, { once: true });
+					if (signal?.aborted === true) onAbort();
+				});
+				remaining -= delay;
+			}
+		};
+	})))();
+}
+
+//#endregion
+//#region dist/browser/CdpCaptureEventHelpers.js
+var isMainFrameNavigation, firstCallFrame, initiatorLocation, exclusionReasonForUrl, integerOrNull, executionContextKey, isJsonContentType, isJsonMediaType, consolePrimitive, BASE64, decodeBase64;
+function init_CdpCaptureEventHelpers() {
+	return (init_CdpCaptureEventHelpers = __esmMin((() => {
+		init_CdpCaptureValues();
+		isMainFrameNavigation = (event, mainFrameId) => {
+			const params = recordValue(event.params);
+			if (params === undefined) return false;
+			const frameId = event.method === "Page.frameNavigated" ? cdpStringValue(recordValue(params.frame)?.id) : event.method === "Page.frameRequestedNavigation" || event.method === "Page.navigatedWithinDocument" ? cdpStringValue(params.frameId) : undefined;
+			return frameId === mainFrameId;
+		};
+		firstCallFrame = (value) => recordsValue(value?.callFrames)[0];
+		initiatorLocation = (initiator) => {
+			let stack = recordValue(initiator?.stack);
+			for (let depth = 0; depth < 32 && stack !== undefined; depth += 1) {
+				const frame = firstCallFrame(stack);
+				if (frame !== undefined) return frame;
+				stack = recordValue(stack.parent);
+			}
+			return cdpStringValue(initiator?.url) === undefined ? undefined : initiator;
+		};
+		exclusionReasonForUrl = (value) => value === undefined || value === "" ? "unattributed_origin" : isHttpUrl(value) ? "disallowed_origin" : "unsupported_url";
+		integerOrNull = (value) => {
+			const number = numberValue(value);
+			return number === undefined ? null : Math.max(0, Math.trunc(number));
+		};
+		executionContextKey = (value) => {
+			const identifier = numberValue(value);
+			return identifier !== undefined && Number.isSafeInteger(identifier) ? String(identifier) : null;
+		};
+		isJsonContentType = (headers) => {
+			if (headers === undefined) return false;
+			for (const [name, value] of Object.entries(headers)) if (name.toLowerCase() === "content-type" && isJsonMediaType(cdpStringValue(value))) return true;
+			return false;
+		};
+		isJsonMediaType = (value) => {
+			const mediaType = value?.split(";", 1)[0]?.trim().toLowerCase();
+			return mediaType === "application/json" || mediaType?.endsWith("+json") === true;
+		};
+		consolePrimitive = (value) => {
+			const type = cdpStringValue(value.type);
+			switch (type) {
+				case "string": return typeof value.value === "string" ? {
+					type,
+					text: value.value
+				} : undefined;
+				case "boolean": return typeof value.value === "boolean" ? {
+					type,
+					text: String(value.value)
+				} : undefined;
+				case "number": return typeof value.value === "number" ? {
+					type,
+					text: String(value.value)
+				} : typeof value.unserializableValue === "string" ? {
+					type,
+					text: value.unserializableValue
+				} : undefined;
+				case "bigint": return typeof value.unserializableValue === "string" ? {
+					type,
+					text: value.unserializableValue
+				} : undefined;
+				case "undefined": return {
+					type,
+					text: "undefined"
+				};
+				default: return undefined;
+			}
+		};
+		BASE64 = /^(?:[A-Za-z\d+/]{4})*(?:[A-Za-z\d+/]{2}==|[A-Za-z\d+/]{3}=)?$/u;
+		decodeBase64 = (value) => value.length % 4 === 0 && BASE64.test(value) ? Buffer.from(value, "base64") : undefined;
+	})))();
+}
+
+//#endregion
+//#region dist/browser/CdpCaptureDomSvg.js
+var SVG_NAMESPACE, XLINK_NAMESPACE, UNRESOLVED, stringAt, numberArray$1, xmlDocument, createDocumentSvgAncestry, domSvgLink, elementInSvgContext, resolveXmlElements, applyDeclarations, xmlnsPrefix, elementNamespace, xlinkHrefValue;
+function init_CdpCaptureDomSvg() {
+	return (init_CdpCaptureDomSvg = __esmMin((() => {
+		init_CdpCaptureValues();
+		SVG_NAMESPACE = "http://www.w3.org/2000/svg";
+		XLINK_NAMESPACE = "http://www.w3.org/1999/xlink";
+		UNRESOLVED = {
+			svgElement: false,
+			xlinkHref: undefined
+		};
+		stringAt = (strings, index) => {
+			const integer = numberValue(index);
+			return integer === undefined ? "" : strings[Math.trunc(integer)] ?? "";
+		};
+		numberArray$1 = (value) => Array.isArray(value) ? value.flatMap((item) => {
+			const number = numberValue(item);
+			return number === undefined ? [] : [number];
+		}) : [];
+		xmlDocument = (nodes) => {
+			const documentIndex = nodes.nodeTypes.findIndex((nodeType) => Math.trunc(nodeType) === 9);
+			if (documentIndex < 0) return false;
+			for (let index = 0; index < nodes.nodeTypes.length; index += 1) {
+				if (Math.trunc(nodes.nodeTypes[index] ?? 0) !== 1) continue;
+				if (Math.trunc(nodes.parents[index] ?? -1) !== documentIndex) continue;
+				const name = stringAt(nodes.strings, nodes.nodeNames[index]);
+				if (name === "HTML") return false;
+				if (name === "html" || name.includes(":")) return true;
+				const attributes = numberArray$1(nodes.attributes[index]);
+				return attributes.some((value, offset) => offset % 2 === 0 && xmlnsPrefix(stringAt(nodes.strings, value)) !== undefined);
+			}
+			return false;
+		};
+		createDocumentSvgAncestry = (nodes) => {
+			const xml = xmlDocument(nodes);
+			return {
+				xml,
+				nodes,
+				svgContexts: new Map(),
+				xmlLinks: xml ? resolveXmlElements(nodes) : new Map()
+			};
+		};
+		domSvgLink = (ancestry, index) => {
+			if (!ancestry.xml) {
+				return {
+					svgElement: elementInSvgContext(index, ancestry.nodes, ancestry.svgContexts),
+					xmlDocument: false,
+					xlinkHref: undefined
+				};
+			}
+			const resolved = ancestry.xmlLinks.get(index) ?? UNRESOLVED;
+			return {
+				svgElement: resolved.svgElement,
+				xmlDocument: true,
+				xlinkHref: resolved.xlinkHref
+			};
+		};
+		elementInSvgContext = (index, nodes, contexts) => {
+			let current = index;
+			const seen = new Set();
+			let inSvg = false;
+			while (current >= 0 && current < nodes.nodeNames.length && !seen.has(current)) {
+				const cached = contexts.get(current);
+				if (cached !== undefined) {
+					inSvg = cached;
+					break;
+				}
+				seen.add(current);
+				if (stringAt(nodes.strings, nodes.nodeNames[current]) === "svg") {
+					inSvg = true;
+					break;
+				}
+				const parent = Math.trunc(nodes.parents[current] ?? -1);
+				if (parent < 0 || parent === current) break;
+				if (stringAt(nodes.strings, nodes.nodeNames[parent]) === "foreignObject") break;
+				current = parent;
+			}
+			for (const node of seen) contexts.set(node, inSvg);
+			return inSvg;
+		};
+		resolveXmlElements = (nodes) => {
+			const children = new Map();
+			const pending = [];
+			for (let node = 0; node < nodes.nodeNames.length; node += 1) {
+				const parent = Math.trunc(nodes.parents[node] ?? -1);
+				if (parent < 0) pending.push({ node });
+				else if (parent < nodes.nodeNames.length && parent !== node) {
+					const siblings = children.get(parent);
+					if (siblings === undefined) children.set(parent, [node]);
+					else siblings.push(node);
+				}
+			}
+			const bindings = new Map();
+			const resolved = new Map();
+			while (pending.length > 0) {
+				const step = pending.pop();
+				if (step === undefined) break;
+				if ("restore" in step) {
+					for (const { prefix, previous } of step.restore) {
+						if (previous === undefined) bindings.delete(prefix);
+						else bindings.set(prefix, previous);
+					}
+					continue;
+				}
+				const { node } = step;
+				const attributes = numberArray$1(nodes.attributes[node]);
+				const restore = applyDeclarations(bindings, attributes, nodes.strings);
+				const svgElement = Math.trunc(nodes.nodeTypes[node] ?? 0) === 1 && elementNamespace(stringAt(nodes.strings, nodes.nodeNames[node]), bindings) === SVG_NAMESPACE;
+				resolved.set(node, {
+					svgElement,
+					xlinkHref: svgElement ? xlinkHrefValue(attributes, nodes.strings, bindings) : undefined
+				});
+				pending.push({ restore });
+				for (const child of children.get(node) ?? []) pending.push({ node: child });
+			}
+			return resolved;
+		};
+		applyDeclarations = (bindings, attributes, strings) => {
+			const restore = [];
+			const seen = new Set();
+			for (let index = 0; index + 1 < attributes.length; index += 2) {
+				const prefix = xmlnsPrefix(stringAt(strings, attributes[index]));
+				if (prefix === undefined || seen.has(prefix)) continue;
+				seen.add(prefix);
+				restore.push({
+					prefix,
+					previous: bindings.get(prefix)
+				});
+				const value = stringAt(strings, attributes[index + 1]);
+				if (value.length === 0) bindings.delete(prefix);
+				else bindings.set(prefix, value);
+			}
+			return restore;
+		};
+		xmlnsPrefix = (name) => {
+			if (name === "xmlns") return "";
+			if (!name.startsWith("xmlns:")) return undefined;
+			const prefix = name.slice("xmlns:".length);
+			if (prefix.length === 0 || prefix === "xmlns" || prefix.includes(":")) return undefined;
+			return prefix;
+		};
+		elementNamespace = (nodeName, bindings) => {
+			const colon = nodeName.indexOf(":");
+			if (colon < 0) return bindings.get("") ?? "";
+			const prefix = nodeName.slice(0, colon);
+			const local = nodeName.slice(colon + 1);
+			if (prefix.length === 0 || local.length === 0 || local.includes(":") || prefix === "xmlns") return "";
+			return bindings.get(prefix) ?? "";
+		};
+		xlinkHrefValue = (attributes, strings, bindings) => {
+			const seen = new Set();
+			for (let index = 0; index + 1 < attributes.length; index += 2) {
+				const name = stringAt(strings, attributes[index]);
+				if (seen.has(name)) continue;
+				seen.add(name);
+				const colon = name.indexOf(":");
+				if (colon <= 0) continue;
+				const prefix = name.slice(0, colon);
+				const local = name.slice(colon + 1);
+				if (local !== "href" || bindings.get(prefix) !== XLINK_NAMESPACE) continue;
+				return stringAt(strings, attributes[index + 1]);
+			}
+			return undefined;
+		};
+	})))();
+}
+
+//#endregion
+//#region dist/browser/CdpCaptureDocuments.js
+var captureFrames, mainFrameUrl, captureResources, walkFrameTrees, captureDom, captureAccessibility, ACCESSIBILITY_STATE_NAMES, accessibilityStates, axText, indexedString, uniqueAttributeNames, numberArray, hrefAttributeValue, domMetadata, domDestination, domUrlAttributes, agentRelValues;
+function init_CdpCaptureDocuments() {
+	return (init_CdpCaptureDocuments = __esmMin((() => {
+		init_CdpCaptureValues();
+		init_CdpCaptureEventHelpers();
+		init_CdpCaptureDomSvg();
+		init_unicodeCodePointOrder();
+		captureFrames = (result, allowedOrigins, maximum, completeness) => {
+			const root = recordValue(recordValue(result)?.frameTree);
+			if (root === undefined) {
+				completeness?.exclude("frames", "invalid_protocol_value");
+				return { items: [] };
+			}
+			const items = [];
+			for (const tree of walkFrameTrees(root, () => completeness?.exclude("frames", "invalid_protocol_value"))) {
+				const frame = recordValue(tree.frame);
+				const frameId = cdpStringValue(frame?.id);
+				const sanitized = allowedSanitizedUrl(frame?.url, allowedOrigins);
+				if (frame === undefined || frameId === undefined) {
+					completeness?.exclude("frames", "invalid_protocol_value");
+					continue;
+				}
+				if (sanitized === undefined || sanitized.origin === null) {
+					completeness?.exclude("frames", exclusionReasonForUrl(cdpStringValue(frame.url)));
+					continue;
+				}
+				if (maximum !== undefined && items.length >= maximum) continue;
+				items.push({
+					frame_id: frameId,
+					parent_frame_id: cdpStringValue(frame.parentId) ?? null,
+					url: sanitized.url,
+					origin: sanitized.origin
+				});
+			}
+			return { items };
+		};
+		mainFrameUrl = (result) => cdpStringValue(recordValue(recordValue(requiredRecord(result).frameTree)?.frame)?.url);
+		captureResources = (result, allowedOrigins, completeness) => {
+			const root = recordValue(recordValue(result)?.frameTree);
+			if (root === undefined) {
+				completeness?.exclude("resources", "invalid_protocol_value");
+				return { items: [] };
+			}
+			const items = [];
+			for (const tree of walkFrameTrees(root, () => completeness?.exclude("resources", "invalid_protocol_value"))) {
+				for (const resource of recordsValue(tree.resources)) {
+					const url = allowedSanitizedUrl(resource.url, allowedOrigins);
+					if (url === undefined || url.origin === null) {
+						completeness?.exclude("resources", exclusionReasonForUrl(cdpStringValue(resource.url)));
+						continue;
+					}
+					const contentSize = numberValue(resource.contentSize);
+					items.push({
+						rawUrl: cdpStringValue(resource.url) ?? "",
+						url: url.url,
+						origin: url.origin,
+						type: cdpStringValue(resource.type) ?? "Other",
+						mime_type: cdpStringValue(resource.mimeType) ?? "",
+						content_size: contentSize === undefined ? null : Math.max(0, contentSize)
+					});
+				}
+			}
+			return { items };
+		};
+		walkFrameTrees = function* (root, onMalformedChild) {
+			const pending = [root];
+			while (pending.length > 0) {
+				const tree = pending.pop();
+				if (tree === undefined) return;
+				const rawChildren = tree.childFrames;
+				if (rawChildren !== undefined && !Array.isArray(rawChildren)) onMalformedChild?.();
+				const children = Array.isArray(rawChildren) ? rawChildren.flatMap((child) => {
+					const parsed = recordValue(child);
+					if (parsed === undefined) onMalformedChild?.();
+					return parsed === undefined ? [] : [parsed];
+				}) : [];
+				for (let index = children.length - 1; index >= 0; index -= 1) {
+					const child = children[index];
+					if (child !== undefined) pending.push(child);
+				}
+				yield tree;
+			}
+		};
+		captureDom = (result, allowedOrigins, input, completeness) => {
+			const root = requiredRecord(result);
+			const strings = Array.isArray(root.strings) ? root.strings.map((value) => cdpStringValue(value) ?? "") : [];
+			const nodes = [];
+			const urls = [];
+			const agentHints = [];
+			let excludedUrls = 0;
+			let total = 0;
+			for (const document of recordsValue(root.documents)) {
+				const documentUrl = indexedString(strings, document.documentURL);
+				if (allowedSanitizedUrl(documentUrl, allowedOrigins) === undefined) {
+					completeness?.exclude("dom", exclusionReasonForUrl(documentUrl));
+					continue;
+				}
+				const baseUrl = indexedString(strings, document.baseURL) || documentUrl;
+				const documentNodes = recordValue(document.nodes);
+				if (documentNodes === undefined) continue;
+				const nodeTypes = numberArray(documentNodes.nodeType);
+				const nodeNames = numberArray(documentNodes.nodeName);
+				const nodeValues = numberArray(documentNodes.nodeValue);
+				const parents = numberArray(documentNodes.parentIndex);
+				const attributes = Array.isArray(documentNodes.attributes) ? documentNodes.attributes : [];
+				const baseIndex = nodes.length;
+				const ancestry = createDocumentSvgAncestry({
+					nodeTypes,
+					nodeNames,
+					parents,
+					strings,
+					attributes
+				});
+				total += nodeTypes.length;
+				for (let index = 0; index < nodeTypes.length; index += 1) {
+					const attributeIndexes = numberArray(attributes[index]);
+					const parent = Math.trunc(parents[index] ?? -1);
+					const nodeIndex = nodes.length;
+					const nodeName = indexedString(strings, nodeNames[index]);
+					const attributeNames = uniqueAttributeNames(attributeIndexes, strings);
+					nodes.push({
+						index: nodeIndex,
+						parent_index: parent < 0 ? -1 : baseIndex + parent,
+						node_type: Math.max(0, Math.trunc(nodeTypes[index] ?? 0)),
+						node_name: nodeName,
+						node_value_length: indexedString(strings, nodeValues[index]).length,
+						attribute_names: attributeNames
+					});
+					const metadata = domMetadata({
+						strings,
+						attributes: attributeIndexes,
+						baseUrl: nodeName.toLowerCase() === "base" ? documentUrl : baseUrl,
+						documentUrl,
+						nodeIndex,
+						nodeName,
+						allowedOrigins,
+						...domSvgLink(ancestry, index)
+					});
+					for (const url of metadata.urls) {
+						urls.push(url);
+						if (url.destination_scope !== "approved") {
+							excludedUrls += 1;
+							completeness?.exclude("metadata", url.destination_scope === "outside_policy" ? "disallowed_origin" : "unsupported_url");
+						}
+					}
+					agentHints.push(...metadata.agentHints);
+				}
+			}
+			return {
+				total,
+				nodes,
+				urls,
+				agentHints,
+				excludedUrls
+			};
+		};
+		captureAccessibility = (results, options) => {
+			const all = results.flatMap((result) => recordsValue(requiredRecord(result).nodes));
+			const nodeIds = new Set(all.flatMap((node) => {
+				const nodeId = cdpStringValue(node.nodeId);
+				return nodeId === undefined ? [] : [nodeId];
+			}));
+			let excludedFields = 0;
+			const nodes = all.map((node) => {
+				const captureText = (value) => {
+					const raw = cdpStringValue(recordValue(value)?.value);
+					if (raw === undefined) return null;
+					if (!options.includeText) {
+						excludedFields += 1;
+						return null;
+					}
+					return raw;
+				};
+				return {
+					node_id: cdpStringValue(node.nodeId) ?? "",
+					parent_id: cdpStringValue(node.parentId) ?? null,
+					role: axText(node.role),
+					name: captureText(node.name),
+					description: captureText(node.description),
+					ignored: node.ignored === true,
+					states: accessibilityStates(node.properties)
+				};
+			});
+			return {
+				total: all.length,
+				nodes,
+				treeIncomplete: all.some((node) => Array.isArray(node.childIds) && node.childIds.some((childId) => {
+					const id = cdpStringValue(childId);
+					return id !== undefined && !nodeIds.has(id);
+				})),
+				textCapture: {
+					status: options.unavailable ? "unavailable" : !options.includeText ? "not_approved" : "included",
+					retained_bytes: nodes.reduce((total, node) => total + Buffer.byteLength(node.name ?? "") + Buffer.byteLength(node.description ?? ""), 0),
+					excluded_fields: excludedFields
+				}
+			};
+		};
+		ACCESSIBILITY_STATE_NAMES = new Set([
+			"atomic",
+			"autocomplete",
+			"busy",
+			"checked",
+			"disabled",
+			"editable",
+			"expanded",
+			"focusable",
+			"focused",
+			"hasPopup",
+			"hidden",
+			"invalid",
+			"level",
+			"live",
+			"modal",
+			"multiline",
+			"multiselectable",
+			"orientation",
+			"pressed",
+			"readonly",
+			"required",
+			"selected",
+			"valuemax",
+			"valuemin"
+		]);
+		accessibilityStates = (value) => {
+			const states = new Map();
+			for (const property of recordsValue(value)) {
+				const name = cdpStringValue(property.name);
+				if (name === undefined || !ACCESSIBILITY_STATE_NAMES.has(name)) continue;
+				const raw = recordValue(property.value)?.value;
+				const state = typeof raw === "boolean" ? raw : typeof raw === "number" ? numberValue(raw) : typeof raw === "string" ? raw : undefined;
+				if (state !== undefined) states.set(name, state);
+			}
+			return [...states].sort(([left], [right]) => compareUnicodeCodePoints(left, right)).map(([name, state]) => ({
+				name,
+				value: state
+			}));
+		};
+		axText = (value) => cdpStringValue(recordValue(value)?.value) ?? null;
+		indexedString = (strings, index) => {
+			const integer = numberValue(index);
+			return integer === undefined ? "" : strings[Math.trunc(integer)] ?? "";
+		};
+		uniqueAttributeNames = (attributeIndexes, strings) => {
+			const names = [];
+			const seen = new Set();
+			for (let index = 0; index < attributeIndexes.length; index += 2) {
+				const name = indexedString(strings, attributeIndexes[index]);
+				if (seen.has(name)) continue;
+				seen.add(name);
+				names.push(name);
+			}
+			return names;
+		};
+		numberArray = (value) => Array.isArray(value) ? value.flatMap((item) => {
+			const number = numberValue(item);
+			return number === undefined ? [] : [number];
+		}) : [];
+		hrefAttributeValue = (pairs, attribute, options) => {
+			const declared = pairs.get(attribute);
+			if (declared !== undefined) return declared;
+			if (attribute !== "href" || !options.svgElement) return undefined;
+			return options.xmlDocument ? options.xlinkHref : pairs.get("xlink:href");
+		};
+		domMetadata = (options) => {
+			const { strings, attributes, baseUrl, documentUrl, nodeIndex, nodeName, allowedOrigins } = options;
+			const pairs = new Map();
+			for (let index = 0; index + 1 < attributes.length; index += 2) {
+				const name = indexedString(strings, attributes[index]);
+				const value = indexedString(strings, attributes[index + 1]);
+				if (!pairs.has(name)) pairs.set(name, value);
+			}
+			const urls = [];
+			for (const attribute of domUrlAttributes) {
+				const value = hrefAttributeValue(pairs, attribute, options);
+				if (value === undefined) continue;
+				const tagName = nodeName.toLowerCase();
+				const usesDocumentUrl = tagName === "form" && attribute === "action" && /^[\t\n\f\r ]*$/u.test(value) || (tagName === "button" || tagName === "input") && attribute === "formaction" && value === "";
+				const destination = domDestination(usesDocumentUrl ? documentUrl : value, baseUrl, allowedOrigins);
+				urls.push({
+					node_index: nodeIndex,
+					attribute,
+					url: destination.url,
+					destination_scope: destination.scope
+				});
+			}
+			const rel = (pairs.get("rel") ?? "").toLowerCase().split(/\s+/u).filter((value) => agentRelValues.includes(value));
+			const href = urls.find(({ attribute }) => attribute === "href")?.url ?? null;
+			const agentHints = nodeName.toLowerCase() === "link" && rel.length > 0 ? rel.map((declaration) => ({
+				mechanism: "dom_link_rel",
+				declaration,
+				url: href,
+				trust: "page-declared-untrusted"
+			})) : [];
+			return {
+				urls,
+				agentHints
+			};
+		};
+		domDestination = (value, baseUrl, allowedOrigins) => {
+			try {
+				const parsed = new URL(value, baseUrl);
+				if (parsed.protocol !== "http:" && parsed.protocol !== "https:") return {
+					url: null,
+					scope: "unsupported"
+				};
+				if (!allowedOrigins.has(parsed.origin)) return {
+					url: null,
+					scope: "outside_policy"
+				};
+				return {
+					url: allowedSanitizedUrl(parsed.href, allowedOrigins)?.url ?? null,
+					scope: "approved"
+				};
+			} catch (cause) {
+				void cause;
+				return {
+					url: null,
+					scope: "unsupported"
+				};
+			}
+		};
+		domUrlAttributes = [
+			"href",
+			"src",
+			"action",
+			"formaction",
+			"poster"
+		];
+		agentRelValues = [
+			"mcp",
+			"model-context",
+			"ai-plugin",
+			"service-desc"
+		];
+	})))();
+}
+
+//#endregion
+//#region dist/browser/CdpOptionalCommand.js
+var optionalCdpCommand;
+function init_CdpOptionalCommand() {
+	return (init_CdpOptionalCommand = __esmMin((() => {
+		init_CdpCommandRejection();
+		init_CdpConnection();
+		optionalCdpCommand = async (context, method, parameters, limitations) => {
+			try {
+				return await context.connection.send(method, parameters, context.sessionId, context.signal);
+			} catch (cause) {
+				if (!(cause instanceof CdpCommandRejection) || cause.code !== -32601) throw cause;
+				limitations.push(`${method} was unavailable from this browser target.`);
+				return undefined;
+			}
+		};
+	})))();
+}
+
+//#endregion
+//#region dist/browser/ElectronFileScope.js
+var authorizedElectronFile, authorizedAsarMember, MAX_CACHED_HEADERS, headerCache, archiveIdentity, asarFiles, isAsarRegularFile, isRecord;
+function init_ElectronFileScope() {
+	return (init_ElectronFileScope = __esmMin((() => {
+		init_AsarHeader();
+		authorizedElectronFile = async (value) => {
+			if (/%(?:2f|5c)/iu.test(value)) return undefined;
+			let url;
+			try {
+				url = new URL(value);
+			} catch (cause) {
+				void cause;
+				return undefined;
+			}
+			if (url.protocol !== "file:" || url.hostname !== "" || url.username !== "" || url.password !== "") return undefined;
+			let path;
+			try {
+				path = fileURLToPath(url);
+			} catch (cause) {
+				void cause;
+				return undefined;
+			}
+			if (!isAbsolute(path) || path.includes("\0")) return undefined;
+			try {
+				if ((await stat(path)).isFile()) return await realpath(path);
+			} catch (cause) {
+				void cause;
+			}
+			return await authorizedAsarMember(path);
+		};
+		authorizedAsarMember = async (path) => {
+			const segments = path.split(sep);
+			for (let index = 1; index < segments.length - 1; index += 1) {
+				if (!(segments[index] ?? "").toLowerCase().endsWith(".asar")) continue;
+				const archive = segments.slice(0, index + 1).join(sep);
+				const member = segments.slice(index + 1);
+				if (member.some((part) => part === "" || part === "." || part === "..")) return undefined;
+				try {
+					const metadata = await stat(archive);
+					if (!metadata.isFile()) continue;
+					const canonical = await realpath(archive);
+					const files = await asarFiles(canonical, metadata);
+					return isAsarRegularFile(files, member) ? join(canonical, ...member) : undefined;
+				} catch (cause) {
+					void cause;
+					return undefined;
+				}
+			}
+			return undefined;
+		};
+		MAX_CACHED_HEADERS = 8;
+		headerCache = new Map();
+		archiveIdentity = (metadata) => `${String(metadata.dev)}:${String(metadata.ino)}:${String(metadata.size)}:${String(metadata.mtimeMs)}`;
+		asarFiles = async (archive, metadata) => {
+			const identity = archiveIdentity(metadata);
+			const cached = headerCache.get(archive);
+			if (cached?.identity === identity) return cached.files;
+			const handle = await open(archive, "r");
+			let files;
+			let jsonBytes;
+			try {
+				const opened = await handle.stat();
+				if (!opened.isFile() || archiveIdentity(opened) !== identity) throw new Error("ASAR identity changed before header read");
+				const admitted = await admitAsarHeader(handle);
+				jsonBytes = admitted.jsonBytes;
+				const json = Buffer.alloc(jsonBytes);
+				let offset = 0;
+				while (offset < json.length) {
+					const part = await handle.read(json, offset, json.length - offset, 16 + offset);
+					if (part.bytesRead === 0) throw new Error("Truncated ASAR JSON header");
+					offset += part.bytesRead;
+				}
+				if (archiveIdentity(await handle.stat()) !== identity) throw new Error("ASAR identity changed during header read");
+				const parsed = JSON.parse(new TextDecoder("utf-8", { fatal: true }).decode(json));
+				if (!isRecord(parsed) || !isRecord(parsed.files)) throw new Error("ASAR header has no file tree");
+				files = parsed.files;
+			} finally {
+				await handle.close();
+			}
+			headerCache.delete(archive);
+			headerCache.set(archive, {
+				identity,
+				files,
+				bytes: jsonBytes
+			});
+			const retainedBytes = () => [...headerCache.values()].reduce((sum, entry) => sum + entry.bytes, 0);
+			while (headerCache.size > MAX_CACHED_HEADERS || retainedBytes() > 16777216) headerCache.delete(headerCache.keys().next().value ?? archive);
+			return files;
+		};
+		isAsarRegularFile = (files, member) => {
+			let node = { files };
+			for (const part of member) {
+				const children = isRecord(node) ? node.files : undefined;
+				if (!isRecord(children) || !Object.hasOwn(children, part)) return false;
+				node = children[part];
+			}
+			return isRecord(node) && typeof node.size === "number" && !("files" in node) && !("link" in node);
+		};
+		isRecord = (value) => typeof value === "object" && value !== null && !Array.isArray(value);
+	})))();
+}
+
+//#endregion
+export { CdpCaptureCompleteness, CdpCommandRejection, CdpConnection, allowedSanitizedUrl, authorizedElectronFile, captureAccessibility, captureDom, captureFrames, captureResources, cdpStringValue, closeCdpTargetSession, consolePrimitive, decodeBase64, delayWithCancellation, discoverCdpEndpoint, exclusionReasonForUrl, executionContextKey, firstCallFrame, hasCdpTargetWebSocket, init_CdpCaptureCompleteness, init_CdpCaptureDocuments, init_CdpCaptureEventHelpers, init_CdpCaptureValues, init_CdpCommandRejection, init_CdpConnection, init_CdpEndpoint, init_CdpOptionalCommand, init_CdpTargetSession, init_ElectronFileScope, initiatorLocation, integerOrNull, isHttpUrl, isJsonContentType, isJsonMediaType, isMainFrameNavigation, mainFrameUrl, numberValue, openCdpTargetSession, optionalCdpCommand, parseCdpEndpointValue, readCdpJson, recordValue, recordsValue, requiredRecord, requiredScriptSource, scriptMetadataValues, sourceExcluded, sourceResult, walkFrameTrees };