@olimsaidov/icdp 0.1.0

package/dist/frame/index.mjs

@@ -0,0 +1,782 @@
+import { CDP_SERVER_ERROR, isHandshakeMessage } from "../protocol.mjs";
+import { createDomRegistry, getAXNodeAndAncestors, getChildAXNodes, getFullAXTree, getPartialAXTree, getRootAXNode, queryAXTree } from "./ax-tree.mjs";
+import chobitsu from "chobitsu";
+//#region src/frame/index.ts
+const cdp = chobitsu;
+const frameId = "icdp-frame";
+const registry = createDomRegistry();
+const noop = () => ({});
+let port = null;
+let nextScriptIdentifier = 1;
+let nextSearchId = 1;
+const outboundMethods = /* @__PURE__ */ new Map();
+const searchResults = /* @__PURE__ */ new Map();
+let runtimeEnabled = false;
+const queuedRuntimeEvents = [];
+const consoleWrapped = Symbol("icdp-console-wrapped");
+let pressedElement = null;
+let hoveredElement = null;
+let lastClickElement = null;
+let lastClickTime = 0;
+function sendToHost(message) {
+	port?.postMessage(JSON.stringify(message));
+}
+function sendRuntimeEvent(message) {
+	if (runtimeEnabled) sendToHost(message);
+	else {
+		queuedRuntimeEvents.push(message);
+		if (queuedRuntimeEvents.length > 200) queuedRuntimeEvents.shift();
+	}
+}
+chobitsu.setOnMessage((raw) => {
+	let message;
+	try {
+		message = JSON.parse(raw);
+	} catch {
+		return;
+	}
+	if (message.id != null) {
+		const method = outboundMethods.get(message.id);
+		outboundMethods.delete(message.id);
+		if (method && message.error?.message === `${method} unimplemented`) message.error = {
+			code: CDP_SERVER_ERROR,
+			message: `Method not found: ${method}`
+		};
+		else if (message.error && message.error.code == null) message.error = {
+			...message.error,
+			code: CDP_SERVER_ERROR
+		};
+	}
+	sendToHost(message);
+});
+function elementForBackendId(id) {
+	const node = registry.nodeForBackendId(id);
+	const element = node instanceof Element ? node : node?.parentElement;
+	if (!element) throw new Error(`No element for backendDOMNodeId=${id}`);
+	return element;
+}
+function boxModel(id) {
+	const rect = elementForBackendId(id).getBoundingClientRect();
+	const quad = [
+		rect.left,
+		rect.top,
+		rect.right,
+		rect.top,
+		rect.right,
+		rect.bottom,
+		rect.left,
+		rect.bottom
+	].map(Math.round);
+	return { model: {
+		content: quad,
+		padding: quad,
+		border: quad,
+		margin: quad,
+		width: Math.round(rect.width),
+		height: Math.round(rect.height)
+	} };
+}
+function contentQuads(id) {
+	return { quads: [boxModel(id).model.content] };
+}
+function describeNode(id) {
+	const node = registry.nodeForBackendId(id);
+	if (!node) throw new Error(`No element for backendDOMNodeId=${id}`);
+	return { node: domNode(node, 0) };
+}
+function attributesFor(el) {
+	const attributes = [];
+	for (const attr of el.attributes) attributes.push(attr.name, attr.value);
+	return attributes;
+}
+function childNodesFor(node, depth) {
+	if (depth === 0) return [];
+	const nextDepth = depth < 0 ? -1 : depth - 1;
+	return Array.from(node.childNodes).map((child) => domNode(child, nextDepth));
+}
+function domNode(node, depth) {
+	const nodeId = registry.backendIdFor(node);
+	const children = childNodesFor(node, depth);
+	const nodeName = node instanceof Element && node.namespaceURI === "http://www.w3.org/1999/xhtml" ? node.nodeName.toUpperCase() : node.nodeName;
+	const result = {
+		backendNodeId: nodeId,
+		localName: node instanceof Element ? node.localName : "",
+		nodeId,
+		nodeName,
+		nodeType: node.nodeType,
+		nodeValue: node.nodeValue ?? ""
+	};
+	if (node.hasChildNodes()) {
+		result.childNodeCount = node.childNodes.length;
+		if (depth !== 0) result.children = children;
+	}
+	if (node instanceof Document) {
+		result.documentURL = location.href;
+		result.baseURL = document.baseURI;
+		result.xmlVersion = "";
+	} else if (node instanceof DocumentType) {
+		result.publicId = node.publicId;
+		result.systemId = node.systemId;
+		result.internalSubset = node.internalSubset;
+	} else if (node instanceof Element) {
+		result.attributes = attributesFor(node);
+		if (node instanceof HTMLIFrameElement && node.contentDocument) {
+			result.frameId = `${frameId}:${nodeId}`;
+			result.contentDocument = domNode(node.contentDocument, depth);
+		}
+	}
+	return result;
+}
+function runtimeValue(value) {
+	if (value === void 0) return { type: "undefined" };
+	if (value === null) return {
+		type: "object",
+		subtype: "null",
+		value: null
+	};
+	if (value instanceof Node) return nodeRuntimeValue(value);
+	if (typeof value === "bigint") return {
+		type: "bigint",
+		unserializableValue: `${value}n`,
+		description: `${value}n`
+	};
+	if (typeof value === "symbol") return {
+		type: "symbol",
+		description: String(value)
+	};
+	if (typeof value === "function") return {
+		type: "function",
+		description: String(value)
+	};
+	if (typeof value === "number" && !Number.isFinite(value)) return {
+		type: "number",
+		unserializableValue: String(value),
+		description: String(value)
+	};
+	if (typeof value === "object") return {
+		type: "object",
+		value: JSON.parse(JSON.stringify(value)),
+		description: Object.prototype.toString.call(value)
+	};
+	return {
+		type: typeof value,
+		value
+	};
+}
+function nodeRuntimeValue(node) {
+	const element = node instanceof Element ? node : node.parentElement;
+	const objectId = `backend:${registry.backendIdFor(element || node)}`;
+	return {
+		type: "object",
+		subtype: "node",
+		className: node instanceof Element ? node.constructor.name : "Node",
+		description: node instanceof Element ? node.outerHTML : node.nodeName,
+		objectId
+	};
+}
+function cloneConsoleObject(value, seen = /* @__PURE__ */ new WeakSet(), depth = 0) {
+	if (value === null || typeof value !== "object") return value;
+	if (seen.has(value)) return "[Circular]";
+	if (depth >= 4) return Object.prototype.toString.call(value);
+	seen.add(value);
+	if (value instanceof Error) return {
+		name: value.name,
+		message: value.message,
+		stack: value.stack
+	};
+	if (value instanceof Element) return {
+		tagName: value.tagName.toLowerCase(),
+		id: value.id || void 0,
+		className: typeof value.className === "string" && value.className ? value.className : void 0,
+		textContent: (value.textContent || "").trim().slice(0, 120) || void 0
+	};
+	if (Array.isArray(value)) return value.slice(0, 100).map((item) => cloneConsoleObject(item, seen, depth + 1));
+	if (value instanceof Map) return { entries: Array.from(value.entries()).slice(0, 100).map(([key, entryValue]) => [cloneConsoleObject(key, seen, depth + 1), cloneConsoleObject(entryValue, seen, depth + 1)]) };
+	if (value instanceof Set) return { values: Array.from(value.values()).slice(0, 100).map((item) => cloneConsoleObject(item, seen, depth + 1)) };
+	if (value instanceof Date) return value.toISOString();
+	if (value instanceof RegExp) return String(value);
+	return Object.fromEntries(Object.entries(value).slice(0, 100).map(([key, entryValue]) => [key, cloneConsoleObject(entryValue, seen, depth + 1)]));
+}
+function consoleRuntimeValue(value) {
+	if (value === void 0 || value === null || typeof value !== "object") return runtimeValue(value);
+	const description = value instanceof Error ? value.stack || `${value.name}: ${value.message}` : value instanceof Element ? value.outerHTML : Object.prototype.toString.call(value);
+	return {
+		type: "object",
+		subtype: value instanceof Error ? "error" : Array.isArray(value) ? "array" : value instanceof Element ? "node" : void 0,
+		className: value.constructor?.name,
+		description,
+		value: cloneConsoleObject(value)
+	};
+}
+function flushQueuedRuntimeEvents() {
+	while (queuedRuntimeEvents.length) {
+		const event = queuedRuntimeEvents.shift();
+		if (event) sendToHost(event);
+	}
+}
+function enableRuntime() {
+	runtimeEnabled = true;
+	sendToHost({
+		method: "Runtime.executionContextCreated",
+		params: { context: {
+			id: 1,
+			name: "top",
+			origin: location.origin
+		} }
+	});
+	flushQueuedRuntimeEvents();
+	return {};
+}
+function emitConsole(type, args) {
+	sendRuntimeEvent({
+		method: "Runtime.consoleAPICalled",
+		params: {
+			type,
+			args: args.map(consoleRuntimeValue),
+			executionContextId: 1,
+			timestamp: Date.now(),
+			stackTrace: { callFrames: [] }
+		}
+	});
+}
+function installConsoleBridge() {
+	for (const [name, type] of Object.entries({
+		clear: "clear",
+		debug: "debug",
+		dir: "dir",
+		error: "error",
+		group: "startGroup",
+		groupCollapsed: "startGroupCollapsed",
+		groupEnd: "endGroup",
+		info: "info",
+		log: "log",
+		table: "table",
+		warn: "warning"
+	})) {
+		const original = console[name];
+		if (typeof original !== "function") continue;
+		let current = wrapConsoleMethod(original, type);
+		Object.defineProperty(console, name, {
+			configurable: true,
+			get: () => current,
+			set: (next) => {
+				current = typeof next === "function" ? wrapConsoleMethod(next, type) : next;
+			}
+		});
+	}
+}
+function wrapConsoleMethod(fn, type) {
+	if (fn[consoleWrapped]) return fn;
+	const wrapped = function(...args) {
+		fn.apply(console, args);
+		emitConsole(type, args);
+	};
+	Object.defineProperty(wrapped, consoleWrapped, { value: true });
+	return wrapped;
+}
+function highlight(el) {
+	const rect = el.getBoundingClientRect();
+	const marker = document.createElement("div");
+	marker.style.cssText = [
+		"position:fixed",
+		`left:${rect.left}px`,
+		`top:${rect.top}px`,
+		`width:${rect.width}px`,
+		`height:${rect.height}px`,
+		"z-index:2147483647",
+		"pointer-events:none",
+		"outline:2px solid #005fb8",
+		"background:rgba(0,95,184,.08)"
+	].join(";");
+	document.documentElement.appendChild(marker);
+	setTimeout(() => marker.remove(), 500);
+}
+function setNativeValue(el, value) {
+	const proto = el instanceof HTMLInputElement ? HTMLInputElement.prototype : HTMLTextAreaElement.prototype;
+	(Object.getOwnPropertyDescriptor(proto, "value")?.set)?.call(el, value);
+}
+function canSelectText(el) {
+	return [
+		"",
+		"text",
+		"search",
+		"tel",
+		"url",
+		"password"
+	].includes(el.type);
+}
+function insertText(text) {
+	const el = document.activeElement;
+	if (!el) return;
+	highlight(el);
+	if (el instanceof HTMLInputElement && !canSelectText(el)) {
+		setNativeValue(el, text);
+		el.dispatchEvent(new InputEvent("input", {
+			bubbles: true,
+			data: text,
+			inputType: "insertText"
+		}));
+		el.dispatchEvent(new Event("change", { bubbles: true }));
+	} else if (el instanceof HTMLInputElement || el instanceof HTMLTextAreaElement) {
+		const start = el.selectionStart ?? el.value.length;
+		const end = el.selectionEnd ?? el.value.length;
+		setNativeValue(el, `${el.value.slice(0, start)}${text}${el.value.slice(end)}`);
+		try {
+			el.setSelectionRange(start + text.length, start + text.length);
+		} catch {}
+		el.dispatchEvent(new InputEvent("input", {
+			bubbles: true,
+			data: text,
+			inputType: "insertText"
+		}));
+		el.dispatchEvent(new Event("change", { bubbles: true }));
+	} else if (el.isContentEditable) document.execCommand("insertText", false, text);
+}
+function deleteBackward() {
+	const el = document.activeElement;
+	if (!el) return;
+	if (el instanceof HTMLInputElement || el instanceof HTMLTextAreaElement) {
+		const start = el.selectionStart ?? el.value.length;
+		const end = el.selectionEnd ?? el.value.length;
+		if (start === 0 && end === 0) return;
+		const nextStart = start === end ? start - 1 : start;
+		setNativeValue(el, `${el.value.slice(0, nextStart)}${el.value.slice(end)}`);
+		try {
+			el.setSelectionRange(nextStart, nextStart);
+		} catch {}
+		el.dispatchEvent(new InputEvent("input", {
+			bubbles: true,
+			inputType: "deleteContentBackward"
+		}));
+		el.dispatchEvent(new Event("change", { bubbles: true }));
+	} else if (el.isContentEditable) document.execCommand("delete", false);
+}
+function pageFrame() {
+	return {
+		id: frameId,
+		loaderId: "icdp-loader",
+		domainAndRegistry: "",
+		mimeType: document.contentType || "text/html",
+		securityOrigin: location.origin,
+		secureContextType: window.isSecureContext ? "Secure" : "InsecureScheme",
+		crossOriginIsolatedContextType: "NotIsolated",
+		gatedAPIFeatures: [],
+		url: location.href
+	};
+}
+function emulateNetworkConditionsByRule(params = {}) {
+	return { ruleIds: (params.matchedNetworkConditions ?? []).map((_, index) => `icdp-rule-${index}`) };
+}
+function addScriptToEvaluateOnNewDocument() {
+	return { identifier: `icdp-script-${nextScriptIdentifier++}` };
+}
+function getFrameTree() {
+	return { frameTree: { frame: pageFrame() } };
+}
+function getResourceTree() {
+	return { frameTree: {
+		frame: pageFrame(),
+		resources: []
+	} };
+}
+function getStorageKey() {
+	return { storageKey: location.origin };
+}
+function axOptions() {
+	return {
+		document,
+		frameId,
+		registry
+	};
+}
+/** Our DOM domain unifies nodeId with backendNodeId, so either resolves here. */
+function axTargetBackendId(params) {
+	const id = Number(params.backendNodeId ?? params.nodeId);
+	return Number.isFinite(id) && id > 0 ? id : void 0;
+}
+/** Strict target resolution with Chromium's AssertNode error messages. */
+function assertAXTarget(params) {
+	if (params.nodeId == null && params.backendNodeId == null && params.objectId == null) throw new Error("Either nodeId, backendNodeId or objectId must be specified");
+	if (params.nodeId != null) {
+		const id = Number(params.nodeId);
+		if (registry.nodeForBackendId(id)) return id;
+		throw new Error("Could not find node with given id");
+	}
+	if (params.backendNodeId != null) {
+		const id = Number(params.backendNodeId);
+		if (registry.nodeForBackendId(id)) return id;
+		throw new Error("No node found for given backend id");
+	}
+	const raw = String(params.objectId);
+	if (raw.startsWith("backend:")) {
+		const id = Number(raw.slice(8));
+		if (registry.nodeForBackendId(id)) return id;
+	}
+	throw new Error("Invalid remote object id");
+}
+function getFullAccessibilityTree(params = {}) {
+	return getFullAXTree(axOptions(), params.depth);
+}
+function getPartialAccessibilityTree(params = {}) {
+	return getPartialAXTree(axOptions(), axTargetBackendId(params), params.fetchRelatives ?? true);
+}
+function getRootAccessibilityNode() {
+	return getRootAXNode(axOptions());
+}
+function getChildAccessibilityNodes(params) {
+	return getChildAXNodes(axOptions(), String(params.id));
+}
+function getAccessibilityNodeAndAncestors(params = {}) {
+	const target = axTargetBackendId(params);
+	if (target == null) throw new Error("getAXNodeAndAncestors requires a nodeId or backendNodeId");
+	return getAXNodeAndAncestors(axOptions(), target);
+}
+function queryAccessibilityTree(params = {}) {
+	return queryAXTree(axOptions(), {
+		target: assertAXTarget(params),
+		accessibleName: params.accessibleName,
+		role: params.role
+	});
+}
+function getDocument(params = {}) {
+	return { root: domNode(document, Number(params.depth ?? 1)) };
+}
+function queryRoot(nodeId) {
+	if (nodeId == null || Number(nodeId) === 0) return document;
+	const node = registry.nodeForBackendId(Number(nodeId));
+	if (node instanceof Document) return node;
+	if (node instanceof Element) return node;
+	return node?.parentElement ?? document;
+}
+function querySelector(params) {
+	const element = queryRoot(params.nodeId).querySelector(params.selector);
+	return { nodeId: element ? registry.backendIdFor(element) : 0 };
+}
+function querySelectorAll(params) {
+	const root = queryRoot(params.nodeId);
+	return { nodeIds: Array.from(root.querySelectorAll(params.selector)).map((element) => registry.backendIdFor(element)) };
+}
+function matchingSearchNodes(query) {
+	try {
+		return Array.from(document.querySelectorAll(query)).map((element) => registry.backendIdFor(element));
+	} catch {}
+	const text = query.toLowerCase();
+	return Array.from(document.querySelectorAll("*")).filter((element) => (element.textContent || "").toLowerCase().includes(text)).map((element) => registry.backendIdFor(element));
+}
+function performSearch(params) {
+	const searchId = `icdp-search-${nextSearchId++}`;
+	const nodes = matchingSearchNodes(String(params.query || ""));
+	searchResults.set(searchId, nodes);
+	return {
+		searchId,
+		resultCount: nodes.length
+	};
+}
+function getSearchResults(params) {
+	return { nodeIds: (searchResults.get(params.searchId) ?? []).slice(params.fromIndex, params.toIndex) };
+}
+function discardSearchResults(params) {
+	searchResults.delete(params.searchId);
+	return {};
+}
+function getAttributes(params) {
+	const node = registry.nodeForBackendId(Number(params.nodeId));
+	return { attributes: node instanceof Element ? attributesFor(node) : [] };
+}
+function getOuterHTML(params) {
+	const node = registry.nodeForBackendId(Number(params.backendNodeId ?? params.nodeId));
+	if (node instanceof Element) return { outerHTML: node.outerHTML };
+	if (node instanceof Document) return { outerHTML: node.documentElement.outerHTML };
+	return { outerHTML: "" };
+}
+function focusNode(params) {
+	const element = elementForBackendId(Number(params.backendNodeId ?? params.nodeId));
+	if (element instanceof HTMLElement) element.focus();
+	return {};
+}
+function scrollIntoViewIfNeeded(params) {
+	elementForBackendId(Number(params.backendNodeId ?? params.nodeId)).scrollIntoView({
+		block: "center",
+		inline: "center"
+	});
+	return {};
+}
+function requestChildNodes(params) {
+	const node = registry.nodeForBackendId(Number(params.nodeId));
+	if (!node) throw new Error(`No element for backendDOMNodeId=${params.nodeId}`);
+	sendToHost({
+		method: "DOM.setChildNodes",
+		params: {
+			parentId: Number(params.nodeId),
+			nodes: childNodesFor(node, Number(params.depth ?? 1))
+		}
+	});
+	return {};
+}
+function describeDomNode(params = {}) {
+	return describeNode(Number(params.backendNodeId ?? params.nodeId ?? 1));
+}
+function resolveNode(params = {}) {
+	return { object: {
+		objectId: `backend:${params.backendNodeId ?? params.nodeId}`,
+		type: "object",
+		className: "Element"
+	} };
+}
+function pushNodesByBackendIdsToFrontend(params = {}) {
+	return { nodeIds: (params.backendNodeIds ?? []).map((id) => id) };
+}
+function getBoxModel(params) {
+	return boxModel(Number(params.backendNodeId ?? params.nodeId));
+}
+function getContentQuads(params) {
+	return contentQuads(Number(params.backendNodeId ?? params.nodeId));
+}
+function getComputedStyleForNode(params) {
+	const style = getComputedStyle(elementForBackendId(Number(params.nodeId)));
+	return { computedStyle: Array.from(style).map((name) => ({
+		name,
+		value: style.getPropertyValue(name)
+	})) };
+}
+function mouseEvent(type, params) {
+	return new MouseEvent(type, {
+		bubbles: true,
+		cancelable: true,
+		button: params.button === "right" ? 2 : params.button === "middle" ? 1 : 0,
+		buttons: Number(params.buttons ?? 0),
+		clientX: Number(params.x ?? 0),
+		clientY: Number(params.y ?? 0)
+	});
+}
+function wheelEvent(params) {
+	return new WheelEvent("wheel", {
+		bubbles: true,
+		cancelable: true,
+		clientX: Number(params.x ?? 0),
+		clientY: Number(params.y ?? 0),
+		deltaX: Number(params.deltaX ?? 0),
+		deltaY: Number(params.deltaY ?? 0)
+	});
+}
+function scrollableAncestor(el) {
+	for (let current = el; current; current = current.parentElement) {
+		const style = getComputedStyle(current);
+		if (/(auto|scroll)/.test(`${style.overflow}${style.overflowX}${style.overflowY}`)) return current;
+	}
+	return document.scrollingElement;
+}
+function dispatchMouseEvent(params) {
+	const target = document.elementFromPoint(Number(params.x ?? 0), Number(params.y ?? 0)) || document.documentElement;
+	if (!(target instanceof Element)) return {};
+	if (params.type === "mouseMoved") {
+		if (hoveredElement !== target) {
+			hoveredElement?.dispatchEvent(mouseEvent("mouseout", params));
+			target.dispatchEvent(mouseEvent("mouseover", params));
+			target.dispatchEvent(mouseEvent("mouseenter", params));
+			hoveredElement = target;
+		}
+		target.dispatchEvent(mouseEvent("mousemove", params));
+	} else if (params.type === "mousePressed") {
+		pressedElement = target;
+		target.dispatchEvent(mouseEvent("mousedown", params));
+	} else if (params.type === "mouseReleased") {
+		target.dispatchEvent(mouseEvent("mouseup", params));
+		if (pressedElement === target) {
+			target.click();
+			const now = Date.now();
+			if (Number(params.clickCount ?? 1) > 1 || lastClickElement === target && now - lastClickTime < 500) target.dispatchEvent(mouseEvent("dblclick", params));
+			lastClickElement = target;
+			lastClickTime = now;
+		}
+		pressedElement = null;
+	} else if (params.type === "mouseWheel") {
+		target.dispatchEvent(wheelEvent(params));
+		scrollableAncestor(target)?.scrollBy(Number(params.deltaX ?? 0), Number(params.deltaY ?? 0));
+	}
+	return {};
+}
+function dispatchKeyEvent(params) {
+	const key = String(params.key || params.code || params.text || "");
+	const target = document.activeElement || document.body;
+	if (params.type === "keyDown" || params.type === "rawKeyDown") {
+		target?.dispatchEvent(new KeyboardEvent("keydown", {
+			bubbles: true,
+			cancelable: true,
+			key
+		}));
+		if (key === "Backspace") deleteBackward();
+	} else if (params.type === "keyUp") target?.dispatchEvent(new KeyboardEvent("keyup", {
+		bubbles: true,
+		cancelable: true,
+		key
+	}));
+	if (typeof params.text === "string" && params.text) insertText(params.text);
+	return {};
+}
+function inputInsertText(params) {
+	if (typeof params.text === "string" && params.text) insertText(params.text);
+	return {};
+}
+function navigate(params) {
+	const next = new URL(String(params.url || "/"), location.href);
+	if (next.origin !== location.origin) throw new Error("Navigation outside the embedded app's origin is not allowed");
+	location.href = next.href;
+	return { frameId };
+}
+async function evaluate(params) {
+	const indirectEval = globalThis.eval;
+	const value = indirectEval(String(params.expression || ""));
+	return { result: runtimeValue(params.awaitPromise && value instanceof Promise ? await value : value) };
+}
+async function callFunctionOn(params) {
+	const id = String(params.objectId || "").startsWith("backend:") ? Number(String(params.objectId).slice(8)) : NaN;
+	const target = Number.isFinite(id) ? elementForBackendId(id) : window;
+	const indirectEval = globalThis.eval;
+	const value = indirectEval(`(${params.functionDeclaration})`).call(target, ...(params.arguments || []).map((arg) => {
+		if (arg.objectId?.startsWith("backend:")) return elementForBackendId(Number(arg.objectId.slice(8)));
+		return arg.value;
+	}));
+	return { result: runtimeValue(params.awaitPromise && value instanceof Promise ? await value : value) };
+}
+cdp.register("Accessibility", {
+	disable: noop,
+	enable: noop,
+	getFullAXTree: getFullAccessibilityTree,
+	getPartialAXTree: getPartialAccessibilityTree,
+	getRootAXNode: getRootAccessibilityNode,
+	getChildAXNodes: getChildAccessibilityNodes,
+	getAXNodeAndAncestors: getAccessibilityNodeAndAncestors,
+	queryAXTree: queryAccessibilityTree
+});
+cdp.register("Animation", { enable: noop });
+cdp.register("Autofill", { setAddresses: noop });
+cdp.register("CSS", {
+	disable: noop,
+	enable: noop,
+	getComputedStyleForNode
+});
+cdp.register("DOM", {
+	discardSearchResults,
+	describeNode: describeDomNode,
+	enable: noop,
+	focus: focusNode,
+	getAttributes,
+	getBoxModel,
+	getContentQuads,
+	getDocument,
+	getOuterHTML,
+	getSearchResults,
+	performSearch,
+	pushNodesByBackendIdsToFrontend,
+	querySelector,
+	querySelectorAll,
+	requestChildNodes,
+	resolveNode,
+	scrollIntoViewIfNeeded
+});
+cdp.register("Input", {
+	dispatchKeyEvent,
+	dispatchMouseEvent,
+	insertText: inputInsertText
+});
+cdp.register("Network", {
+	emulateNetworkConditionsByRule,
+	overrideNetworkState: noop,
+	setBlockedURLs: noop
+});
+cdp.register("Page", {
+	addScriptToEvaluateOnNewDocument,
+	getFrameTree,
+	getResourceTree,
+	navigate
+});
+cdp.register("Runtime", {
+	addBinding: noop,
+	callFunctionOn,
+	enable: enableRuntime,
+	evaluate,
+	runIfWaitingForDebugger: noop
+});
+cdp.register("Storage", { getStorageKey });
+const ANNOUNCE_RETRIES = 10;
+const ANNOUNCE_INTERVAL_MS = 300;
+let started = false;
+function parentAllowed(origin, allowed) {
+	return allowed === "*" || allowed.includes(origin);
+}
+async function handleCommand(raw) {
+	const request = JSON.parse(raw);
+	if (request.id != null) outboundMethods.set(request.id, request.method);
+	try {
+		await chobitsu.sendRawMessage(raw);
+	} catch (error) {
+		if (request.id != null) outboundMethods.delete(request.id);
+		sendToHost({
+			id: request.id,
+			error: {
+				code: CDP_SERVER_ERROR,
+				message: error instanceof Error ? error.message : String(error)
+			}
+		});
+	}
+}
+function adoptPort(next) {
+	port?.close();
+	port = next;
+	next.onmessage = (event) => {
+		handleCommand(String(event.data));
+	};
+	sendToHost({
+		method: "Page.frameNavigated",
+		params: { frame: pageFrame() }
+	});
+	sendToHost({
+		method: "Page.domContentEventFired",
+		params: { timestamp: performance.now() / 1e3 }
+	});
+	sendToHost({
+		method: "Page.loadEventFired",
+		params: { timestamp: performance.now() / 1e3 }
+	});
+}
+function announce(allowed) {
+	const hello = {
+		icdp: "hello",
+		v: 1,
+		title: document.title || location.href,
+		url: location.href
+	};
+	const targetOrigins = allowed === "*" ? ["*"] : allowed;
+	for (const origin of targetOrigins) try {
+		window.parent.postMessage(hello, origin);
+	} catch {}
+}
+/**
+* Boot the Frame Agent. No-op when the page is not embedded. The agent stays
+* dormant (announces, but never adopts a channel) unless a parent on the
+* allowlist answers with a welcome.
+*/
+function startFrameAgent(options) {
+	if (started || window.parent === window) return;
+	started = true;
+	const allowed = options.allowedParents;
+	window.addEventListener("message", (event) => {
+		if (event.source !== window.parent || !isHandshakeMessage(event.data)) return;
+		if (!parentAllowed(event.origin, allowed)) return;
+		if (event.data.icdp === "probe") announce(allowed);
+		else if (event.data.icdp === "welcome" && event.ports[0]) adoptPort(event.ports[0]);
+	});
+	installConsoleBridge();
+	announce(allowed);
+	let attempts = 0;
+	const retry = window.setInterval(() => {
+		if (port || ++attempts >= ANNOUNCE_RETRIES) {
+			window.clearInterval(retry);
+			return;
+		}
+		announce(allowed);
+	}, ANNOUNCE_INTERVAL_MS);
+}
+//#endregion
+export { startFrameAgent };