@cmmd-center/forge 0.13.29 → 0.13.31

package/dist/playwright-backend-DVQOhqRO.mjs

@@ -0,0 +1,642 @@
+#!/usr/bin/env node
+
+import { t as settleValueWithin } from "./settle-BJcmpbvq.mjs";
+import { randomUUID } from "node:crypto";
+import { chromium } from "playwright";
+//#region ../../node_modules/.bun/@cmmd-center+agent-browser@0.6.2+69e331b0475d65dc/node_modules/@cmmd-center/agent-browser/dist/backends/playwright-locators.js
+function locatorForAction(page, action) {
+	return action.query ? locatorFromQuery(page, action.query) : page.locator(action.selector ?? "");
+}
+function locatorFromQuery(page, query) {
+	switch (query.kind) {
+		case "and": return locatorFromQuery(page, query.left).and(locatorFromQuery(page, query.right));
+		case "css": return page.locator(query.selector);
+		case "filter": return locatorFromQuery(page, query.base).filter(filterOptions(page, query.options));
+		case "first": return locatorFromQuery(page, query.base).first();
+		case "frame": return locatorInFrame(page, page.frameLocator(query.selector), query.child);
+		case "label": return page.getByLabel(query.text, query.options);
+		case "last": return locatorFromQuery(page, query.base).last();
+		case "locator": return locatorFromQuery(page, query.base).locator(query.selector, filterOptions(page, query.options));
+		case "nth": return locatorFromQuery(page, query.base).nth(query.index);
+		case "or": return locatorFromQuery(page, query.left).or(locatorFromQuery(page, query.right));
+		case "placeholder": return page.getByPlaceholder(query.text, query.options);
+		case "role": return page.getByRole(query.role, query.options);
+		case "testId": return page.getByTestId(query.testId);
+		case "text": return page.getByText(query.text, query.options);
+	}
+}
+function locatorInFrame(page, frame, query) {
+	switch (query.kind) {
+		case "css": return frame.locator(query.selector);
+		case "filter": return locatorInFrame(page, frame, query.base).filter(filterOptions(page, query.options));
+		case "first": return locatorInFrame(page, frame, query.base).first();
+		case "label": return frame.getByLabel(query.text, query.options);
+		case "last": return locatorInFrame(page, frame, query.base).last();
+		case "locator": return locatorInFrame(page, frame, query.base).locator(query.selector, filterOptions(page, query.options));
+		case "nth": return locatorInFrame(page, frame, query.base).nth(query.index);
+		case "placeholder": return frame.getByPlaceholder(query.text, query.options);
+		case "role": return frame.getByRole(query.role, query.options);
+		case "testId": return frame.getByTestId(query.testId);
+		case "text": return frame.getByText(query.text, query.options);
+		case "and":
+		case "frame":
+		case "or": throw new Error(`Unsupported frame locator query kind: ${query.kind}`);
+	}
+}
+function filterOptions(page, options) {
+	if (!options) return void 0;
+	return {
+		...options.has === void 0 ? {} : { has: locatorFromQuery(page, options.has) },
+		...options.hasNot === void 0 ? {} : { hasNot: locatorFromQuery(page, options.hasNot) },
+		...options.hasNotText === void 0 ? {} : { hasNotText: options.hasNotText },
+		...options.hasText === void 0 ? {} : { hasText: options.hasText }
+	};
+}
+//#endregion
+//#region ../../node_modules/.bun/@cmmd-center+agent-browser@0.6.2+69e331b0475d65dc/node_modules/@cmmd-center/agent-browser/dist/backends/playwright-backend.js
+const TAB_METADATA_TIMEOUT_MS = 250;
+const TAB_CONTROL_TIMEOUT_MS = 500;
+var PlaywrightBackend = class {
+	options;
+	browser;
+	context;
+	pageIds = /* @__PURE__ */ new WeakMap();
+	logs = /* @__PURE__ */ new WeakMap();
+	registeredPages = /* @__PURE__ */ new WeakSet();
+	constructor(options = {}) {
+		this.options = options;
+	}
+	info() {
+		return {
+			id: "playwright",
+			kind: "playwright",
+			name: this.options.name ?? "Playwright Chromium"
+		};
+	}
+	async close() {
+		/* v8 ignore next -- defensive cleanup for already-closed Playwright contexts. */
+		await this.context?.close().catch(() => void 0);
+		await this.browser?.close();
+		this.browser = void 0;
+		this.context = void 0;
+	}
+	async listTabs() {
+		const context = await this.getContext();
+		return Promise.all(context.pages().map((page) => this.toTab(page).info()));
+	}
+	async selectedTab() {
+		const page = (await this.getContext()).pages().at(-1);
+		if (page) await settleValueWithin(page.bringToFront(), TAB_CONTROL_TIMEOUT_MS);
+		return page ? this.toTab(page) : void 0;
+	}
+	async newTab() {
+		const page = await (await this.getContext()).newPage();
+		await this.preparePage(page);
+		await settleValueWithin(page.bringToFront(), TAB_CONTROL_TIMEOUT_MS);
+		return this.toTab(page);
+	}
+	async getTab(id) {
+		const page = (await this.getContext()).pages().find((candidate) => this.idFor(candidate) === id);
+		if (!page) throw new Error(`Tab not found: ${id}`);
+		await settleValueWithin(page.bringToFront(), TAB_CONTROL_TIMEOUT_MS);
+		return this.toTab(page);
+	}
+	async getContext() {
+		/* v8 ignore next -- persistent headed/default launch combinations are covered by smoke, not unit coverage. */
+		if (this.options.userDataDir && !this.context) {
+			this.context = await chromium.launchPersistentContext(this.options.userDataDir, {
+				...this.options.launchOptions,
+				...this.options.contextOptions,
+				headless: this.options.headless ?? false
+			});
+			this.browser = this.context.browser() ?? void 0;
+			return this.context;
+		}
+		/* v8 ignore next -- requires a live externally managed Chrome CDP endpoint */
+		if (!this.browser && this.options.cdpEndpoint) {
+			/* v8 ignore start -- requires a live externally managed Chrome CDP endpoint */
+			this.browser = await chromium.connectOverCDP(this.options.cdpEndpoint);
+			this.context = this.browser.contexts()[0] ?? await this.browser.newContext(this.options.contextOptions);
+			return this.context;
+		}
+		/* v8 ignore next -- headed/default launch is covered by browser parity smoke. */
+		if (!this.browser) this.browser = await chromium.launch({
+			...this.options.launchOptions,
+			headless: this.options.headless ?? false
+		});
+		if (!this.context) this.context = await this.browser.newContext(this.options.contextOptions);
+		return this.context;
+	}
+	toTab(page) {
+		this.registerPage(page);
+		return new PlaywrightTabHandle(page, this.idFor(page), this.logsFor(page));
+	}
+	async preparePage(page) {
+		this.registerPage(page);
+		const bounds = this.options.windowBounds;
+		if (!bounds) return;
+		await settleValueWithin(page.setViewportSize({
+			width: bounds.width,
+			height: bounds.height
+		}), TAB_CONTROL_TIMEOUT_MS);
+		const sessionResult = await settleValueWithin(page.context().newCDPSession(page), TAB_CONTROL_TIMEOUT_MS);
+		/* v8 ignore next -- Playwright CDP attachment failures are bounded and covered by the shared timeout primitive. */
+		if (sessionResult.status !== "fulfilled") return;
+		const session = sessionResult.value;
+		try {
+			const windowResult = await settleValueWithin(session.send("Browser.getWindowForTarget"), TAB_CONTROL_TIMEOUT_MS);
+			/* v8 ignore next -- Chromium may decline window control in unsupported headless/CDP environments. */
+			if (windowResult.status !== "fulfilled" || typeof windowResult.value.windowId !== "number") return;
+			await settleValueWithin(session.send("Browser.setWindowBounds", {
+				bounds: {
+					height: bounds.height,
+					left: bounds.left ?? 0,
+					top: bounds.top ?? 0,
+					width: bounds.width,
+					windowState: "normal"
+				},
+				windowId: windowResult.value.windowId
+			}), TAB_CONTROL_TIMEOUT_MS);
+		} finally {
+			await settleValueWithin(session.detach(), TAB_CONTROL_TIMEOUT_MS);
+		}
+	}
+	registerPage(page) {
+		this.idFor(page);
+		this.logsFor(page);
+		if (this.registeredPages.has(page)) return;
+		this.registeredPages.add(page);
+		page.on("console", (message) => {
+			this.logsFor(page).push(toConsoleLog(message, page.url()));
+		});
+	}
+	idFor(page) {
+		let id = this.pageIds.get(page);
+		if (!id) {
+			id = `tab_${randomUUID()}`;
+			this.pageIds.set(page, id);
+		}
+		return id;
+	}
+	logsFor(page) {
+		let entries = this.logs.get(page);
+		if (!entries) {
+			entries = [];
+			this.logs.set(page, entries);
+		}
+		return entries;
+	}
+};
+var PlaywrightTabHandle = class {
+	page;
+	id;
+	logEntries;
+	constructor(page, id, logEntries) {
+		this.page = page;
+		this.id = id;
+		this.logEntries = logEntries;
+	}
+	async info() {
+		const [title, history] = await Promise.all([settleValueWithin(this.page.title(), TAB_METADATA_TIMEOUT_MS), settleValueWithin(this.historyState(), TAB_METADATA_TIMEOUT_MS)]);
+		const base = title.status !== "fulfilled" ? {
+			id: this.id,
+			url: this.page.url()
+		} : {
+			id: this.id,
+			title: title.value,
+			url: this.page.url()
+		};
+		/* v8 ignore next -- metadata timeout fallback is covered through AgentBrowser's bounded observation contract. */
+		return history.status === "fulfilled" ? {
+			...base,
+			...history.value
+		} : base;
+	}
+	async historyState() {
+		const sessionResult = await settleValueWithin(this.page.context().newCDPSession(this.page), TAB_METADATA_TIMEOUT_MS);
+		/* v8 ignore next -- Playwright CDP attachment failures are bounded and covered by the shared timeout primitive. */
+		if (sessionResult.status !== "fulfilled") return {};
+		const session = sessionResult.value;
+		try {
+			const historyResult = await settleValueWithin(session.send("Page.getNavigationHistory"), TAB_METADATA_TIMEOUT_MS);
+			/* v8 ignore next -- Chromium navigation-history failures are bounded external CDP behavior. */
+			if (historyResult.status !== "fulfilled") return {};
+			const history = historyResult.value;
+			return {
+				canGoBack: history.currentIndex > 0,
+				canGoForward: history.currentIndex < history.entries.length - 1
+			};
+		} finally {
+			await settleValueWithin(session.detach(), TAB_METADATA_TIMEOUT_MS);
+		}
+	}
+	async goto(url) {
+		await this.page.goto(url, { waitUntil: "domcontentloaded" });
+	}
+	async reload() {
+		await this.page.reload({ waitUntil: "domcontentloaded" });
+	}
+	async forceReload() {
+		const client = await this.page.context().newCDPSession(this.page);
+		try {
+			await client.send("Page.reload", { ignoreCache: true });
+			/* v8 ignore next -- defensive fallback for navigations that do not settle after CDP reload. */
+			await this.page.waitForLoadState("domcontentloaded", { timeout: 3e4 }).catch(() => void 0);
+		} finally {
+			await client.detach();
+		}
+	}
+	async back() {
+		await this.page.goBack({ waitUntil: "domcontentloaded" });
+	}
+	async forward() {
+		await this.page.goForward({ waitUntil: "domcontentloaded" });
+	}
+	async close() {
+		await this.page.close();
+	}
+	async screenshot(options = {}) {
+		const bytes = await this.page.screenshot({
+			...options.fullPage === void 0 ? {} : { fullPage: options.fullPage },
+			...options.clip === void 0 ? {} : { clip: options.clip },
+			...options.mimeType === void 0 ? {} : { type: options.mimeType === "image/jpeg" ? "jpeg" : "png" },
+			...options.quality === void 0 ? {} : { quality: options.quality }
+		});
+		if (options.maxBytes !== void 0 && bytes.byteLength > options.maxBytes) throw new Error(`Browser screenshot exceeded maxBytes=${options.maxBytes}. size=${bytes.byteLength}`);
+		return bytes;
+	}
+	async setViewport(size) {
+		await this.page.setViewportSize({
+			width: Math.round(size.width),
+			height: Math.round(size.height)
+		});
+	}
+	async setZoom(zoom) {
+		/* v8 ignore next 3 -- browser-executed callback runs outside Node coverage */
+		await this.page.evaluate((level) => {
+			document.documentElement.style.zoom = String(level);
+		}, zoom.level);
+	}
+	async clearCookies() {
+		await this.page.context().clearCookies();
+	}
+	async clearCache() {
+		const client = await this.page.context().newCDPSession(this.page);
+		try {
+			await client.send("Network.clearBrowserCache");
+		} finally {
+			await client.detach();
+		}
+	}
+	async domSnapshot() {
+		return this.page.locator("body").ariaSnapshot({ timeout: 5e3 });
+	}
+	async evaluate(expression, arg) {
+		/* v8 ignore next 4 -- browser-executed callback runs outside Node coverage */
+		return this.page.evaluate((input) => {
+			return new Function("arg", `return (${input.expression})(arg);`)(input.arg);
+		}, {
+			arg,
+			expression
+		});
+	}
+	async waitForLoadState(state = "load", timeoutMs) {
+		await this.page.waitForLoadState(state, timeoutOptions(timeoutMs));
+	}
+	async waitForURL(url, timeoutMs) {
+		await this.page.waitForURL(url, timeoutOptions(timeoutMs));
+	}
+	async waitForDownload(timeoutMs) {
+		return toBrowserDownload(await this.page.waitForEvent("download", timeoutOptions(timeoutMs)));
+	}
+	async elementInfo(options) {
+		/* v8 ignore start -- browser-executed DOM inspection runs outside Node coverage */
+		return this.page.evaluate(({ x, y, includeNonInteractable }) => {
+			const element = document.elementFromPoint(x, y);
+			if (!element || element === document.documentElement || element === document.body) return;
+			const rect = element.getBoundingClientRect();
+			if (rect.width <= 0 || rect.height <= 0) return;
+			const style = window.getComputedStyle(element);
+			if (!includeNonInteractable && (style.visibility === "hidden" || style.display === "none" || style.pointerEvents === "none")) return;
+			const tagName = element.tagName.toLowerCase();
+			const visibleText = visibleElementText(element);
+			const ariaName = element.getAttribute("aria-label") ?? element.getAttribute("alt") ?? void 0;
+			const role = element.getAttribute("role") ?? inferRole(element);
+			const candidates = selectorCandidates(element);
+			const testId = element.getAttribute("data-testid") ?? element.getAttribute("data-test-id") ?? void 0;
+			const nodeId = ensureNodeId(element);
+			const preview = compactText(`${tagName}${role ? ` role=${role}` : ""}${ariaName ? ` aria="${ariaName}"` : ""}${visibleText ? ` text="${visibleText}"` : ""}`);
+			return {
+				...ariaName ? { ariaName } : {},
+				boundingBox: {
+					x: rect.x,
+					y: rect.y,
+					width: rect.width,
+					height: rect.height
+				},
+				nodeId,
+				preview,
+				...role ? { role } : {},
+				selector: {
+					candidates,
+					primary: candidates[0] ?? null
+				},
+				tagName,
+				...testId ? { testId } : {},
+				...visibleText ? { visibleText } : {}
+			};
+			function compactText(value) {
+				return value.replace(/\s+/g, " ").trim().slice(0, 180);
+			}
+			function visibleElementText(node) {
+				if (node instanceof HTMLInputElement || node instanceof HTMLTextAreaElement) return compactText(node.value || node.placeholder || "");
+				if (node instanceof HTMLSelectElement) return compactText(node.selectedOptions[0]?.textContent ?? node.value);
+				return compactText(node.textContent ?? "") || void 0;
+			}
+			function inferRole(node) {
+				if (node instanceof HTMLAnchorElement && node.href) return "link";
+				if (node instanceof HTMLButtonElement) return "button";
+				if (node instanceof HTMLInputElement) return node.type || "textbox";
+				if (node instanceof HTMLSelectElement) return "combobox";
+				if (node instanceof HTMLTextAreaElement) return "textbox";
+				if (/^h[1-6]$/i.test(node.tagName)) return "heading";
+			}
+			function ensureNodeId(node) {
+				const existing = node.getAttribute("data-agent-browser-node-id");
+				if (existing) return Number(existing);
+				const next = Number(document.documentElement.getAttribute("data-agent-browser-next-node-id") ?? "1");
+				document.documentElement.setAttribute("data-agent-browser-next-node-id", String(next + 1));
+				node.setAttribute("data-agent-browser-node-id", String(next));
+				return next;
+			}
+			function selectorCandidates(node) {
+				const candidates = [];
+				if (node.id) candidates.push(`#${cssEscape(node.id)}`);
+				const testId = node.getAttribute("data-testid") ?? node.getAttribute("data-test-id");
+				if (testId) candidates.push(`[data-testid="${cssString(testId)}"]`);
+				const href = node.getAttribute("href");
+				if (href) candidates.push(`${node.tagName.toLowerCase()}[href="${cssString(href)}"]`);
+				const aria = node.getAttribute("aria-label");
+				if (aria) candidates.push(`${node.tagName.toLowerCase()}[aria-label="${cssString(aria)}"]`);
+				const name = node.getAttribute("name");
+				if (name) candidates.push(`${node.tagName.toLowerCase()}[name="${cssString(name)}"]`);
+				const parts = [];
+				let current = node;
+				while (current && current !== document.body && current !== document.documentElement && parts.length < 5) {
+					let part = current.tagName.toLowerCase();
+					const name = current.getAttribute("name");
+					if (name) part += `[name="${cssString(name)}"]`;
+					else {
+						const className = Array.from(current.classList).find(Boolean);
+						if (className) part += `.${cssEscape(className)}`;
+					}
+					const parent = current.parentElement;
+					if (parent) {
+						const siblings = Array.from(parent.children).filter((sibling) => sibling.tagName === current?.tagName);
+						if (siblings.length > 1) part += `:nth-of-type(${siblings.indexOf(current) + 1})`;
+					}
+					parts.unshift(part);
+					const candidate = parts.join(" > ");
+					if (document.querySelectorAll(candidate).length === 1) {
+						candidates.push(candidate);
+						break;
+					}
+					current = parent;
+				}
+				const fallback = parts.join(" > ") || node.tagName.toLowerCase();
+				candidates.push(fallback);
+				return Array.from(new Set(candidates));
+			}
+			function cssEscape(value) {
+				return CSS.escape(value);
+			}
+			function cssString(value) {
+				return value.replace(/\\/g, "\\\\").replace(/"/g, "\\\"");
+			}
+		}, options);
+		/* v8 ignore stop */
+	}
+	async elementScreenshot(options) {
+		const element = await this.elementInfo(options);
+		if (!element?.boundingBox) return void 0;
+		return this.screenshot({ clip: element.boundingBox });
+	}
+	async click(action) {
+		const locator = this.locatorFor(action);
+		await assertSingle(locator.count(), locatorActionLabel(action));
+		await locator.click(timeoutOptions(action.timeoutMs));
+	}
+	async doubleClick(action) {
+		const locator = this.locatorFor(action);
+		await assertSingle(locator.count(), locatorActionLabel(action));
+		await locator.dblclick(timeoutOptions(action.timeoutMs));
+	}
+	async fill(action, value) {
+		const locator = this.locatorFor(action);
+		await assertSingle(locator.count(), locatorActionLabel(action));
+		await locator.fill(value, timeoutOptions(action.timeoutMs));
+	}
+	async type(action, value) {
+		const locator = this.locatorFor(action);
+		await assertSingle(locator.count(), locatorActionLabel(action));
+		await locator.pressSequentially(value, timeoutOptions(action.timeoutMs));
+	}
+	async press(action, key) {
+		const locator = this.locatorFor(action);
+		await assertSingle(locator.count(), locatorActionLabel(action));
+		await locator.press(key, timeoutOptions(action.timeoutMs));
+	}
+	async select(action, value) {
+		const locator = this.locatorFor(action);
+		await assertSingle(locator.count(), locatorActionLabel(action));
+		await locator.selectOption(value, timeoutOptions(action.timeoutMs));
+	}
+	async check(action, checked) {
+		const locator = this.locatorFor(action);
+		await assertSingle(locator.count(), locatorActionLabel(action));
+		await locator.setChecked(checked, timeoutOptions(action.timeoutMs));
+	}
+	async text(action) {
+		const locator = this.locatorFor(action);
+		await assertSingle(locator.count(), locatorActionLabel(action));
+		return locator.textContent(timeoutOptions(action.timeoutMs));
+	}
+	async innerText(action) {
+		const locator = this.locatorFor(action);
+		await assertSingle(locator.count(), locatorActionLabel(action));
+		return locator.innerText(timeoutOptions(action.timeoutMs));
+	}
+	async allTextContents(action) {
+		return this.locatorFor(action).allTextContents();
+	}
+	async attribute(action, name) {
+		const locator = this.locatorFor(action);
+		await assertSingle(locator.count(), locatorActionLabel(action));
+		return locator.getAttribute(name, timeoutOptions(action.timeoutMs));
+	}
+	async isVisible(action) {
+		const locator = this.locatorFor(action);
+		await assertSingle(locator.count(), locatorActionLabel(action));
+		return locator.isVisible(timeoutOptions(action.timeoutMs));
+	}
+	async isEnabled(action) {
+		const locator = this.locatorFor(action);
+		await assertSingle(locator.count(), locatorActionLabel(action));
+		return locator.isEnabled(timeoutOptions(action.timeoutMs));
+	}
+	async locatorCount(action) {
+		return this.locatorFor(action).count();
+	}
+	async waitForLocator(action, state) {
+		await this.locatorFor(action).waitFor({
+			...state === void 0 ? {} : { state },
+			...timeoutOptions(action.timeoutMs)
+		});
+	}
+	async cuaMove(point) {
+		await this.page.mouse.move(point.x, point.y);
+	}
+	async cuaClick(point) {
+		await this.page.mouse.click(point.x, point.y, { button: mouseButton(point.button) });
+	}
+	async cuaDoubleClick(point) {
+		await this.page.mouse.dblclick(point.x, point.y);
+	}
+	async cuaDrag(path) {
+		const [start, ...rest] = path;
+		if (!start) return;
+		await this.page.mouse.move(start.x, start.y);
+		await this.page.mouse.down();
+		for (const point of rest) await this.page.mouse.move(point.x, point.y);
+		await this.page.mouse.up();
+	}
+	async cuaScroll(input) {
+		await this.page.mouse.move(input.x, input.y);
+		await this.page.mouse.wheel(input.scrollX, input.scrollY);
+	}
+	async cuaType(text) {
+		await this.page.keyboard.type(text);
+	}
+	async cuaKeypress(keys) {
+		await this.page.keyboard.press(keys.join("+"));
+	}
+	async visibleDom() {
+		return this.page.evaluate(`(() => {
+      let nextId = Number(document.documentElement.getAttribute("data-agent-browser-next-node-id") || "1");
+      function walk(element) {
+        const rect = element.getBoundingClientRect();
+        const style = window.getComputedStyle(element);
+        if (rect.width <= 0 || rect.height <= 0 || style.display === "none" || style.visibility === "hidden") {
+          return undefined;
+        }
+        let nodeId = element.getAttribute("data-agent-browser-node-id");
+        if (!nodeId) {
+          nodeId = String(nextId++);
+          element.setAttribute("data-agent-browser-node-id", nodeId);
+        }
+        const tagName = element.tagName.toLowerCase();
+        const visibleText = (element.textContent ?? "").replace(/\s+/g, " ").trim().slice(0, 120) || undefined;
+        const role = element.getAttribute("role") ?? undefined;
+        const ariaName = element.getAttribute("aria-label") ?? undefined;
+        const children = Array.from(element.children).map(walk).filter(Boolean);
+        return {
+          ...(ariaName ? { ariaName } : {}),
+          boundingBox: { x: rect.x, y: rect.y, width: rect.width, height: rect.height },
+          ...(children.length ? { children } : {}),
+          nodeId,
+          preview: (tagName + (ariaName ? ' "' + ariaName + '"' : "") + (visibleText ? " " + visibleText : "")).slice(0, 180),
+          ...(role ? { role } : {}),
+          tagName,
+          ...(visibleText ? { visibleText } : {})
+        };
+      }
+      document.documentElement.setAttribute("data-agent-browser-next-node-id", String(nextId));
+      return walk(document.body) ?? { nodeId: "body", preview: "body", tagName: "body" };
+    })()`);
+	}
+	async domClick(nodeId) {
+		await this.byNodeId(nodeId).click();
+	}
+	async domDoubleClick(nodeId) {
+		await this.byNodeId(nodeId).dblclick();
+	}
+	async domScroll(input) {
+		if (input.nodeId) {
+			/* v8 ignore next -- browser-executed DOM callback runs outside Node coverage */
+			await this.byNodeId(input.nodeId).evaluate((element, delta) => element.scrollBy(delta.x, delta.y), {
+				x: input.x,
+				y: input.y
+			});
+			return;
+		}
+		await this.page.mouse.wheel(input.x, input.y);
+	}
+	async domType(text) {
+		await this.page.keyboard.type(text);
+	}
+	async domKeypress(keys) {
+		await this.page.keyboard.press(keys.join("+"));
+	}
+	async clipboardReadText() {
+		/* v8 ignore next -- browser-executed callback runs outside Node coverage */
+		return this.page.evaluate(() => navigator.clipboard.readText());
+	}
+	async clipboardWriteText(text) {
+		/* v8 ignore next -- browser-executed callback runs outside Node coverage */
+		await this.page.evaluate((value) => navigator.clipboard.writeText(value), text);
+	}
+	async logs(limit = 100) {
+		return this.logEntries.slice(-limit);
+	}
+	byNodeId(nodeId) {
+		return this.page.locator(`[data-agent-browser-node-id="${cssStringForSelector(nodeId)}"]`);
+	}
+	locatorFor(action) {
+		return locatorForAction(this.page, action);
+	}
+};
+function locatorActionLabel(action) {
+	/* v8 ignore next -- valid public calls always supply selector or query; malformed calls are rejected downstream. */
+	return action.selector ?? action.query?.kind ?? "locator";
+}
+function mouseButton(button) {
+	if (button === 2) return "middle";
+	if (button === 3) return "right";
+	return "left";
+}
+function cssStringForSelector(value) {
+	return value.replace(/\\/g, "\\\\").replace(/"/g, "\\\"");
+}
+function timeoutOptions(timeoutMs) {
+	return timeoutMs === void 0 ? {} : { timeout: timeoutMs };
+}
+function toBrowserDownload(download) {
+	return {
+		failure: () => download.failure(),
+		path: () => download.path().catch(() => null),
+		saveAs: (path) => download.saveAs(path),
+		suggestedFilename: () => download.suggestedFilename(),
+		url: () => download.url()
+	};
+}
+async function assertSingle(countPromise, selector) {
+	const count = await countPromise;
+	if (count !== 1) throw new Error(`Selector must resolve to exactly one element. selector=${selector} count=${count}`);
+}
+function toConsoleLog(message, url) {
+	return {
+		level: normalizeLevel(message.type()),
+		message: message.text(),
+		timestamp: (/* @__PURE__ */ new Date()).toISOString(),
+		url
+	};
+}
+function normalizeLevel(level) {
+	if (level === "debug" || level === "info" || level === "log" || level === "warn" || level === "error") return level;
+	/* v8 ignore next -- Playwright currently normalizes known console message types */
+	return "log";
+}
+//#endregion
+export { PlaywrightBackend };
+
+//# sourceMappingURL=playwright-backend-DVQOhqRO.mjs.map

