effect-browserbase 0.1.0-beta.102 → 0.2.0-beta.0

package/dist/BrowserBinding-qbQA6JhH.mjs

@@ -1,2452 +0,0 @@
-import { Identifier } from "./References.mjs";
-import { BrowserError, InitializationError } from "./Errors.mjs";
-import { SafeFilename } from "./Transfers.mjs";
-import { ControlFacts, FrameInfo, ObservedControl, PageExecutionState, PageInfo, PageSuspension } from "./BrowserData.mjs";
-import { a as failure, c as sanitize, i as closeWithin, l as timeout, n as pngGeometry, o as publicError, r as NativeFailure, s as safeDecode } from "./Images-DgscEfSf.mjs";
-import { Context, Effect, Layer, Redacted, Schema } from "effect";
-//#region src/internal/browser/Binding.ts
-const fromNativeAttempt = (attempt) => ({ connect: (request) => Effect.tryPromise({
-	try: (signal) => {
-		const pending = attempt(request, signal).then(async (driver) => {
-			if (signal.aborted) {
-				request.onAbandoned();
-				driver.fenceInitialization?.();
-				await driver.disconnect().catch(() => {});
-				throw BrowserError.make({
-					operation: "connect",
-					reason: "interrupted"
-				});
-			}
-			return driver;
-		});
-		pending.then(request.onSettled, request.onSettled);
-		return pending;
-	},
-	catch: (error) => Schema.is(InitializationError)(error) ? error : publicError(error, "connect", { reason: "provider" })
-}) });
-/**
-* Binding identity is issuance, never shape: a value that merely looks like a binding has no
-* entry here and cannot reach the owner, so only this package's constructors supply an engine.
-*/
-const issued = /* @__PURE__ */ new WeakMap();
-const issueBinding = (binding, implementation) => {
-	issued.set(binding, implementation);
-	return Object.freeze(binding);
-};
-const bindingImplementation = (binding) => issued.get(binding);
-//#endregion
-//#region src/internal/browser/Actions.ts
-const waitEvent = (add, remove, ticket, accepts = () => true) => {
-	let done = false;
-	let resolve = () => {};
-	let reject = () => {};
-	const promise = new Promise((yes, no) => {
-		resolve = yes;
-		reject = no;
-	});
-	promise.catch(() => {});
-	const cleanup = () => {
-		remove(listener);
-		ticket.signal.removeEventListener("abort", abort);
-		clearTimeout(timer);
-	};
-	const abort = () => {
-		if (!done) {
-			done = true;
-			cleanup();
-			reject(failure("interrupted"));
-		}
-	};
-	const listener = (value) => {
-		if (!done && accepts(value)) {
-			done = true;
-			cleanup();
-			resolve(value);
-		}
-	};
-	const timer = setTimeout(() => {
-		if (!done) {
-			done = true;
-			cleanup();
-			reject(failure("timeout"));
-		}
-	}, ticket.remainingMillis());
-	add(listener);
-	ticket.signal.addEventListener("abort", abort, { once: true });
-	if (ticket.signal.aborted) abort();
-	return {
-		promise,
-		cancel: abort
-	};
-};
-/**
-* In-memory bytes and provider-stored paths reach the page by different mechanisms and are
-* never mixed: the first is streamed from this client, the second is opened by the browser
-* process itself. A mixed request is a configuration error, not a native surprise later.
-*/
-const nativeSelection = (files) => {
-	if (files.length === 0) throw failure("configuration", "undispatched");
-	const inline = files.filter((file) => file._tag === "Inline");
-	const remote = files.filter((file) => file._tag === "Remote");
-	if (inline.length === files.length) return {
-		_tag: "Inline",
-		payload: inline.map((file) => ({
-			name: file.name,
-			mimeType: file.mediaType,
-			buffer: Buffer.from(file.bytes)
-		}))
-	};
-	if (remote.length === files.length) return {
-		_tag: "Remote",
-		paths: remote.map((file) => file.path)
-	};
-	throw failure("configuration", "undispatched");
-};
-/**
-* Input to the selected document. A mutation marks its ticket dispatched immediately before the
-* one native command that may change the page; any outcome after that point is uncertain.
-*/
-const makeActions = (context, targets, observation) => {
-	const { current } = targets;
-	let downloadSerial = 0;
-	/** A result URL is only ever an http(s) address without credentials. */
-	const httpUrl = (value) => {
-		let url;
-		try {
-			url = new URL(value);
-		} catch {
-			throw failure("malformed");
-		}
-		if (!["http:", "https:"].includes(url.protocol) || url.username || url.password) throw failure("malformed");
-		return value;
-	};
-	const postUrl = () => httpUrl(targets.selectedUrl());
-	/**
-	* Acts on the exact attached node a target names. The observation seam establishes that it is
-	* still the control that was inspected and that the host's policy, if any, admits it. `admit`
-	* then sees that node before anything is dispatched, so a refusal it raises is undispatched
-	* too, and what it learns reaches the action without the node being resolved a second time.
-	*/
-	const withAdmittedElement = async (target, ticket, admit, action, policy) => {
-		const { element, kept } = await observation.resolve(target, ticket, policy);
-		try {
-			const admitted = await admit(element);
-			ticket.check();
-			ticket.dispatch();
-			return await action(element, admitted);
-		} finally {
-			if (!kept) await closeWithin(() => element.dispose()).catch(() => {});
-		}
-	};
-	const withElement = (target, ticket, action, policy) => withAdmittedElement(target, ticket, async () => {}, action, policy);
-	const click = (target, ticket, policy) => sanitize(async () => {
-		await withElement(target, ticket, (element) => element.click({ timeout: timeout(ticket) }), policy);
-		ticket.check();
-		return postUrl();
-	});
-	/**
-	* A file the provider already stores is named to the browser process, which opens it; this
-	* client never reads that path. Exactly one main-frame node may match, and exactly one
-	* command dispatches. A retained node or child frame is refused rather than approximated.
-	*/
-	const attachStoredFiles = async (target, paths, ticket) => {
-		if (typeof target !== "string") throw failure("unsupported", "undispatched");
-		const { entry, frame } = current();
-		if (frame !== entry.page.mainFrame()) throw failure("unsupported", "undispatched");
-		const cdp = await context.newCDPSession(entry.page);
-		try {
-			ticket.check();
-			const root = safeDecode(Schema.Struct({ root: Schema.Struct({ nodeId: Schema.Int }) }), await cdp.send("DOM.getDocument", { depth: 0 }));
-			const matched = safeDecode(Schema.Struct({ nodeIds: Schema.Array(Schema.Int).check(Schema.isMaxLength(64)) }), await cdp.send("DOM.querySelectorAll", {
-				nodeId: root.root.nodeId,
-				selector: target
-			}));
-			ticket.check();
-			const nodeId = matched.nodeIds[0];
-			if (matched.nodeIds.length !== 1 || nodeId === void 0) throw failure(matched.nodeIds.length === 0 ? "not-found" : "ambiguous", "undispatched");
-			ticket.dispatch();
-			await cdp.send("DOM.setFileInputFiles", {
-				files: [...paths],
-				nodeId
-			});
-		} finally {
-			await closeWithin(() => cdp.detach()).catch(() => {});
-		}
-	};
-	const beginNavigation = (url, timeoutMillis, ticket) => sanitize(async () => {
-		const { entry, frame } = current();
-		ticket.dispatch();
-		targets.navigating.begin(entry.id);
-		const settled = sanitize(async () => {
-			try {
-				await frame.goto(url, {
-					waitUntil: "domcontentloaded",
-					timeout: timeoutMillis
-				});
-			} finally {
-				targets.navigating.end(entry.id);
-			}
-			return httpUrl(targets.urlOf(frame));
-		});
-		settled.catch(() => {});
-		return {
-			pageId: entry.id,
-			settled,
-			stop: () => sanitize(async () => {
-				const cdp = await context.newCDPSession(entry.page);
-				try {
-					await cdp.send("Page.stopLoading");
-				} finally {
-					await closeWithin(() => cdp.detach()).catch(() => {});
-				}
-			})
-		};
-	});
-	const fill = (target, value, ticket, policy) => sanitize(async () => {
-		await withElement(target, ticket, (element) => element.fill(value, { timeout: timeout(ticket) }), policy);
-		ticket.check();
-		return postUrl();
-	});
-	const scroll = (deltaX, deltaY, ticket) => sanitize(async () => {
-		const { frame } = current();
-		ticket.dispatch();
-		await frame.evaluate(({ x, y }) => window.scrollBy({
-			left: x,
-			top: y,
-			behavior: "instant"
-		}), {
-			x: deltaX,
-			y: deltaY
-		});
-		ticket.check();
-		return postUrl();
-	});
-	const waitFor = (selector, state, ticket) => sanitize(async () => {
-		await (await current().frame.waitForSelector(selector, {
-			state,
-			strict: true,
-			timeout: timeout(ticket)
-		}))?.dispose();
-		ticket.check();
-	});
-	const clickAndWait = (target, ticket) => sanitize(async () => {
-		const { entry, frame } = current();
-		const observer = waitEvent((on) => entry.page.on("framenavigated", on), (off) => entry.page.off("framenavigated", off), ticket, (changedFrame) => changedFrame === frame);
-		try {
-			await click(target, ticket);
-			await observer.promise;
-			await frame.waitForLoadState("domcontentloaded", { timeout: timeout(ticket) });
-			ticket.check();
-			return postUrl();
-		} finally {
-			observer.cancel();
-		}
-	});
-	const clickForDownload = (target, ticket) => sanitize(async () => {
-		const page = current().entry.page;
-		const observer = waitEvent((on) => page.on("download", on), (off) => page.off("download", off), ticket);
-		try {
-			await click(target, ticket);
-			const download = await observer.promise;
-			const filename = safeDecode(SafeFilename, download.suggestedFilename());
-			const error = await download.failure();
-			ticket.check();
-			return {
-				downloadId: `native-download-${++downloadSerial}`,
-				filename,
-				state: error === null ? "completed" : "failed"
-			};
-		} finally {
-			observer.cancel();
-		}
-	});
-	const selectFiles = (target, files, ticket) => sanitize(async () => {
-		const selection = nativeSelection(files);
-		if (selection._tag === "Remote") await attachStoredFiles(target, selection.paths, ticket);
-		else await withElement(target, ticket, (element) => element.setInputFiles(selection.payload, { timeout: timeout(ticket) }));
-		ticket.check();
-		return postUrl();
-	});
-	const clickForFileSelection = (target, files, ticket) => sanitize(async () => {
-		const selection = nativeSelection(files);
-		if (selection._tag === "Remote") throw failure("unsupported", "undispatched");
-		const page = current().entry.page;
-		const observer = waitEvent((on) => page.on("filechooser", on), (off) => page.off("filechooser", off), ticket);
-		try {
-			await click(target, ticket);
-			const chooser = await observer.promise;
-			ticket.check();
-			if (!chooser.isMultiple() && selection.payload.length > 1) throw failure("unsupported");
-			await chooser.setFiles(selection.payload, { timeout: timeout(ticket) });
-			ticket.check();
-			return postUrl();
-		} finally {
-			observer.cancel();
-		}
-	});
-	return {
-		withAdmittedElement,
-		beginNavigation,
-		click,
-		fill,
-		scroll,
-		waitFor,
-		clickAndWait,
-		clickForDownload,
-		selectFiles,
-		clickForFileSelection
-	};
-};
-//#endregion
-//#region src/internal/browser/CallbackTasks.ts
-/** Native callbacks cannot await a Semaphore. Reserve a bounded slot synchronously
-* before starting native work; never construct an already-running Promise first.
-* Fail-session pressure/failure fences the connection once. Reject-call pressure or
-* failure remains local to that invocation and reopens admission when accepted work
-* settles. Accepted rejections remain observed after close, and no callback-side Fiber
-* or unbounded producer queue is created. */
-var CallbackTasks = class {
-	pending = /* @__PURE__ */ new Set();
-	stopped = false;
-	faulted = false;
-	capacity;
-	onFault;
-	constructor(capacity, onFault) {
-		if (!Number.isSafeInteger(capacity) || capacity < 1) throw new RangeError("Invalid callback capacity");
-		this.capacity = capacity;
-		this.onFault = onFault;
-	}
-	fault() {
-		if (this.stopped || this.faulted) return;
-		this.faulted = true;
-		this.onFault();
-	}
-	submit(action, failureMode = "fail-session") {
-		if (this.stopped || this.faulted) return false;
-		if (this.pending.size >= this.capacity) {
-			if (failureMode === "fail-session") this.fault();
-			return false;
-		}
-		const task = Promise.resolve().then(action).then(() => {}, () => {
-			if (failureMode === "fail-session") this.fault();
-		}).finally(() => this.pending.delete(task));
-		this.pending.add(task);
-		return true;
-	}
-	stop() {
-		this.stopped = true;
-	}
-	async settle() {
-		await Promise.all(this.pending);
-	}
-};
-//#endregion
-//#region src/internal/browser/CaptureSource.ts
-/**
-* Screencast sources bound to one page and frame, and the watchers that learn when that binding
-* stops describing what the page shows. A main-frame change invalidates every watcher on the page.
-*/
-const makeCaptureSources = (targets) => {
-	const { current, entries, frameId } = targets;
-	const captureWatchers = /* @__PURE__ */ new Map();
-	const invalidate = (entry, reason, frame) => {
-		const watchers = captureWatchers.get(entry.id);
-		if (watchers === void 0) return;
-		const changedFrameId = frame === void 0 ? void 0 : frameId(frame);
-		const mainFrameId = frameId(entry.page.mainFrame());
-		for (const watcher of [...watchers]) {
-			if (frame !== void 0 && changedFrameId !== mainFrameId && changedFrameId !== watcher.frameId) continue;
-			if (frame !== void 0 && watcher.document !== void 0 && reason === "target-changed" && changedFrameId === mainFrameId && watcher.frameId === mainFrameId) watcher.document(frame.url());
-			else watcher.invalidate(reason);
-		}
-	};
-	const forget = (entry) => {
-		captureWatchers.delete(entry.id);
-	};
-	const clear = () => {
-		captureWatchers.clear();
-	};
-	const capture = (target) => sanitize(async () => {
-		let entry;
-		let captureFrame;
-		if (target === void 0) {
-			const selectedTarget = current();
-			entry = selectedTarget.entry;
-			captureFrame = selectedTarget.frame;
-		} else {
-			const requested = entries.get(target.pageId);
-			if (requested === void 0 || requested.page.isClosed()) throw failure("not-found", "undispatched");
-			if (await targets.targetId(requested) !== target.targetId) throw failure("stale", "undispatched");
-			entry = requested;
-			captureFrame = entry.page.mainFrame();
-		}
-		const page = entry.page;
-		const targetId = await targets.targetId(entry);
-		const watchedFrameId = frameId(captureFrame);
-		if (page.screencast === void 0) throw failure("unsupported");
-		let watcherSet;
-		let watcher;
-		return {
-			pageId: entry.id,
-			targetId,
-			frameId: watchedFrameId,
-			source: {
-				start: ({ receive, quality, size, invalidate, opened, document }) => sanitize(async () => {
-					watcherSet = captureWatchers.get(entry.id) ?? /* @__PURE__ */ new Set();
-					captureWatchers.set(entry.id, watcherSet);
-					watcher = {
-						frameId: watchedFrameId,
-						invalidate,
-						...document === void 0 ? {} : { document }
-					};
-					watcherSet.add(watcher);
-					opened?.(captureFrame.url());
-					try {
-						await page.screencast.start({
-							quality,
-							...size === void 0 ? {} : { size },
-							onFrame: (frame) => {
-								receive(frame);
-							}
-						});
-					} catch (error) {
-						watcherSet.delete(watcher);
-						watcher = void 0;
-						if (watcherSet.size === 0) captureWatchers.delete(entry.id);
-						throw error;
-					}
-				}),
-				stop: () => sanitize(async () => {
-					if (watcher !== void 0 && watcherSet !== void 0) {
-						watcherSet.delete(watcher);
-						watcher = void 0;
-						if (watcherSet.size === 0) captureWatchers.delete(entry.id);
-					}
-					if (page.isClosed()) return;
-					try {
-						await page.screencast.stop();
-					} catch (error) {
-						if (!page.isClosed()) throw error;
-					}
-				})
-			}
-		};
-	});
-	return {
-		invalidate,
-		forget,
-		clear,
-		capture
-	};
-};
-//#endregion
-//#region src/internal/browser/NativeBindings.ts
-const ContextCreated = Schema.Struct({ context: Schema.Struct({
-	id: Schema.Int.check(Schema.isGreaterThan(0)),
-	uniqueId: Schema.NonEmptyString.check(Schema.isMaxLength(256)),
-	origin: Schema.String.check(Schema.isMaxLength(2048)),
-	auxData: Schema.optionalKey(Schema.Struct({
-		isDefault: Schema.Boolean,
-		frameId: Identifier
-	}))
-}) });
-const ContextDestroyed = Schema.Struct({ executionContextId: Schema.Int });
-const TargetIdentity = Schema.Struct({ targetInfo: Schema.Struct({ targetId: Identifier }) });
-const Call = Schema.Struct({
-	name: Identifier,
-	sequence: Schema.Int.check(Schema.isBetween({
-		minimum: 1,
-		maximum: Number.MAX_SAFE_INTEGER
-	})),
-	input: Schema.String.check(Schema.isMaxLength(1048576))
-});
-const error = (step, reason) => InitializationError.make({
-	operation: "callback",
-	step,
-	reason
-});
-/**
-* A small page-side transport, not a second host scheduler. Each document owns its finite
-* pending replies and one startup timer; host authority always comes from Chromium's native
-* execution-context event, never the fields in this message or a page-reported origin.
-*/
-const pageBundle = (nativeName, controllerName, bindings) => `(() => {
-  const nativeName = ${JSON.stringify(nativeName)};
-  const controllerName = ${JSON.stringify(controllerName)};
-  if (Object.prototype.hasOwnProperty.call(globalThis, controllerName)) return;
-  const definitions = ${JSON.stringify(bindings.map(({ name, maxConcurrent, maxInputBytes, timeoutMillis }) => ({
-	name,
-	maximum: maxConcurrent + 1,
-	maxInputBytes,
-	timeoutMillis
-})))};
-  const stringify = JSON.stringify.bind(JSON);
-  const parse = JSON.parse.bind(JSON);
-  const encode = new TextEncoder();
-  const descriptors = Object.getOwnPropertyDescriptors;
-  const ownKeys = Reflect.ownKeys;
-  const prototype = Object.getPrototypeOf;
-  const plain = Object.prototype;
-  const arrayPrototype = Array.prototype;
-  const pending = new Map();
-  const functions = new Map();
-  const counts = new Map();
-  let sequence = 0;
-  let closed = false;
-  let startup;
-  const rejected = () => {
-    const value = new Error('Browser binding call rejected');
-    value.name = 'BrowserbaseBindingError';
-    value.stack = '';
-    return value;
-  };
-  const jsonInput = (value, maximum) => {
-    let nodes = 0;
-    const ancestors = new Set();
-    const visit = (item, depth) => {
-      if (++nodes > Math.min(maximum, 65536) || depth > 64) throw rejected();
-      if (item === null || typeof item === 'boolean') return;
-      if (typeof item === 'string') { if (item.length > maximum) throw rejected(); return; }
-      if (typeof item === 'number') { if (!Number.isFinite(item)) throw rejected(); return; }
-      if (typeof item !== 'object' || ancestors.has(item)) throw rejected();
-      const array = Array.isArray(item);
-      const parent = prototype(item);
-      if (array ? parent !== arrayPrototype : parent !== plain && parent !== null) throw rejected();
-      ancestors.add(item);
-      const fields = descriptors(item);
-      const keys = ownKeys(fields);
-      if (keys.length > Math.min(maximum, 65536)) throw rejected();
-      if (array && keys.length !== item.length + 1) throw rejected();
-      for (const key of keys) {
-        if (array && key === 'length') continue;
-        if (typeof key !== 'string' || key.length > maximum || key === 'toJSON') throw rejected();
-        const field = fields[key];
-        if (!field.enumerable || !Object.prototype.hasOwnProperty.call(field, 'value')) throw rejected();
-        if (array && (!/^(0|[1-9][0-9]*)$/.test(key) || Number(key) >= item.length)) throw rejected();
-        visit(field.value, depth + 1);
-      }
-      ancestors.delete(item);
-    };
-    visit(value, 0);
-    return stringify(value);
-  };
-  const settle = (id, packet) => {
-    const call = pending.get(id);
-    if (!call) return;
-    pending.delete(id);
-    clearTimeout(call.timer);
-    counts.set(call.name, (counts.get(call.name) || 1) - 1);
-    if (packet && packet.ok === true) {
-      try { call.resolve(parse(packet.text)); } catch { call.reject(rejected()); }
-    } else call.reject(rejected());
-  };
-  const dispatch = () => {
-    clearTimeout(startup);
-    startup = undefined;
-    if (closed) return;
-    const native = globalThis[nativeName];
-    if (typeof native !== 'function') {
-      if (pending.size > 0) startup = setTimeout(dispatch, 10);
-      return;
-    }
-    for (const [id, call] of pending) {
-      if (call.sent) continue;
-      call.sent = true;
-      try { native(call.message); } catch { settle(id); }
-    }
-  };
-  const close = () => {
-    if (closed) return;
-    closed = true;
-    clearTimeout(startup);
-    for (const id of [...pending.keys()]) settle(id);
-    for (const [name, fn] of functions) {
-      if (globalThis[name] === fn) delete globalThis[name];
-    }
-  };
-  const controller = Object.freeze({ deliver: settle, close,
-    get status() { return closed ? 'closed' : functions.size === definitions.length ? 'ready' : 'installing'; }
-  });
-  Object.defineProperty(globalThis, controllerName, { value: controller, configurable: true });
-  for (const definition of definitions) {
-    if (Object.prototype.hasOwnProperty.call(globalThis, definition.name)) { close(); return; }
-    const fn = (...args) => new Promise((resolve, reject) => {
-      if (closed || args.length !== 1 || sequence >= Number.MAX_SAFE_INTEGER ||
-          (counts.get(definition.name) || 0) >= definition.maximum) {
-        reject(rejected()); return;
-      }
-      let input;
-      try {
-        input = jsonInput(args[0], definition.maxInputBytes);
-        if (typeof input !== 'string' || input.length > definition.maxInputBytes ||
-            encode.encode(input).byteLength > definition.maxInputBytes) throw rejected();
-      } catch { reject(rejected()); return; }
-      const id = ++sequence;
-      const timer = setTimeout(() => settle(id), definition.timeoutMillis);
-      counts.set(definition.name, (counts.get(definition.name) || 0) + 1);
-      pending.set(id, { name: definition.name, resolve, reject, timer, sent: false,
-        message: stringify({ name: definition.name, sequence: id, input }) });
-      dispatch();
-    });
-    functions.set(definition.name, fn);
-    Object.defineProperty(globalThis, definition.name, { value: fn, configurable: true });
-  }
-})();`;
-/**
-* The pinned Playwright binding callback reports a Frame but no calling document identity.
-* That Frame survives navigation, so checking frame.url() would authorize an old document
-* using its replacement's origin. Chromium's maintained Runtime binding protocol supplies
-* the original executionContextId; uniqueId prevents context-id reuse when publishing replies.
-* These are child CDP sessions on the existing owned Playwright connection, not another owner,
-* websocket, browser resource or publicly exposed raw-protocol capability.
-*/
-const makeNativeBindings = (context, bindings, fault) => {
-	const identity = globalThis.crypto.randomUUID().replaceAll("-", "");
-	const nativeName = `__effect_agent_binding_${identity}`;
-	const controllerName = `__effect_agent_bindings_${identity}`;
-	const bundle = pageBundle(nativeName, controllerName, bindings);
-	const byName = new Map(bindings.map((binding) => [binding.name, binding]));
-	const targets = /* @__PURE__ */ new Map();
-	const currentDocuments = /* @__PURE__ */ new Map();
-	const attaching = /* @__PURE__ */ new WeakSet();
-	const maximumReplies = 16 + bindings.reduce((sum, binding) => sum + binding.maxConcurrent, 0);
-	let replies = 0;
-	let closing = false;
-	let disposed;
-	const close = () => {
-		closing = true;
-	};
-	const attach = async (subject, page) => {
-		if (closing || page.isClosed() || attaching.has(subject)) return;
-		attaching.add(subject);
-		let cdp;
-		let retained = false;
-		try {
-			try {
-				cdp = await context.newCDPSession(subject);
-			} catch (cause) {
-				if (subject !== page && cause instanceof Error && cause.message.includes("This frame does not have a separate CDP session")) return;
-				if (page.isClosed() || subject !== page && "isDetached" in subject && subject.isDetached()) return;
-				throw cause;
-			}
-			const native = cdp;
-			const targetId = Schema.decodeSync(TargetIdentity)(await native.send("Target.getTargetInfo")).targetInfo.targetId;
-			if (closing || page.isClosed() || targets.has(targetId)) return;
-			if (targets.size >= 128) throw error("bindings", "busy");
-			const documents = /* @__PURE__ */ new Map();
-			const created = (raw) => {
-				const parsed = Schema.decodeUnknownOption(ContextCreated)(raw);
-				if (parsed._tag === "None") return;
-				const value = parsed.value.context;
-				if (closing || value.auxData?.isDefault !== true) return;
-				if (documents.get(value.id)?.uniqueId === value.uniqueId) return;
-				const previous = currentDocuments.get(value.auxData.frameId);
-				if (previous !== void 0) {
-					const previousDocuments = targets.get(previous.targetId)?.documents;
-					if (previousDocuments?.get(previous.id) === previous) previousDocuments.delete(previous.id);
-					currentDocuments.delete(value.auxData.frameId);
-				}
-				if (documents.size >= 128 && !documents.has(value.id)) {
-					fault();
-					return;
-				}
-				const document = {
-					...value,
-					sequence: 0,
-					targetId
-				};
-				currentDocuments.set(value.auxData.frameId, document);
-				documents.set(value.id, document);
-			};
-			const destroyed = (raw) => {
-				const parsed = Schema.decodeUnknownOption(ContextDestroyed)(raw);
-				if (parsed._tag === "Some") {
-					const document = documents.get(parsed.value.executionContextId);
-					const frameId = document?.auxData?.frameId;
-					if (frameId !== void 0 && currentDocuments.get(frameId) === document) currentDocuments.delete(frameId);
-					documents.delete(parsed.value.executionContextId);
-				}
-			};
-			const cleared = () => {
-				for (const document of documents.values()) {
-					const frameId = document.auxData?.frameId;
-					if (frameId !== void 0 && currentDocuments.get(frameId) === document) currentDocuments.delete(frameId);
-				}
-				documents.clear();
-			};
-			const called = (event) => {
-				if (closing || event.name !== nativeName || replies >= maximumReplies) return;
-				const document = documents.get(event.executionContextId);
-				if (document === void 0 || event.payload.length > 2097664) return;
-				const parsed = Schema.decodeOption(Schema.fromJsonString(Call))(event.payload);
-				if (parsed._tag === "None") return;
-				const call = parsed.value;
-				const binding = byName.get(call.name);
-				if (binding === void 0 || call.sequence <= document.sequence) return;
-				document.sequence = call.sequence;
-				replies++;
-				let retired = false;
-				const check = async (signal) => {
-					const current = () => {
-						if (closing || retired || signal.aborted || page.isClosed()) throw error(binding.name, "closed");
-						if (documents.get(document.id) !== document || currentDocuments.get(document.auxData?.frameId ?? "") !== document) throw error(binding.name, "stale");
-						if (!binding.origins.includes(document.origin)) throw error(binding.name, "origin");
-					};
-					current();
-					const result = await native.send("Runtime.evaluate", {
-						expression: "true",
-						uniqueContextId: document.uniqueId,
-						returnByValue: true,
-						silent: true,
-						timeout: binding.timeoutMillis
-					});
-					current();
-					if (result.exceptionDetails !== void 0 || result.result.value !== true) throw error(binding.name, "stale");
-				};
-				const reply = async (packet) => {
-					if (closing || page.isClosed() || documents.get(document.id) !== document || currentDocuments.get(document.auxData?.frameId ?? "") !== document) return;
-					await native.send("Runtime.evaluate", {
-						expression: `globalThis[${JSON.stringify(controllerName)}]?.deliver(${call.sequence},${JSON.stringify(packet)})`,
-						uniqueContextId: document.uniqueId,
-						returnByValue: true,
-						silent: true,
-						timeout: binding.timeoutMillis
-					});
-				};
-				binding.invoke({
-					read: async (signal) => {
-						await check(signal);
-						return call.input;
-					},
-					check,
-					dispose: async () => {
-						retired = true;
-					}
-				}).then((text) => reply({
-					ok: true,
-					text
-				}), () => reply({ ok: false })).catch(() => {}).finally(() => {
-					replies--;
-				});
-			};
-			const off = () => {
-				native.off("Runtime.executionContextCreated", created);
-				native.off("Runtime.executionContextDestroyed", destroyed);
-				native.off("Runtime.executionContextsCleared", cleared);
-				native.off("Runtime.bindingCalled", called);
-				cleared();
-			};
-			const target = {
-				cdp: native,
-				documents,
-				page,
-				off,
-				closed: false
-			};
-			const onClosed = () => {
-				target.closed = true;
-				off();
-				if (targets.get(targetId) === target) targets.delete(targetId);
-				native.off("close", onClosed);
-			};
-			native.on("close", onClosed);
-			targets.set(targetId, target);
-			retained = true;
-			native.on("Runtime.executionContextCreated", created);
-			native.on("Runtime.executionContextDestroyed", destroyed);
-			native.on("Runtime.executionContextsCleared", cleared);
-			native.on("Runtime.bindingCalled", called);
-			await native.send("Runtime.enable");
-			if (closing) return;
-			await native.send("Runtime.addBinding", { name: nativeName });
-			if (closing) {
-				await native.send("Runtime.removeBinding", { name: nativeName }).catch(() => {});
-				return;
-			}
-			for (const document of documents.values()) {
-				if (closing) return;
-				const installed = await native.send("Runtime.evaluate", {
-					expression: `${bundle}\nglobalThis[${JSON.stringify(controllerName)}]?.status`,
-					uniqueContextId: document.uniqueId,
-					returnByValue: true,
-					silent: true,
-					timeout: 2e3
-				});
-				if (documents.get(document.id) !== document || currentDocuments.get(document.auxData?.frameId ?? "") !== document) continue;
-				if (installed.exceptionDetails !== void 0 || installed.result.value !== "ready") throw InitializationError.make({
-					operation: "register",
-					step: "bindings",
-					reason: "configuration"
-				});
-			}
-		} finally {
-			attaching.delete(subject);
-			if (cdp !== void 0 && (!retained || closing)) await cdp.detach().catch(() => {});
-		}
-	};
-	const dispose = () => {
-		close();
-		disposed ??= (async () => {
-			const settled = await Promise.allSettled([...targets.values()].map(async (target) => {
-				const documents = [...target.documents.values()];
-				target.off();
-				const removal = await Promise.allSettled([(async () => {
-					if (!target.closed && !target.page.isClosed()) {
-						for (const document of documents) await target.cdp.send("Runtime.evaluate", {
-							expression: `globalThis[${JSON.stringify(controllerName)}]?.close()`,
-							uniqueContextId: document.uniqueId,
-							returnByValue: true,
-							silent: true,
-							timeout: 1e3
-						}).catch(() => {});
-						if (!target.closed) await target.cdp.send("Runtime.removeBinding", { name: nativeName });
-					}
-				})()]);
-				const wasClosed = target.closed || target.page.isClosed();
-				const detachment = await Promise.allSettled([target.closed ? Promise.resolve() : target.cdp.detach()]);
-				if (!wasClosed && removal.some((result) => result.status === "rejected")) throw InitializationError.make({
-					operation: "dispose",
-					step: "bindings",
-					reason: "native"
-				});
-				if (!target.closed && !target.page.isClosed() && detachment.some((result) => result.status === "rejected")) throw InitializationError.make({
-					operation: "dispose",
-					step: "bindings",
-					reason: "native"
-				});
-			}));
-			targets.clear();
-			currentDocuments.clear();
-			if (settled.some((result) => result.status === "rejected")) throw InitializationError.make({
-				operation: "dispose",
-				step: "bindings",
-				reason: "native"
-			});
-		})();
-		return disposed;
-	};
-	return {
-		bundle,
-		attach,
-		close,
-		dispose
-	};
-};
-//#endregion
-//#region src/internal/browser/Initialization.ts
-/**
-* The connection's bootstrap registrations and native bindings, and the readiness of the selected
-* document under that bootstrap. Fencing is synchronous; disposal removes what was registered.
-*/
-const makeInitialization = (context, options, targets, callbacks, events, closing) => {
-	const { current, entries, epochOf } = targets;
-	const registeredEpochs = /* @__PURE__ */ new WeakMap();
-	const readyDocuments = /* @__PURE__ */ new WeakMap();
-	const registrations = [];
-	let initializationClosed = false;
-	let disposal;
-	const initializationFault = (error) => {
-		if (closing() || initializationClosed) return;
-		if (options.onBindingFault === void 0) events.fault();
-		else options.onBindingFault(error);
-	};
-	const bindingTask = (action) => {
-		if (!callbacks.submit(async () => {
-			try {
-				await action();
-			} catch (cause) {
-				initializationFault(Schema.is(InitializationError)(cause) ? cause : InitializationError.make({
-					operation: "register",
-					step: "bindings",
-					reason: "native"
-				}));
-			}
-		}, "reject-call")) initializationFault(InitializationError.make({
-			operation: "register",
-			step: "bindings",
-			reason: "busy"
-		}));
-	};
-	const bindings = options.bindings === void 0 || options.bindings.length === 0 ? void 0 : makeNativeBindings(context, options.bindings, () => initializationFault(InitializationError.make({
-		operation: "register",
-		step: "bindings",
-		reason: "busy"
-	})));
-	const attach = async (page) => {
-		if (bindings === void 0) return;
-		await bindings.attach(page, page);
-		for (const frame of page.frames()) if (frame !== page.mainFrame()) await bindings.attach(frame, page);
-	};
-	const fence = () => {
-		initializationClosed = true;
-		bindings?.close();
-	};
-	const dispose = () => {
-		fence();
-		disposal ??= (async () => {
-			if ((await Promise.allSettled([...registrations.splice(0).map((registration) => registration.dispose()), ...bindings === void 0 ? [] : [bindings.dispose()]])).some((result) => result.status === "rejected")) throw failure("provider");
-		})();
-		return disposal;
-	};
-	/** Attaches a page this connection registered after initialization, off the event path. */
-	const attachPage = (page) => {
-		if (bindings !== void 0) bindingTask(() => attach(page));
-	};
-	/** Attaches the new document of a frame that navigated after initialization. */
-	const attachFrame = (frame, page) => {
-		if (bindings !== void 0) bindingTask(() => bindings.attach(frame, page));
-	};
-	/**
-	* Registrations are installed once per connection and before this connection creates any
-	* document. Documents that were already running keep their recorded epoch, so the readiness
-	* policy can tell them apart from documents that actually ran the bundle.
-	*/
-	const install = async () => {
-		const bootstrap = options.bootstrap;
-		if (bootstrap === void 0 && bindings === void 0) return;
-		for (const entry of entries.values()) for (const frame of entry.page.frames()) registeredEpochs.set(frame, epochOf(frame));
-		for (const grant of bootstrap?.permissions ?? []) await context.grantPermissions([...grant.permissions], { origin: grant.origin });
-		const content = [bindings?.bundle, bootstrap?.bundle].filter((part) => part !== void 0).join("\n");
-		if (content.length > 0) {
-			const registration = await context.addInitScript({ content });
-			if (initializationClosed) await registration.dispose();
-			else registrations.push(registration);
-		}
-	};
-	const documentOrigin = (frame) => {
-		try {
-			const url = new URL(frame.url());
-			return ["http:", "https:"].includes(url.protocol) ? url.origin : "";
-		} catch {
-			return "";
-		}
-	};
-	/** A finite wait for a page promise. Native work continues; only this wait is bounded. */
-	const evaluateWithin = async (frame, expression, milliseconds) => {
-		let timer;
-		try {
-			return await Promise.race([frame.evaluate(expression), new Promise((_, reject) => {
-				timer = setTimeout(() => reject(failure("timeout")), milliseconds);
-			})]);
-		} finally {
-			clearTimeout(timer);
-		}
-	};
-	const readiness = async (bootstrap, ticket) => {
-		const { frame } = current();
-		const epoch = epochOf(frame);
-		if (readyDocuments.get(frame) === epoch) return { _tag: "Ready" };
-		ticket.check();
-		if (epoch <= (registeredEpochs.get(frame) ?? -1)) {
-			if (bootstrap.existingDocuments === "RequireFreshNavigation") return { _tag: "RequiresNavigation" };
-		}
-		const origin = documentOrigin(frame);
-		const applicable = bootstrap.readiness.filter((requirement) => requirement.origins === void 0 || requirement.origins.includes(origin));
-		if (applicable.length === 0) {
-			readyDocuments.set(frame, epoch);
-			return { _tag: "NotApplicable" };
-		}
-		for (const requirement of applicable) {
-			const budget = Math.max(1, Math.min(requirement.timeoutMillis, ticket.remainingMillis()));
-			let value;
-			try {
-				value = await evaluateWithin(frame, requirement.expression, budget);
-			} catch (error) {
-				if (epochOf(frame) !== epoch || frame.isDetached()) return {
-					_tag: "NotReady",
-					step: requirement.step,
-					reason: "stale"
-				};
-				return {
-					_tag: "NotReady",
-					step: requirement.step,
-					reason: Schema.is(NativeFailure)(error) && error.reason === "timeout" ? "timeout" : "failed"
-				};
-			}
-			ticket.check();
-			if (epochOf(frame) !== epoch) return {
-				_tag: "NotReady",
-				step: requirement.step,
-				reason: "stale"
-			};
-			if (value !== true) return {
-				_tag: "NotReady",
-				step: requirement.step,
-				reason: "failed"
-			};
-		}
-		readyDocuments.set(frame, epoch);
-		return { _tag: "Ready" };
-	};
-	const documentReadiness = (ticket) => sanitize(async () => {
-		const bootstrap = options.bootstrap;
-		return bootstrap === void 0 || bootstrap.readiness.length === 0 ? { _tag: "Ready" } : readiness(bootstrap, ticket);
-	});
-	return {
-		attach,
-		attachPage,
-		attachFrame,
-		fence,
-		dispose,
-		install,
-		documentReadiness
-	};
-};
-//#endregion
-//#region src/internal/browser/Keyboard.ts
-/**
-* Real key input to the selected page. Every stroke is one the browser would receive from a
-* keyboard, so handlers see trusted `keydown` and `keyup`, and the browser itself decides what
-* has focus. Nothing here focuses, paces or retries: a caller that wants a cadence sends its keys.
-*/
-const makeKeyboard = (targets, actions, receipt) => {
-	const { current } = targets;
-	/**
-	* Keys reach the focused element of the focused document, so the guard requires both: the
-	* element named is that element or holds it, through any open shadow root, and its document
-	* has focus. The pinned Chromium clears a frame's active element when focus leaves that
-	* frame, which makes the second check redundant wherever that holds. It is kept because that
-	* is the browser's bookkeeping, not a guarantee, and where it failed the keys would land in
-	* another frame than the one this guard was asked about.
-	*/
-	const requireFocus = async (element) => {
-		if (await element.evaluate((node) => {
-			if (!node.ownerDocument.hasFocus()) return false;
-			let active = node.ownerDocument.activeElement;
-			while (active?.shadowRoot?.activeElement) active = active.shadowRoot.activeElement;
-			for (let at = active; at !== null;) {
-				if (at === node) return true;
-				at = at.parentNode ?? (at instanceof ShadowRoot ? at.host : null);
-			}
-			return false;
-		}) !== true) throw failure("not-focused", "undispatched");
-	};
-	/** Sends under one dispatch, either to whatever has focus or to the one element that must. */
-	const send = async (into, ticket, policy, keys) => {
-		const { page } = current().entry;
-		if (into === void 0) {
-			ticket.dispatch();
-			await keys(page);
-		} else await actions.withAdmittedElement(into, ticket, requireFocus, () => keys(page), policy);
-		ticket.check();
-		return receipt(page);
-	};
-	const press = (key, modifiers, into, ticket, policy) => sanitize(() => send(into, ticket, policy, (page) => page.keyboard.press([...modifiers, key].join("+"))));
-	const type = (text, into, ticket, policy) => sanitize(() => send(into, ticket, policy, async (page) => {
-		for (const character of text) {
-			ticket.check();
-			await page.keyboard.type(character);
-		}
-	}));
-	return {
-		press,
-		type
-	};
-};
-//#endregion
-//#region src/internal/browser/PageExecution.ts
-const fail = (reason, outcome = "undispatched") => BrowserError.make({
-	operation: "page-control",
-	reason,
-	outcome
-});
-/** Owned by one native page/connection. Cleanup never resumes or rolls back a hold. */
-var PageExecution = class {
-	phase = "running";
-	revision = 0;
-	receipt;
-	priorRate;
-	disposed = false;
-	pageId;
-	targetId;
-	port;
-	freshId;
-	constructor(pageId, targetId, port, freshId = () => globalThis.crypto.randomUUID()) {
-		this.pageId = pageId;
-		this.targetId = targetId;
-		this.port = port;
-		this.freshId = freshId;
-	}
-	state() {
-		if (this.disposed || this.port.closed()) throw fail("closed");
-		return PageExecutionState.make({
-			pageId: this.pageId,
-			targetId: this.targetId,
-			state: this.phase,
-			...this.receipt === void 0 ? {} : { suspensionId: this.receipt.suspensionId }
-		});
-	}
-	assertRunning() {
-		if (this.disposed || this.port.closed()) throw fail("closed");
-		if (this.phase !== "running") throw fail("busy");
-	}
-	invalidate() {
-		const held = this.phase !== "running";
-		this.revision++;
-		this.receipt = void 0;
-		if (held) this.phase = "unknown";
-		return held;
-	}
-	check(ticket, revision) {
-		ticket.check();
-		const outcome = ticket.dispatched ? "unknown" : "undispatched";
-		if (this.disposed || this.port.closed()) throw fail("closed", outcome);
-		if (this.revision !== revision) throw fail("stale", outcome);
-	}
-	async write(ticket, revision, command) {
-		this.check(ticket, revision);
-		ticket.dispatch();
-		await command();
-		this.check(ticket, revision);
-	}
-	async suspend(ticket) {
-		this.assertRunning();
-		const revision = this.revision;
-		this.check(ticket, revision);
-		const rate = await this.port.readRate();
-		this.check(ticket, revision);
-		if (!Number.isFinite(rate)) throw fail("malformed");
-		this.phase = "unknown";
-		this.priorRate = rate;
-		await this.write(ticket, revision, () => this.port.rate(0));
-		await this.write(ticket, revision, () => this.port.focus(false));
-		await this.write(ticket, revision, () => this.port.lifecycle("frozen"));
-		const receipt = Object.freeze(PageSuspension.make({
-			pageId: this.pageId,
-			targetId: this.targetId,
-			suspensionId: this.freshId()
-		}));
-		this.check(ticket, revision);
-		this.receipt = receipt;
-		this.phase = "suspended";
-		return receipt;
-	}
-	async resume(receipt, ticket) {
-		this.check(ticket, this.revision);
-		if (this.phase !== "suspended" || this.receipt === void 0 || receipt.pageId !== this.pageId || receipt.targetId !== this.targetId || receipt.suspensionId !== this.receipt.suspensionId || this.priorRate === void 0) throw fail("stale");
-		const revision = this.revision;
-		const rate = this.priorRate;
-		this.receipt = void 0;
-		this.phase = "unknown";
-		await this.write(ticket, revision, () => this.port.lifecycle("active"));
-		await this.write(ticket, revision, () => this.port.activate());
-		await this.write(ticket, revision, () => this.port.focus(true));
-		await this.write(ticket, revision, () => this.port.frameBarrier(ticket));
-		await this.write(ticket, revision, () => this.port.rate(rate));
-		this.priorRate = void 0;
-		this.phase = "running";
-	}
-	async dispose() {
-		if (this.disposed) return;
-		this.disposed = true;
-		this.phase = "unknown";
-		this.receipt = void 0;
-		this.revision++;
-		await this.port.detach();
-	}
-};
-//#endregion
-//#region src/internal/browser/NativePageControl.ts
-/**
-* One native page execution per registered page, created once over its own CDP session. Its
-* receipt is invalidated when the page closes or its main frame navigates, and holds and
-* resumes act only on the exact page and target they name.
-*/
-const makePageControl = (browser, context, options, targets, callbacks, events, closing, held) => {
-	const { current, entries } = targets;
-	const execution = (entry) => {
-		if (!options.pageControl) return Promise.reject(failure("unsupported", "undispatched"));
-		entry.execution ??= sanitize(async () => {
-			const cdp = await context.newCDPSession(entry.page);
-			try {
-				const targetId = await targets.targetId(entry);
-				if (closing() || entry.page.isClosed()) throw failure("closed");
-				await cdp.send("Emulation.setFocusEmulationEnabled", { enabled: true });
-				if (closing() || entry.page.isClosed()) throw failure("closed");
-				const control = new PageExecution(entry.id, targetId, {
-					readRate: async () => safeDecode(Schema.Struct({ playbackRate: Schema.Finite }), await cdp.send("Animation.getPlaybackRate")).playbackRate,
-					rate: async (playbackRate) => {
-						await cdp.send("Animation.setPlaybackRate", { playbackRate });
-					},
-					focus: async (enabled) => {
-						await cdp.send("Emulation.setFocusEmulationEnabled", { enabled });
-					},
-					lifecycle: async (state) => {
-						await cdp.send("Page.setWebLifecycleState", { state });
-					},
-					activate: async () => {
-						await cdp.send("Page.bringToFront");
-					},
-					closed: () => closing() || !browser.isConnected() || entry.page.isClosed(),
-					detach: async () => {
-						if (entry.page.isClosed() || !browser.isConnected()) return;
-						try {
-							await closeWithin(() => cdp.detach());
-						} catch (error) {
-							if (!entry.page.isClosed() && browser.isConnected()) throw error;
-						}
-					},
-					frameBarrier: async (ticket) => {
-						ticket.check();
-						const tree = safeDecode(Schema.Struct({ frameTree: Schema.Struct({ frame: Schema.Struct({ id: Identifier }) }) }), await cdp.send("Page.getFrameTree"));
-						ticket.check();
-						const world = await cdp.send("Page.createIsolatedWorld", {
-							frameId: tree.frameTree.frame.id,
-							worldName: "effect-agent-browserbase-page-control"
-						});
-						ticket.check();
-						const result = await cdp.send("Runtime.evaluate", {
-							expression: "new Promise(resolve => requestAnimationFrame(() => resolve(true)))",
-							contextId: safeDecode(Schema.Int.check(Schema.isGreaterThan(0)), world.executionContextId),
-							awaitPromise: true,
-							returnByValue: true,
-							userGesture: false,
-							timeout: Math.min(2e3, ticket.remainingMillis())
-						});
-						ticket.check();
-						if (result.exceptionDetails !== void 0 || result.result.value !== true) throw failure("malformed");
-					}
-				});
-				entry.executionValue = control;
-				return control;
-			} catch (error) {
-				await closeWithin(() => cdp.detach()).catch(() => {});
-				throw error;
-			}
-		});
-		return entry.execution;
-	};
-	const explicit = async (target, ticket) => {
-		ticket.check();
-		const entry = entries.get(target.pageId);
-		if (entry === void 0 || entry.page.isClosed()) throw failure("closed", "undispatched");
-		const control = await execution(entry);
-		ticket.check();
-		if (control.targetId !== target.targetId) throw failure("stale", "undispatched");
-		return control;
-	};
-	/** A closed page's execution is invalidated at once and disposed outside the event. */
-	const closed = (entry) => {
-		entry.executionValue?.invalidate();
-		if (entry.execution !== void 0) callbacks.submit(async () => {
-			await (await entry.execution)?.dispose();
-		});
-	};
-	/** A main-frame navigation invalidates the execution; one that was held faults the session. */
-	const navigating = (entry, frame) => {
-		if (frame === entry.page.mainFrame() && entry.executionValue?.invalidate()) events.fault();
-	};
-	const operations = {
-		state: (page, ticket) => sanitize(async () => (await explicit(page, ticket)).state()),
-		suspend: (page, ticket) => sanitize(async () => {
-			const control = await explicit(page, ticket);
-			held(control.pageId);
-			return control.suspend(ticket);
-		}),
-		resume: (receipt, ticket) => sanitize(async () => {
-			const control = await explicit(receipt, ticket);
-			held(control.pageId);
-			return control.resume(receipt, ticket);
-		}),
-		checkSelected: (ticket) => sanitize(async () => {
-			ticket.check();
-			const control = await execution(current().entry);
-			ticket.check();
-			control.assertRunning();
-		})
-	};
-	const dispose = () => Promise.allSettled([...entries.values()].map(async (entry) => {
-		if (entry.execution !== void 0) await (await entry.execution).dispose();
-	}));
-	return {
-		execution,
-		closed,
-		navigating,
-		operations,
-		dispose
-	};
-};
-//#endregion
-//#region src/internal/browser/PageRead.ts
-/**
-* What the page reader returns. It is decoded on the host, so a page that tampers with its own
-* prototypes can make a read fail but cannot make it return something unbounded or untyped.
-*/
-const PageReadResult = Schema.Struct({
-	text: Schema.String.check(Schema.isMaxLength(131072)),
-	textTruncated: Schema.Boolean,
-	controlsTruncated: Schema.Boolean,
-	controls: Schema.Array(ControlFacts).check(Schema.isMaxLength(64)),
-	viewport: Schema.Struct({
-		width: Schema.Finite,
-		height: Schema.Finite,
-		clippedText: Schema.Natural,
-		coveredText: Schema.Natural,
-		uncertainText: Schema.Natural,
-		unreachableControls: Schema.Natural,
-		exhausted: Schema.Boolean
-	})
-});
-/** What makes a control the one that was inspected. Geometry is excluded: scrolling moves it. */
-const identityOf = (facts) => JSON.stringify([
-	facts.kind,
-	facts.label,
-	facts.disabled,
-	facts.editable,
-	facts.inputType ?? null,
-	facts.autocomplete ?? null,
-	facts.destination ?? null,
-	facts.formMethod ?? null
-]);
-/** The model-facing projection: no destination, form or geometry ever leaves through it. */
-const observedControl = (facts, elementId) => ObservedControl.make({
-	elementId,
-	kind: facts.kind,
-	label: facts.label,
-	disabled: facts.disabled
-});
-/**
-* Runs inside the page, so it is one self-contained function: it may not reference anything in
-* this module. It reads; it never scrolls, focuses, mutates or dispatches.
-*
-* Visibility here is geometry and hit-testing, never a pixel comparison. Text is kept only when
-* its line boxes intersect the viewport and the browser finds its own element at a sampled
-* point. Text under something that takes no pointer events cannot be hit-tested at all, so it is
-* counted as uncertain and left out rather than promoted to visible evidence.
-*/
-const readPage = (request) => {
-	const { scope, maximumBytes, controlLimit, nodeBudget, only } = request;
-	const width = window.innerWidth;
-	const height = window.innerHeight;
-	const evidence = {
-		width,
-		height,
-		clippedText: 0,
-		coveredText: 0,
-		uncertainText: 0,
-		unreachableControls: 0,
-		exhausted: false
-	};
-	const intersects = (rect) => rect.width > 0 && rect.height > 0 && rect.bottom > 0 && rect.right > 0 && rect.top < height && rect.left < width;
-	const within = (rect) => rect.top >= 0 && rect.left >= 0 && rect.bottom <= height && rect.right <= width;
-	const passThrough = [];
-	let visited = 0;
-	if (only === void 0 && scope === "viewport") {
-		const all = document.body?.getElementsByTagName("*") ?? [];
-		for (let i = 0; i < all.length; i++) {
-			if (++visited > nodeBudget) {
-				evidence.exhausted = true;
-				break;
-			}
-			const element = all[i];
-			if (element === void 0) continue;
-			const style = getComputedStyle(element);
-			if (style.pointerEvents !== "none" || style.visibility === "hidden") continue;
-			if (passThrough.some((known) => known.element.contains(element))) continue;
-			const rect = element.getBoundingClientRect();
-			if (intersects(rect) && Number(style.opacity) > 0) passThrough.push({
-				element,
-				rect
-			});
-		}
-	}
-	/** Whether the browser finds `owner` at this point, and how far that can be trusted. */
-	const hitTest = (owner, rect) => {
-		const x = Math.min(width - 1, Math.max(0, rect.left + rect.width / 2));
-		const y = Math.min(height - 1, Math.max(0, rect.top + rect.height / 2));
-		let hit = document.elementFromPoint(x, y);
-		while (hit?.shadowRoot) {
-			const inner = hit.shadowRoot.elementFromPoint(x, y);
-			if (inner === null || inner === hit) break;
-			hit = inner;
-		}
-		if (hit === null) return "uncertain";
-		if (hit !== owner && !owner.contains(hit) && !hit.contains(owner)) return "covered";
-		return passThrough.some((layer) => !layer.element.contains(owner) && !owner.contains(layer.element) && x >= layer.rect.left && x < layer.rect.right && y >= layer.rect.top && y < layer.rect.bottom) ? "uncertain" : "self";
-	};
-	const factsOf = (node) => {
-		const tag = node.tagName.toLowerCase();
-		const field = node instanceof HTMLInputElement || node instanceof HTMLButtonElement || node instanceof HTMLSelectElement || node instanceof HTMLTextAreaElement ? node : void 0;
-		const form = node instanceof HTMLButtonElement && node.type === "submit" || node instanceof HTMLInputElement && (node.type === "submit" || node.type === "image") ? field?.form : void 0;
-		const target = node instanceof HTMLAnchorElement || node instanceof HTMLAreaElement ? node.href : form === void 0 || form === null ? void 0 : node.hasAttribute("formaction") && field !== void 0 && "formAction" in field ? field.formAction : form.action;
-		const method = form === void 0 || form === null ? void 0 : (node.hasAttribute("formmethod") && field !== void 0 && "formMethod" in field ? field.formMethod : form.method).toLowerCase();
-		const disabled = node.matches(":disabled") || node.getAttribute("aria-disabled") === "true";
-		const rect = node.getBoundingClientRect();
-		const placement = !intersects(rect) ? "outside" : within(rect) ? "inside" : "partial";
-		const autocomplete = node instanceof HTMLInputElement || node instanceof HTMLSelectElement || node instanceof HTMLTextAreaElement ? node.autocomplete : "";
-		return {
-			kind: tag === "a" ? "link" : [
-				"button",
-				"input",
-				"select",
-				"textarea"
-			].includes(tag) ? tag : "other",
-			label: (node.getAttribute("aria-label") ?? node.getAttribute("placeholder") ?? (node instanceof HTMLInputElement ? node.labels?.[0]?.textContent : node.textContent) ?? "").slice(0, 256),
-			disabled,
-			editable: !disabled && (node instanceof HTMLInputElement || node instanceof HTMLTextAreaElement ? !node.readOnly : node instanceof HTMLSelectElement),
-			...node instanceof HTMLInputElement || node instanceof HTMLButtonElement ? { inputType: node.type.slice(0, 32) } : {},
-			...autocomplete === "" ? {} : { autocomplete: autocomplete.slice(0, 128) },
-			...target === void 0 || target.length > 2048 ? {} : { destination: target },
-			...method === "get" || method === "post" || method === "dialog" ? { formMethod: method } : {},
-			box: {
-				x: rect.left,
-				y: rect.top,
-				width: rect.width,
-				height: rect.height
-			},
-			placement,
-			hitTest: placement === "outside" ? "unsampled" : hitTest(node, rect),
-			mainFrame: window.top === window
-		};
-	};
-	if (only !== void 0) return {
-		nodes: [only],
-		data: { facts: factsOf(only) }
-	};
-	const nodes = [];
-	const controls = [];
-	const candidates = document.querySelectorAll("a[href],button,input,select,textarea,[role=button]");
-	let controlsTruncated = false;
-	for (let i = 0; i < candidates.length; i++) {
-		if (++visited > nodeBudget) {
-			evidence.exhausted = true;
-			controlsTruncated = true;
-			break;
-		}
-		const node = candidates[i];
-		if (node === void 0) continue;
-		const facts = factsOf(node);
-		if (scope === "viewport" && facts.hitTest !== "self") {
-			if (facts.placement !== "outside") evidence.unreachableControls++;
-			continue;
-		}
-		if (nodes.length >= controlLimit) {
-			controlsTruncated = true;
-			break;
-		}
-		nodes.push(node);
-		controls.push(facts);
-	}
-	const encoder = new TextEncoder();
-	let text = "";
-	let textTruncated = false;
-	if (scope === "document") {
-		const encoded = encoder.encode(document.body?.innerText ?? "");
-		let end = Math.min(encoded.length, maximumBytes);
-		while (end > 0 && end < encoded.length && ((encoded[end] ?? 0) & 192) === 128) end--;
-		text = new TextDecoder().decode(encoded.subarray(0, end));
-		textTruncated = end < encoded.length;
-	} else if (document.body !== null) {
-		const walker = document.createTreeWalker(document.body, NodeFilter.SHOW_TEXT);
-		const range = document.createRange();
-		let bytes = 0;
-		let lastBottom = Number.NEGATIVE_INFINITY;
-		const boxAt = (node, index) => {
-			const length = node.data.length;
-			for (let k = index; k < Math.min(length, index + 8); k++) {
-				range.setStart(node, k);
-				range.setEnd(node, k + 1);
-				const rect = range.getClientRects()[0];
-				if (rect !== void 0 && rect.width + rect.height > 0) return rect;
-			}
-		};
-		for (let node = walker.nextNode(); node !== null; node = walker.nextNode()) {
-			if (++visited > nodeBudget) {
-				evidence.exhausted = true;
-				textTruncated = true;
-				break;
-			}
-			const owner = node.parentElement;
-			if (!(node instanceof Text) || owner === null || node.data.trim() === "") continue;
-			if ([
-				"SCRIPT",
-				"STYLE",
-				"NOSCRIPT",
-				"TEMPLATE"
-			].includes(owner.tagName)) continue;
-			if (owner.checkVisibility?.({
-				opacityProperty: true,
-				visibilityProperty: true
-			}) === false) continue;
-			range.selectNodeContents(node);
-			const first = [...range.getClientRects()].filter(intersects)[0];
-			if (first === void 0) continue;
-			const verdict = hitTest(owner, first);
-			if (verdict !== "self") {
-				if (verdict === "covered") evidence.coveredText++;
-				else evidence.uncertainText++;
-				continue;
-			}
-			range.selectNodeContents(node);
-			let visible = node.data;
-			if (![...range.getClientRects()].every(within)) {
-				const length = node.data.length;
-				let low = 0;
-				let high = length;
-				while (low < high) {
-					const middle = low + high >> 1;
-					const rect = boxAt(node, middle);
-					if (rect === void 0 || rect.bottom <= 0) low = middle + 1;
-					else high = middle;
-				}
-				const start = low;
-				high = length;
-				while (low < high) {
-					const middle = low + high >> 1;
-					const rect = boxAt(node, middle);
-					if (rect !== void 0 && rect.top >= height) high = middle;
-					else low = middle + 1;
-				}
-				visible = node.data.slice(start, low);
-				evidence.clippedText++;
-			}
-			const fragment = visible.replace(/\s+/g, " ").trim();
-			if (fragment === "") continue;
-			const joined = (text === "" ? "" : first.top >= lastBottom - 1 ? "\n" : " ") + fragment;
-			const size = encoder.encode(joined).length;
-			if (bytes + size > maximumBytes) {
-				textTruncated = true;
-				break;
-			}
-			text += joined;
-			bytes += size;
-			lastBottom = Math.max(lastBottom, first.bottom);
-		}
-	}
-	return {
-		nodes,
-		data: {
-			text,
-			textTruncated,
-			controlsTruncated,
-			controls,
-			viewport: evidence
-		}
-	};
-};
-//#endregion
-//#region src/internal/browser/Observation.ts
-const TextResult = Schema.Struct({
-	text: Schema.String,
-	missing: Schema.Boolean,
-	overLimit: Schema.Boolean
-});
-const Geometry = Schema.Struct({
-	width: Schema.Natural,
-	height: Schema.Natural
-});
-const Count = Schema.Natural.check(Schema.isLessThanOrEqualTo(1e6));
-const Facts = Schema.Struct({ facts: ControlFacts });
-/** Bounds the page traversal itself, so a huge document costs a bounded read. */
-const NodeBudget = 2e4;
-/**
-* What is read from the selected document, and the one retained observation whose nodes a later
-* action may name. That observation is valid only until the next invalidating event.
-*/
-const makeObservation = (targets, events) => {
-	const { current } = targets;
-	let observation;
-	let observationSerial = 0;
-	const invalidate = () => {
-		if (observation !== void 0) observation.validity = "invalid";
-	};
-	/**
-	* A read is ordered against document replacement by failing: if the document it was reading
-	* was replaced underneath it, or a navigation is still in flight on its page, the native error
-	* is `target-changed` and `undispatched`, so a caller knows to read again. A read is never a
-	* mutation, so reading again is always safe.
-	*/
-	const reading = async (body) => {
-		const { entry, frame } = current();
-		const epoch = targets.epochOf(frame);
-		try {
-			return await body();
-		} catch (error) {
-			if (!Schema.is(BrowserError)(error) && (!Schema.is(NativeFailure)(error) || error.reason === "provider") && (targets.epochOf(frame) !== epoch || targets.navigating.has(entry.id))) throw failure("target-changed", "undispatched");
-			throw error;
-		}
-	};
-	const changed = (reason) => {
-		invalidate();
-		events.invalidate(reason);
-	};
-	/**
-	* Holding or resuming a page may run its `freeze` and `resume` handlers, so nothing observed
-	* on it may be acted on unchecked. Another page's observation is untouched: a stage hold is
-	* independent of the page an agent is driving.
-	*/
-	const held = (pageId) => {
-		if (observation?.pageId === pageId && observation.validity === "valid") {
-			observation.validity = "suspended";
-			observation.revalidated.clear();
-		}
-	};
-	const dispose = async () => {
-		const old = observation;
-		observation = void 0;
-		if (old !== void 0) {
-			old.validity = "invalid";
-			await closeWithin(() => Promise.allSettled([...old.nodes.values()].map((node) => node.handle.dispose())));
-		}
-	};
-	const exactElement = async (selector, ticket) => {
-		ticket.check();
-		const holder = await current().frame.evaluateHandle((requested) => {
-			try {
-				const matches = document.querySelectorAll(requested);
-				return {
-					count: matches.length,
-					node: matches.length === 1 ? matches[0] : null
-				};
-			} catch {
-				return {
-					count: 0,
-					node: null
-				};
-			}
-		}, selector);
-		let node;
-		try {
-			const countHandle = await holder.getProperty("count");
-			let count;
-			try {
-				count = safeDecode(Count, await countHandle.jsonValue());
-			} finally {
-				await countHandle.dispose();
-			}
-			ticket.check();
-			if (count !== 1) throw failure(count === 0 ? "not-found" : "ambiguous", "undispatched");
-			node = await holder.getProperty("node");
-			const element = node.asElement();
-			if (element === null) throw failure("not-found", "undispatched");
-			ticket.check();
-			return element;
-		} catch (error) {
-			await node?.dispose().catch(() => {});
-			throw error;
-		} finally {
-			await holder.dispose();
-		}
-	};
-	/** A retained node is only as current as the observation that produced it. */
-	const retained = (target, allowSuspended = false) => {
-		const snapshot = observation;
-		if (snapshot === void 0 || snapshot.id !== target.observationId) throw failure("stale", "undispatched");
-		const usable = snapshot.validity === "valid" || snapshot.validity === "suspended" && (allowSuspended || snapshot.revalidated.has(target.elementId));
-		const node = snapshot.nodes.get(target.elementId);
-		if (!usable || node === void 0) throw failure("stale", "undispatched");
-		return node;
-	};
-	/**
-	* Read from the exact node, never re-resolved from a selector or a label. It is the same page
-	* function an observation uses, told to read one node and traverse nothing.
-	*/
-	const factsOf = async (element) => {
-		const holder = await current().frame.evaluateHandle(readPage, {
-			scope: "document",
-			maximumBytes: 0,
-			controlLimit: 0,
-			nodeBudget: 0,
-			only: element
-		});
-		try {
-			const data = await holder.getProperty("data");
-			try {
-				return safeDecode(Facts, await data.jsonValue()).facts;
-			} finally {
-				await data.dispose();
-			}
-		} finally {
-			await holder.dispose();
-		}
-	};
-	/**
-	* The exact attached node a target names, checked against the page right now. A selector must
-	* still match it and nothing else. A retained node must still be the control that was
-	* inspected: the same node with a different destination, type or label is not. A host policy
-	* then decides on those fresh facts, and a refusal or a policy that throws sends nothing.
-	*/
-	const resolve = async (target, ticket, policy, allowSuspended = false) => {
-		const kept = typeof target !== "string";
-		const node = typeof target === "string" ? void 0 : retained(target, allowSuspended);
-		const element = typeof target === "string" ? await exactElement(target, ticket) : node?.handle;
-		if (element === void 0) throw failure("stale", "undispatched");
-		try {
-			if (await element.evaluate((candidate, selector) => {
-				if (!candidate.isConnected) return false;
-				if (selector === void 0) return true;
-				const matches = candidate.ownerDocument.querySelectorAll(selector);
-				return matches.length === 1 && matches[0] === candidate;
-			}, typeof target === "string" ? target : void 0) !== true) throw failure("stale", "undispatched");
-			if (node !== void 0 || policy !== void 0) {
-				const facts = await factsOf(element);
-				if (node !== void 0 && identityOf(facts) !== node.identity) throw failure("stale", "undispatched");
-				if (policy !== void 0) {
-					let admitted = false;
-					try {
-						admitted = policy(facts) === true;
-					} catch {
-						admitted = false;
-					}
-					if (!admitted) throw failure("denied", "undispatched");
-				}
-			}
-			ticket.check();
-			return {
-				element,
-				kept
-			};
-		} catch (error) {
-			if (!kept) await closeWithin(() => element.dispose()).catch(() => {});
-			throw error;
-		}
-	};
-	const controlFacts = (target, ticket) => sanitize(async () => {
-		const { element } = await resolve(target, ticket);
-		return factsOf(element);
-	});
-	/** After a hold, one node at a time: still attached, and still the control inspected. */
-	const revalidate = (target, ticket) => sanitize(async () => {
-		await resolve(target, ticket, void 0, true);
-		observation?.revalidated.add(target.elementId);
-	});
-	const readText = (selector, maximumBytes, ticket) => sanitize(async () => {
-		ticket.check();
-		const raw = await reading(() => current().frame.evaluate(({ selector, maximumBytes }) => {
-			const element = selector === void 0 ? document.body : document.querySelector(selector);
-			if (element === null) return {
-				text: "",
-				missing: true,
-				overLimit: false
-			};
-			const text = element instanceof HTMLElement ? element.innerText : element.textContent ?? "";
-			if (new TextEncoder().encode(text).length > maximumBytes) return {
-				text: "",
-				missing: false,
-				overLimit: true
-			};
-			return {
-				text,
-				missing: false,
-				overLimit: false
-			};
-		}, {
-			selector,
-			maximumBytes
-		}));
-		ticket.check();
-		const value = safeDecode(TextResult, raw);
-		if (value.missing) throw failure("not-found");
-		if (value.overLimit || new TextEncoder().encode(value.text).length > maximumBytes) throw failure("limit");
-		return value.text;
-	});
-	/** One bounded read of the selected frame, and the node handles it names, in order. */
-	const read = async (scope, maximumBytes, controlLimit, ticket, keepNodes) => {
-		const holder = await current().frame.evaluateHandle(readPage, {
-			scope,
-			maximumBytes,
-			controlLimit,
-			nodeBudget: NodeBudget
-		});
-		const handles = [];
-		let nodesHandle;
-		try {
-			const dataHandle = await holder.getProperty("data");
-			let data;
-			try {
-				data = safeDecode(PageReadResult, await dataHandle.jsonValue());
-			} finally {
-				await dataHandle.dispose();
-			}
-			if (new TextEncoder().encode(data.text).length > maximumBytes || data.controls.length > controlLimit) throw failure("limit");
-			if (keepNodes) {
-				nodesHandle = await holder.getProperty("nodes");
-				for (let i = 0; i < data.controls.length; i++) {
-					const node = await nodesHandle.getProperty(String(i));
-					const element = node.asElement();
-					if (element === null) {
-						await node.dispose();
-						throw failure("malformed");
-					}
-					handles.push(element);
-				}
-			}
-			ticket.check();
-			return {
-				data,
-				handles
-			};
-		} catch (error) {
-			await Promise.allSettled(handles.map((handle) => handle.dispose()));
-			throw error;
-		} finally {
-			await nodesHandle?.dispose().catch(() => {});
-			await holder.dispose();
-		}
-	};
-	const observe = (scope, maximumBytes, controlLimit, ticket) => sanitize(async () => {
-		await dispose();
-		ticket.check();
-		const pageId = current().entry.id;
-		const { data, handles } = await reading(() => read(scope, maximumBytes, controlLimit, ticket, true));
-		const id = `observation-${++observationSerial}`;
-		const nodes = /* @__PURE__ */ new Map();
-		handles.forEach((handle, i) => {
-			const facts = data.controls[i];
-			if (facts !== void 0) nodes.set(`element-${i}`, {
-				handle,
-				identity: identityOf(facts)
-			});
-		});
-		if (nodes.size !== data.controls.length) {
-			await Promise.allSettled(handles.map((handle) => handle.dispose()));
-			throw failure("malformed");
-		}
-		observation = {
-			id,
-			pageId,
-			validity: "valid",
-			nodes,
-			revalidated: /* @__PURE__ */ new Set()
-		};
-		return {
-			observationId: id,
-			scope,
-			url: targets.selectedUrl(),
-			text: data.text,
-			textTruncated: data.textTruncated,
-			controlsTruncated: data.controlsTruncated,
-			controls: data.controls.map((facts, i) => observedControl(facts, `element-${i}`)),
-			viewport: data.viewport
-		};
-	});
-	const screenshot = (fullPage, maximumBytes, ticket) => sanitize(() => reading(async () => {
-		const page = current().entry.page;
-		ticket.check();
-		const raw = await page.evaluate((full) => ({
-			width: full ? Math.max(document.documentElement.scrollWidth, window.innerWidth) : window.innerWidth,
-			height: full ? Math.max(document.documentElement.scrollHeight, window.innerHeight) : window.innerHeight
-		}), fullPage);
-		const geometry = safeDecode(Geometry, raw);
-		if (geometry.width < 1 || geometry.height < 1 || geometry.width > 16384 || geometry.height > 16384 || geometry.width * geometry.height > 33554432) throw failure("limit");
-		ticket.check();
-		const bytes = await page.screenshot({
-			type: "png",
-			fullPage,
-			scale: "css",
-			timeout: timeout(ticket)
-		});
-		if (!(bytes instanceof Uint8Array)) throw failure("malformed");
-		if (bytes.length > maximumBytes) throw failure("limit");
-		const actual = pngGeometry(bytes);
-		if (actual.width > 16384 || actual.height > 16384 || actual.width * actual.height > 33554432) throw failure("limit");
-		ticket.check();
-		return new Uint8Array(bytes);
-	}));
-	/**
-	* Passive: it reads what is on screen and takes a picture, keeps no node, and leaves the
-	* retained observation exactly as it was. Text and picture are sampled one after the other,
-	* so a document replaced in between is reported rather than hidden.
-	*/
-	const checkpoint = (maximumBytes, controlLimit, pictureBytes, ticket) => sanitize(async () => {
-		ticket.check();
-		const { frame } = current();
-		const epoch = targets.epochOf(frame);
-		const { data } = await reading(() => read("viewport", maximumBytes, controlLimit, ticket, false));
-		const picture = pictureBytes === void 0 ? void 0 : await screenshot(false, pictureBytes, ticket);
-		return {
-			url: targets.selectedUrl(),
-			...data,
-			...picture === void 0 ? {} : { picture },
-			documentChanged: targets.epochOf(frame) !== epoch
-		};
-	});
-	return {
-		invalidate,
-		changed,
-		held,
-		dispose,
-		resolve,
-		controlFacts,
-		revalidate,
-		readText,
-		observe,
-		screenshot,
-		checkpoint
-	};
-};
-//#endregion
-//#region src/internal/browser/Pointer.ts
-const Reach = Schema.Struct({
-	viewportWidth: Schema.Finite,
-	viewportHeight: Schema.Finite,
-	reachable: Schema.Boolean
-});
-/**
-* Real pointer input to the selected page. Every command is one the browser would receive from
-* a person, so handlers see trusted events and the browser decides what is under the pointer.
-* Nothing here scrolls, eases or retries: a caller that wants a trajectory sends its points.
-*/
-const makePointer = (targets, actions) => {
-	const { current } = targets;
-	const positions = /* @__PURE__ */ new WeakMap();
-	const moveTo = async (page, point) => {
-		await page.mouse.move(point.x, point.y);
-		positions.set(page, point);
-	};
-	const receipt = (page) => ({ position: positions.get(page) ?? null });
-	const pointerMove = (point, ticket) => sanitize(async () => {
-		const { page } = current().entry;
-		ticket.dispatch();
-		await moveTo(page, point);
-		ticket.check();
-		return receipt(page);
-	});
-	/**
-	* The centre of the element's box, in main-frame viewport pixels, and only if the pointer can
-	* really be placed there: the box has area, the point is inside the viewport, and the element
-	* is what the browser finds at that point. An open shadow root is followed to the node a
-	* person would actually be over.
-	*/
-	const reachablePoint = async (page, element) => {
-		const box = await element.boundingBox();
-		if (box === null || box.width <= 0 || box.height <= 0) throw failure("not-visible", "undispatched");
-		const point = {
-			x: box.x + box.width / 2,
-			y: box.y + box.height / 2
-		};
-		const reach = safeDecode(Reach, await element.evaluate((node) => {
-			const rect = node.getBoundingClientRect();
-			const x = rect.left + rect.width / 2;
-			const y = rect.top + rect.height / 2;
-			let hit = node.ownerDocument.elementFromPoint(x, y);
-			while (hit?.shadowRoot) {
-				const inner = hit.shadowRoot.elementFromPoint(x, y);
-				if (inner === null || inner === hit) break;
-				hit = inner;
-			}
-			return {
-				viewportWidth: window.top === window ? window.innerWidth : Number.POSITIVE_INFINITY,
-				viewportHeight: window.top === window ? window.innerHeight : Number.POSITIVE_INFINITY,
-				reachable: hit !== null && (hit === node || node.contains(hit))
-			};
-		}));
-		const viewport = Number.isFinite(reach.viewportWidth) ? {
-			width: reach.viewportWidth,
-			height: reach.viewportHeight
-		} : safeDecode(Schema.Struct({
-			width: Schema.Finite,
-			height: Schema.Finite
-		}), await page.evaluate(() => ({
-			width: window.innerWidth,
-			height: window.innerHeight
-		})));
-		if (!reach.reachable || point.x < 0 || point.y < 0 || point.x >= viewport.width || point.y >= viewport.height) throw failure("not-visible", "undispatched");
-		return point;
-	};
-	const hover = (target, ticket, policy) => sanitize(async () => {
-		const { page } = current().entry;
-		await actions.withAdmittedElement(target, ticket, (element) => reachablePoint(page, element), (_element, point) => moveTo(page, point), policy);
-		ticket.check();
-		return receipt(page);
-	});
-	const wheel = (deltaX, deltaY, at, ticket) => sanitize(async () => {
-		const { page } = current().entry;
-		ticket.dispatch();
-		if (at !== void 0) await moveTo(page, at);
-		await page.mouse.wheel(deltaX, deltaY);
-		ticket.check();
-		return receipt(page);
-	});
-	return {
-		pointerMove,
-		hover,
-		wheel,
-		receipt
-	};
-};
-//#endregion
-//#region src/internal/browser/Targets.ts
-const TargetInfo = Schema.Struct({ targetInfo: Schema.Struct({
-	targetId: Identifier,
-	type: Schema.Literal("page")
-}) });
-const URLText = Schema.String.check(Schema.isMaxLength(8192));
-/**
-* The connection's pages, frames and document epochs, and the one selected target every other
-* seam acts on. A page beyond the configured bound is closed and faulted, never tracked.
-*/
-const makeTargets = (browser, context, options, callbacks, events, closing, hooks) => {
-	const entries = /* @__PURE__ */ new Map();
-	const byPage = /* @__PURE__ */ new WeakMap();
-	const frameIds = /* @__PURE__ */ new WeakMap();
-	const documentEpochs = /* @__PURE__ */ new WeakMap();
-	const selection = {};
-	const navigating = /* @__PURE__ */ new Set();
-	let serial = 0, frameSerial = 0;
-	let creatingPage = false;
-	const epochOf = (frame) => documentEpochs.get(frame) ?? 0;
-	const frameId = (frame) => {
-		let id = frameIds.get(frame);
-		if (id === void 0) {
-			id = `frame-${++frameSerial}`;
-			frameIds.set(frame, id);
-		}
-		return id;
-	};
-	const register = (page) => {
-		const existing = byPage.get(page);
-		if (existing !== void 0) return existing;
-		const entry = {
-			id: `page-${++serial}`,
-			page,
-			off: []
-		};
-		byPage.set(page, entry);
-		if (entries.size >= options.maxPages) {
-			callbacks.submit(() => closeWithin(() => page.close()));
-			events.fault();
-			return entry;
-		}
-		entries.set(entry.id, entry);
-		for (const frame of page.frames()) frameId(frame);
-		const onClose = () => {
-			hooks.closed(entry);
-			entries.delete(entry.id);
-			for (const off of entry.off.splice(0)) off();
-			if (selection.entry === entry) {
-				selection.entry = void 0;
-				selection.frame = void 0;
-				hooks.changed("target-changed");
-			}
-		};
-		const onNavigation = (frame) => {
-			hooks.navigating(entry, frame);
-			documentEpochs.set(frame, epochOf(frame) + 1);
-			hooks.navigated(entry, frame);
-			frameId(frame);
-			hooks.frameChanged(entry, frame);
-			if (selection.entry === entry && (selection.frame === frame || frame === page.mainFrame())) hooks.changed("target-changed");
-		};
-		const onDetached = (frame) => {
-			hooks.frameChanged(entry, frame);
-			if (selection.frame === frame) {
-				selection.frame = void 0;
-				hooks.changed("target-changed");
-			}
-		};
-		const onDialog = (dialog) => {
-			hooks.dialog(dialog);
-		};
-		page.on("close", onClose);
-		page.on("framenavigated", onNavigation);
-		page.on("framedetached", onDetached);
-		page.on("dialog", onDialog);
-		entry.off.push(() => page.off("close", onClose), () => page.off("framenavigated", onNavigation), () => page.off("framedetached", onDetached), () => page.off("dialog", onDialog));
-		hooks.opened(entry, creatingPage);
-		return entry;
-	};
-	const current = () => {
-		if (closing() || !browser.isConnected() || selection.entry === void 0 || selection.entry.page.isClosed() || selection.frame === void 0 || selection.frame.isDetached()) throw failure("closed", "undispatched");
-		return {
-			entry: selection.entry,
-			frame: selection.frame
-		};
-	};
-	const targetId = async (entry) => {
-		if (entry.targetId !== void 0) return entry.targetId;
-		const cdp = await context.newCDPSession(entry.page);
-		try {
-			const info = await cdp.send("Target.getTargetInfo");
-			entry.targetId = safeDecode(TargetInfo, info).targetInfo.targetId;
-			return entry.targetId;
-		} finally {
-			await closeWithin(() => cdp.detach()).catch(() => {});
-		}
-	};
-	const urlOf = (frame) => safeDecode(URLText, frame.url());
-	const selectedUrl = () => urlOf(current().frame);
-	/**
-	* Chooses the connection's first target: a page it opens itself, the one the caller named, or
-	* the only page present. Assignments land on the live selection as they happen.
-	*/
-	const selectInitial = async () => {
-		if (options.newPage || entries.size === 0) {
-			creatingPage = true;
-			try {
-				selection.entry = register(await context.newPage());
-			} finally {
-				creatingPage = false;
-			}
-		} else if (options.initialTargetId !== void 0) {
-			for (const entry of entries.values()) if (await targetId(entry) === options.initialTargetId) selection.entry = entry;
-			if (selection.entry === void 0) throw failure("not-found");
-		} else {
-			if (entries.size !== 1) throw failure("ambiguous");
-			selection.entry = entries.values().next().value;
-		}
-	};
-	const clear = () => {
-		entries.clear();
-		selection.entry = void 0;
-		selection.frame = void 0;
-	};
-	const selected = () => {
-		const { entry, frame } = current();
-		return {
-			pageId: entry.id,
-			frameId: frameId(frame)
-		};
-	};
-	const selectedTargetId = () => sanitize(() => targetId(current().entry));
-	const listPages = (ticket) => sanitize(async () => {
-		ticket.check();
-		const output = [];
-		for (const entry of entries.values()) {
-			const id = await targetId(entry);
-			const title = await entry.page.title();
-			ticket.check();
-			if (typeof title !== "string") throw failure("malformed");
-			output.push(safeDecode(PageInfo, {
-				pageId: entry.id,
-				targetId: id,
-				title: title.slice(0, 512),
-				url: entry.page.url(),
-				selected: selection.entry === entry
-			}));
-		}
-		return output;
-	});
-	const selectPage = (id, ticket) => sanitize(async () => {
-		const entry = entries.get(id);
-		ticket.check();
-		if (entry === void 0 || entry.page.isClosed()) throw failure("not-found", "undispatched");
-		await hooks.release();
-		ticket.check();
-		selection.entry = entry;
-		selection.frame = entry.page.mainFrame();
-		hooks.changed("target-changed");
-	});
-	const newPage = (ticket) => sanitize(async () => {
-		if (entries.size >= options.maxPages) throw failure("limit", "undispatched");
-		ticket.dispatch();
-		creatingPage = true;
-		try {
-			const page = await context.newPage();
-			if (ticket.signal.aborted) {
-				await closeWithin(() => page.close()).catch(() => {});
-				ticket.check();
-			}
-			return register(page).id;
-		} finally {
-			creatingPage = false;
-		}
-	});
-	const closePage = (id, ticket) => sanitize(async () => {
-		const entry = entries.get(id);
-		if (entry === void 0) throw failure("not-found", "undispatched");
-		ticket.dispatch();
-		await entry.page.close({ runBeforeUnload: false });
-		ticket.check();
-	});
-	const listFrames = (ticket) => sanitize(async () => {
-		ticket.check();
-		const frames = current().entry.page.frames();
-		if (frames.length > 128) throw failure("limit");
-		return frames.map((frame) => safeDecode(FrameInfo, {
-			frameId: frameId(frame),
-			parentFrameId: frame.parentFrame() === null ? null : frameId(frame.parentFrame()),
-			url: frame.url(),
-			name: frame.name().slice(0, 256)
-		}));
-	});
-	const selectFrame = (id, ticket) => sanitize(async () => {
-		const entry = selection.entry;
-		if (entry === void 0) throw failure("closed");
-		const frame = entry.page.frames().find((f) => frameId(f) === id);
-		if (frame === void 0 || frame.isDetached()) throw failure("not-found", "undispatched");
-		await hooks.release();
-		ticket.check();
-		selection.frame = frame;
-		hooks.changed("target-changed");
-	});
-	return {
-		entries,
-		selection,
-		epochOf,
-		frameId,
-		register,
-		current,
-		targetId,
-		urlOf,
-		/** A navigation this driver began on the page is still in flight. */
-		navigating: {
-			begin: (pageId) => void navigating.add(pageId),
-			end: (pageId) => void navigating.delete(pageId),
-			has: (pageId) => navigating.has(pageId)
-		},
-		selectedUrl,
-		selectInitial,
-		clear,
-		selected,
-		selectedTargetId,
-		listPages,
-		selectPage,
-		newPage,
-		closePage,
-		listFrames,
-		selectFrame
-	};
-};
-//#endregion
-//#region src/internal/browser/Playwright.ts
-const NativeWindow = Schema.Struct({ windowId: Schema.Natural });
-/**
-* The provider-issued address is accepted only as a credential-free Browserbase WSS URL. Every
-* binding applies this first, including one a host routes elsewhere, so routing can never be
-* reached with an address the provider did not plausibly issue.
-*/
-const validateConnection = (connection) => {
-	if (typeof connection !== "string" || connection.length > 16384) throw failure("malformed");
-	let url;
-	try {
-		url = new URL(connection);
-	} catch {
-		throw failure("malformed");
-	}
-	if (url.protocol !== "wss:" || url.username || url.password || url.port || !url.hostname.endsWith(".browserbase.com")) throw failure("unsafe-url");
-	return connection;
-};
-/**
-* Connects to an already validated or host-resolved CDP endpoint and builds the one driver. The
-* import is lazy, so constructing any Layer cannot load Playwright or allocate a browser. A
-* trusted observer sees the engine's browser before the driver exists and never replaces it.
-*/
-const connectPlaywrightEndpoint = async (endpoint, signal, options, events, observe) => {
-	if (signal.aborted) throw failure("interrupted");
-	const { chromium } = await import("playwright-core");
-	const browser = await sanitize(() => chromium.connectOverCDP(endpoint, {
-		timeout: 15e3,
-		...options.pageControl ? { noDefaults: true } : {}
-	}));
-	if (signal.aborted) {
-		await closeWithin(() => browser.close()).catch(() => {});
-		throw failure("interrupted");
-	}
-	try {
-		observe?.(browser);
-		const driver = await makePlaywrightDriver(browser, options, events);
-		if (signal.aborted) {
-			await driver.disconnect().catch(() => {});
-			throw failure("interrupted");
-		}
-		return driver;
-	} catch (error) {
-		await closeWithin(() => browser.close()).catch(() => {});
-		throw Schema.is(BrowserError)(error) || Schema.is(InitializationError)(error) || Schema.is(NativeFailure)(error) ? error : failure("provider");
-	}
-};
-/** Tests may supply a real already-connected browser. This is deliberately not an exported subpath. */
-const makePlaywrightDriver = async (browser, options, events) => {
-	const contexts = browser.contexts();
-	if (contexts.length !== 1) throw failure("ambiguous");
-	const context = contexts[0];
-	const dialogs = /* @__PURE__ */ new Set();
-	const callbacks = new CallbackTasks(32, () => events.fault());
-	let closing = false;
-	let initialized = false;
-	let browserCdp;
-	const targets = makeTargets(browser, context, options, callbacks, events, () => closing, {
-		opened: (entry, created) => {
-			if (initialized && options.pageControl) callbacks.submit(async () => {
-				await pageControl.execution(entry);
-			});
-			if (initialized) initialization.attachPage(entry.page);
-			if (initialized && !created) {
-				if (options.popupPolicy === "close") callbacks.submit(() => closeWithin(() => entry.page.close()));
-				else if (options.popupPolicy === "pause") events.pause();
-			}
-		},
-		closed: (entry) => {
-			pageControl.closed(entry);
-			captures.invalidate(entry, "target-changed");
-			captures.forget(entry);
-		},
-		navigating: (entry, frame) => pageControl.navigating(entry, frame),
-		navigated: (entry, frame) => {
-			if (initialized) initialization.attachFrame(frame, entry.page);
-		},
-		frameChanged: (entry, frame) => {
-			captures.invalidate(entry, "target-changed", frame);
-		},
-		dialog: (dialog) => {
-			if (options.dialogPolicy === "dismiss") callbacks.submit(() => closeWithin(() => dialog.dismiss()));
-			else if (dialogs.size >= 8) {
-				events.fault();
-				callbacks.submit(() => closeWithin(() => dialog.dismiss()));
-			} else {
-				dialogs.add(dialog);
-				observation.invalidate();
-				events.pause();
-			}
-		},
-		release: () => observation.dispose(),
-		changed: (reason) => observation.changed(reason)
-	});
-	const { current, entries, register } = targets;
-	const initialization = makeInitialization(context, options, targets, callbacks, events, () => closing);
-	const observation = makeObservation(targets, events);
-	const actions = makeActions(context, targets, observation);
-	const pointer = makePointer(targets, actions);
-	const keyboard = makeKeyboard(targets, actions, pointer.receipt);
-	const captures = makeCaptureSources(targets);
-	const pageControl = makePageControl(browser, context, options, targets, callbacks, events, () => closing, (pageId) => observation.held(pageId));
-	const onPage = (page) => {
-		register(page);
-	};
-	const onDisconnected = () => {
-		if (!closing) {
-			observation.invalidate();
-			events.disconnected();
-		}
-	};
-	context.on("page", onPage);
-	browser.on("disconnected", onDisconnected);
-	const sizeNativeContents = async (entry) => {
-		if (browserCdp === void 0) throw failure("closed", "undispatched");
-		const targetId = await targets.targetId(entry);
-		const current = await browserCdp.send("Browser.getWindowForTarget", { targetId });
-		const native = safeDecode(NativeWindow, current);
-		await browserCdp.send("Browser.setContentsSize", {
-			windowId: native.windowId,
-			width: options.viewport.width,
-			height: options.viewport.height
-		});
-	};
-	const driver = {
-		...options.pageControl ? { pageControl: pageControl.operations } : {},
-		selected: targets.selected,
-		selectedTargetId: targets.selectedTargetId,
-		listPages: targets.listPages,
-		selectPage: targets.selectPage,
-		newPage: targets.newPage,
-		closePage: targets.closePage,
-		listFrames: targets.listFrames,
-		selectFrame: targets.selectFrame,
-		beginNavigation: actions.beginNavigation,
-		readText: observation.readText,
-		observe: observation.observe,
-		checkpoint: observation.checkpoint,
-		controlFacts: observation.controlFacts,
-		revalidate: observation.revalidate,
-		click: actions.click,
-		fill: actions.fill,
-		scroll: actions.scroll,
-		pointerMove: pointer.pointerMove,
-		hover: pointer.hover,
-		wheel: pointer.wheel,
-		press: keyboard.press,
-		type: keyboard.type,
-		screenshot: observation.screenshot,
-		resize: (viewport, ticket) => sanitize(async () => {
-			const page = current().entry.page;
-			const entry = current().entry;
-			ticket.dispatch();
-			captures.invalidate(entry, "resized");
-			observation.changed("resized");
-			await page.setViewportSize(viewport);
-			ticket.check();
-		}),
-		waitFor: actions.waitFor,
-		clickAndWait: actions.clickAndWait,
-		clickForDownload: actions.clickForDownload,
-		selectFiles: actions.selectFiles,
-		clickForFileSelection: actions.clickForFileSelection,
-		documentReadiness: initialization.documentReadiness,
-		dismissDialogs: (ticket) => sanitize(async () => {
-			for (const dialog of [...dialogs]) {
-				ticket.dispatch();
-				await dialog.dismiss();
-				dialogs.delete(dialog);
-			}
-		}),
-		capture: captures.capture,
-		invalidateObservation: observation.invalidate,
-		fenceInitialization: initialization.fence,
-		disposeInitialization: initialization.dispose,
-		disconnect: () => sanitize(async () => {
-			closing = true;
-			initialization.fence();
-			callbacks.stop();
-			observation.invalidate();
-			context.off("page", onPage);
-			browser.off("disconnected", onDisconnected);
-			for (const entry of entries.values()) for (const off of entry.off.splice(0)) off();
-			captures.clear();
-			await closeWithin(initialization.dispose).catch(() => {});
-			await observation.dispose().catch(() => {});
-			await closeWithin(() => Promise.allSettled([...dialogs].map((dialog) => dialog.dismiss()))).catch(() => {});
-			dialogs.clear();
-			await closeWithin(() => callbacks.settle()).catch(() => {});
-			await closeWithin(() => pageControl.dispose()).catch(() => {});
-			await closeWithin(() => browserCdp?.detach() ?? Promise.resolve()).catch(() => {});
-			await closeWithin(() => browser.close());
-			targets.clear();
-		})
-	};
-	try {
-		for (const page of context.pages()) register(page);
-		browserCdp = await browser.newBrowserCDPSession();
-		await browserCdp.send("Browser.setDownloadBehavior", {
-			behavior: "allow",
-			downloadPath: "downloads",
-			eventsEnabled: true
-		});
-		await initialization.install();
-		for (const entry of entries.values()) await initialization.attach(entry.page);
-		await targets.selectInitial();
-		const { selection } = targets;
-		if (selection.entry === void 0) throw failure("not-found");
-		await initialization.attach(selection.entry.page);
-		selection.frame = selection.entry.page.mainFrame();
-		if (!options.preserveViewport) {
-			await sizeNativeContents(selection.entry);
-			await selection.entry.page.setViewportSize(options.viewport);
-		}
-		await targets.targetId(selection.entry);
-		if (options.pageControl) for (const entry of entries.values()) await pageControl.execution(entry);
-		initialized = true;
-		return driver;
-	} catch (error) {
-		await driver.disconnect().catch(() => {});
-		throw error;
-	}
-};
-//#endregion
-//#region src/BrowserBinding.ts
-const invalid = (connection) => Effect.try({
-	try: () => validateConnection(connection),
-	catch: (error) => publicError(error, "connect", { reason: "malformed" })
-});
-/** Playwright over CDP, lazily loaded at connection time and never at Layer construction. */
-const playwright = (options = {}) => {
-	const { resolveEndpoint, onConnected } = options;
-	return issueBinding({ _tag: "BrowserbaseBrowserBinding" }, { connect: (request) => Effect.gen(function* () {
-		const validated = yield* invalid(request.connection);
-		const endpoint = resolveEndpoint === void 0 ? validated : yield* resolveEndpoint({ url: Redacted.make(validated) });
-		return yield* fromNativeAttempt((attempt, signal) => connectPlaywrightEndpoint(endpoint, signal, attempt.options, attempt.events, onConnected === void 0 ? void 0 : (native) => onConnected({
-			native,
-			endpoint
-		}))).connect(request);
-	}) });
-};
-const defaultBinding = playwright();
-/** Defaults to Playwright with the provider's own address, so no consumer has to provide it. */
-const BrowserbaseBrowserBinding = Context.Reference("effect-browserbase/BrowserBinding", { defaultValue: () => defaultBinding });
-/** Supply a binding to every browser Layer built beneath it. */
-const layer = (binding) => Layer.succeed(BrowserbaseBrowserBinding, binding);
-const layerPlaywright = layer(defaultBinding);
-//#endregion
-export { bindingImplementation as a, playwright as i, layer as n, layerPlaywright as r, BrowserbaseBrowserBinding as t };
-
-//# sourceMappingURL=BrowserBinding-qbQA6JhH.mjs.map