package/dist/settle-B6Rn65UV.cjs

@@ -0,0 +1,28 @@
+#!/usr/bin/env node
+
+//#region ../../node_modules/.bun/@cmmd-center+agent-browser@0.6.2+69e331b0475d65dc/node_modules/@cmmd-center/agent-browser/dist/core/settle.js
+async function settleValueWithin(promise, timeoutMs) {
+	let timer;
+	try {
+		return await Promise.race([promise.then((value) => ({
+			status: "fulfilled",
+			value
+		}), (error) => ({
+			error,
+			status: "rejected"
+		})), new Promise((resolve) => {
+			timer = setTimeout(() => resolve({ status: "timed-out" }), timeoutMs);
+		})]);
+	} finally {
+		clearTimeout(timer);
+	}
+}
+//#endregion
+Object.defineProperty(exports, "settleValueWithin", {
+	enumerable: true,
+	get: function() {
+		return settleValueWithin;
+	}
+});
+
+//# sourceMappingURL=settle-B6Rn65UV.cjs.map

package/dist/settle-BJcmpbvq.mjs

@@ -0,0 +1,23 @@
+#!/usr/bin/env node
+
+//#region ../../node_modules/.bun/@cmmd-center+agent-browser@0.6.2+69e331b0475d65dc/node_modules/@cmmd-center/agent-browser/dist/core/settle.js
+async function settleValueWithin(promise, timeoutMs) {
+	let timer;
+	try {
+		return await Promise.race([promise.then((value) => ({
+			status: "fulfilled",
+			value
+		}), (error) => ({
+			error,
+			status: "rejected"
+		})), new Promise((resolve) => {
+			timer = setTimeout(() => resolve({ status: "timed-out" }), timeoutMs);
+		})]);
+	} finally {
+		clearTimeout(timer);
+	}
+}
+//#endregion
+export { settleValueWithin as t };
+
+//# sourceMappingURL=settle-BJcmpbvq.mjs.map