@effect-agent/platform-cloudflare 0.1.0-beta.8 → 0.1.0-beta.80

package/dist/InteractiveBrowser.mjs

@@ -0,0 +1,1090 @@
+import { n as BrowserRunSessionLifecycle, t as BrowserRunCleanupError } from "./browser-session-lifecycle-CUbVfEgP.mjs";
+import { Clock, Context, Duration, Effect, Layer, Option, Redacted, Ref, Schema, Semaphore } from "effect";
+import { PageScreenshotResult } from "@effect-agent/sandbox/PageScreenshot";
+import { SandboxImplementation } from "@effect-agent/sandbox/Sandbox";
+import puppeteer from "@cloudflare/puppeteer";
+import { BrowserActionResult, BrowserNavigationResult, BrowserScreenshotRequest, BrowserScrollRequest, BrowserTextResult, InteractiveBrowser, InteractiveBrowserActionError, InteractiveBrowserBusyError, InteractiveBrowserCapacityError, InteractiveBrowserExpiredError, InteractiveBrowserLimitError, InteractiveBrowserPolicy, InteractiveBrowserPolicyDeniedError, InteractiveBrowserProtocolError, InteractiveBrowserTargetUrl, InteractiveBrowserUnsupportedError } from "@effect-agent/sandbox/InteractiveBrowser";
+//#region src/InteractiveBrowser.ts
+const browserRunInteractiveImplementation = SandboxImplementation.make({
+	isolation: "isolated",
+	identity: "cloudflare-browser-run-interactive"
+});
+const MIN_KEEP_ALIVE_MILLIS = 1e4;
+const MAX_KEEP_ALIVE_MILLIS = 6e5;
+const MAX_TEXT_LENGTH = 8388608;
+const MAX_SCREENSHOT_BYTES = 8388608;
+const MIN_LIVE_VIEW_EXPIRY_MILLIS = 6e4;
+const MAX_LIVE_VIEW_EXPIRY_MILLIS = 36e5;
+const MAX_HANDOFF_TIMEOUT_MILLIS = 18e5;
+const MAX_HOST_TEXT_LENGTH = 8192;
+const CLEANUP_STEP_TIMEOUT_MILLIS = 1e4;
+const ACTION_NETWORK_QUIET_MILLIS = 200;
+const ACTION_NETWORK_SETTLE_MILLIS = 2e3;
+const ACTION_POST_STATE_MILLIS = 250;
+const MAX_OBSERVED_CONTROLS = 64;
+const PositiveInt = Schema.Int.check(Schema.isGreaterThan(0));
+const BoundedHostText = Schema.String.check(Schema.isMinLength(1), Schema.isMaxLength(MAX_HOST_TEXT_LENGTH));
+const BoundedRemoteText = Schema.String.check(Schema.isMaxLength(MAX_TEXT_LENGTH));
+const TextObservation = Schema.Union([
+	Schema.Struct({
+		_tag: Schema.Literal("Text"),
+		text: BoundedRemoteText
+	}),
+	Schema.Struct({ _tag: Schema.Literal("MissingElement") }),
+	Schema.Struct({
+		_tag: Schema.Literal("OverLimit"),
+		observed: Schema.Natural
+	})
+]);
+const ActionTargetState = Schema.Struct({
+	matchCount: Schema.Natural,
+	invalidSelector: Schema.optionalKey(Schema.Boolean),
+	kind: Schema.optionalKey(Schema.Literals([
+		"button",
+		"checkbox",
+		"radio",
+		"select",
+		"text",
+		"link",
+		"other"
+	])),
+	checked: Schema.optionalKey(Schema.Boolean),
+	selected: Schema.optionalKey(Schema.Boolean),
+	disabled: Schema.optionalKey(Schema.Boolean),
+	required: Schema.optionalKey(Schema.Boolean),
+	valid: Schema.optionalKey(Schema.Boolean),
+	formValid: Schema.optionalKey(Schema.Boolean)
+});
+const ActionNetworkState = Schema.Struct({
+	total: Schema.Natural,
+	status2xx: Schema.Natural,
+	status3xx: Schema.Natural,
+	status4xx: Schema.Natural,
+	status5xx: Schema.Natural,
+	failed: Schema.Natural,
+	pending: Schema.Natural,
+	settleTimedOut: Schema.Boolean
+});
+const ActionObservation = Schema.Struct({
+	before: ActionTargetState,
+	after: Schema.optionalKey(ActionTargetState),
+	afterUnavailable: Schema.Boolean,
+	network: ActionNetworkState
+});
+const PageObservation = Schema.fromJsonString(Schema.Struct({
+	pageText: BoundedRemoteText,
+	selectorMatchCount: Schema.Natural,
+	controlsTruncated: Schema.Boolean,
+	controls: Schema.Array(Schema.Struct({
+		selector: BoundedRemoteText,
+		kind: BoundedRemoteText,
+		label: Schema.optionalKey(Schema.String.check(Schema.isMaxLength(200))),
+		checked: Schema.optionalKey(Schema.Boolean),
+		selected: Schema.optionalKey(Schema.Boolean),
+		disabled: Schema.optionalKey(Schema.Boolean),
+		required: Schema.optionalKey(Schema.Boolean),
+		valid: Schema.optionalKey(Schema.Boolean),
+		formValid: Schema.optionalKey(Schema.Boolean)
+	})).check(Schema.isMaxLength(MAX_OBSERVED_CONTROLS))
+}));
+const PngBytes = Schema.Uint8Array.check(Schema.isMaxLength(MAX_SCREENSHOT_BYTES), Schema.makeFilter((bytes) => bytes.length >= 8 && bytes[0] === 137 && bytes[1] === 80 && bytes[2] === 78 && bytes[3] === 71 && bytes[4] === 13 && bytes[5] === 10 && bytes[6] === 26 && bytes[7] === 10, { title: "PNG bytes" }));
+const BrowserRunSessionId = Schema.String.check(Schema.isMinLength(1), Schema.isMaxLength(256), Schema.makeFilter((value) => /^[A-Za-z0-9_-]+$/.test(value), { title: "a Browser Run session identifier" }));
+const LiveViewUrl = Schema.String.check(Schema.isMaxLength(MAX_HOST_TEXT_LENGTH), Schema.makeFilter((value) => {
+	try {
+		const url = new URL(value);
+		return url.protocol === "https:" && url.host === "live.browser.run" && url.username === "" && url.password === "" && url.pathname === "/ui/view" && url.searchParams.get("mode") === "tab" && (url.searchParams.get("wss") ?? "").startsWith("live.browser.run/api/devtools/browser/");
+	} catch {
+		return false;
+	}
+}, { title: "a Cloudflare Live View HTTPS URL" }));
+const LiveViewObservation = Schema.Struct({ devtoolsFrontendUrl: LiveViewUrl });
+const HandoffObservation = Schema.Struct({ handoffId: BoundedHostText });
+const HandoffDuration = Schema.Natural.check(Schema.isLessThanOrEqualTo(MAX_HANDOFF_TIMEOUT_MILLIS));
+const HandoffStateObservation = Schema.Union([Schema.Struct({
+	active: Schema.Literal(true),
+	handoffId: BoundedHostText,
+	durationMs: HandoffDuration
+}), Schema.Struct({
+	active: Schema.Literal(false),
+	handoffId: Schema.optionalKey(BoundedHostText),
+	durationMs: Schema.optionalKey(HandoffDuration)
+})]);
+/**
+* Host presentation state in CSS pixels. Dimensions are integers in 1..2048,
+* density is finite in 1..2 (default 1), and neither scaled dimension may exceed
+* 2048 pixels. Mobile, touch, and orientation emulation are not supported.
+*/
+var BrowserRunViewport = class extends Schema.Class("BrowserRunViewport")(Schema.Struct({
+	width: PositiveInt.check(Schema.isLessThanOrEqualTo(2048)),
+	height: PositiveInt.check(Schema.isLessThanOrEqualTo(2048)),
+	deviceScaleFactor: Schema.optionalKey(Schema.Finite.check(Schema.isBetween({
+		minimum: 1,
+		maximum: 2
+	})))
+}).check(Schema.makeFilter((viewport) => Math.max(viewport.width, viewport.height) * (viewport.deviceScaleFactor ?? 1) <= 2048, { title: "a viewport with scaled dimensions no larger than 2048 pixels" }))) {};
+const decodeViewport = (input) => Schema.decodeUnknownEffect(BrowserRunViewport)(input, { onExcessProperty: "error" }).pipe(Effect.mapError(() => policyError("The browser viewport is malformed")), Effect.map((viewport) => ({
+	width: viewport.width,
+	height: viewport.height,
+	deviceScaleFactor: viewport.deviceScaleFactor ?? 1
+})));
+/** Host-only request for a redacted Cloudflare Live View URL. */
+var BrowserRunLiveViewRequest = class extends Schema.Class("BrowserRunLiveViewRequest")({
+	mode: Schema.Literal("tab"),
+	expiresInMs: PositiveInt.check(Schema.isBetween({
+		minimum: MIN_LIVE_VIEW_EXPIRY_MILLIS,
+		maximum: MAX_LIVE_VIEW_EXPIRY_MILLIS
+	}))
+}) {};
+var BrowserRunLiveViewResult = class extends Schema.Class("BrowserRunLiveViewResult")({ devtoolsFrontendUrl: Schema.Redacted(LiveViewUrl) }) {};
+/** Start one bounded handoff; controller ownership remains a consumer concern. */
+var BrowserRunHandoffRequest = class extends Schema.Class("BrowserRunHandoffRequest")({
+	instructions: BoundedHostText.check(Schema.isMaxLength(1024)),
+	timeout: PositiveInt.check(Schema.isLessThanOrEqualTo(MAX_HANDOFF_TIMEOUT_MILLIS))
+}) {};
+var BrowserRunHandoffResult = class extends Schema.Class("BrowserRunHandoffResult")({ handoffId: Schema.Redacted(BoundedHostText) }) {};
+var BrowserRunHandoffState = class extends Schema.Class("BrowserRunHandoffState")({
+	active: Schema.Boolean,
+	handoffId: Schema.optionalKey(Schema.Redacted(BoundedHostText)),
+	durationMs: Schema.optionalKey(HandoffDuration)
+}) {};
+/** Host-supplied Browser Run binding projected into one fakeable launch operation. */
+var BrowserRunInteractiveBinding = class BrowserRunInteractiveBinding extends Context.Service()("@effect-agent/platform-cloudflare/BrowserRunInteractiveBinding") {
+	static layer(options) {
+		return Layer.effect(BrowserRunInteractiveBinding)(Effect.gen(function* () {
+			const lifecycle = yield* BrowserRunSessionLifecycle;
+			const viewport = options.viewport === void 0 ? void 0 : yield* decodeViewport(options.viewport);
+			return {
+				launch: async (keepAliveMillis) => makeProductionBrowser(await puppeteer.launch(options.browser, {
+					keep_alive: keepAliveMillis,
+					...viewport === void 0 ? {} : { defaultViewport: { ...viewport } }
+				})),
+				closeSession: (sessionId) => lifecycle.close(sessionId).pipe(Effect.mapError((cause) => actionError("close", cause)))
+			};
+		}));
+	}
+};
+/** Cloudflare host authority kept separate from the provider-neutral browser handle. */
+var BrowserRunInteractiveHost = class extends Context.Service()("@effect-agent/platform-cloudflare/BrowserRunInteractiveHost") {};
+const makeProductionRequest = (request) => ({
+	url: () => request.url(),
+	abort: () => request.abort("blockedbyclient"),
+	continue: () => request.continue()
+});
+const makeProductionCdpSession = (session) => ({
+	send: async (command, parameters) => {
+		const send = Reflect.get(session, "send");
+		return await Reflect.apply(send, session, [command, parameters]);
+	},
+	detach: () => session.detach()
+});
+var BrowserRunActionUndispatched = class extends Error {
+	matchCount;
+	constructor(matchCount) {
+		super("The browser action selector did not resolve to exactly one element");
+		this.matchCount = matchCount;
+	}
+};
+const readActionTarget = (page, selector) => page.evaluate((requestedSelector) => {
+	const pageDocument = Reflect.get(globalThis, "document");
+	let matches;
+	try {
+		matches = Reflect.apply(Reflect.get(pageDocument, "querySelectorAll"), pageDocument, [requestedSelector]);
+	} catch (cause) {
+		if (cause instanceof Error && cause.name === "SyntaxError") return {
+			matchCount: 0,
+			invalidSelector: true
+		};
+		throw cause;
+	}
+	if (typeof matches !== "object" || matches === null) throw new Error("Invalid query result");
+	const matchCount = Math.min(1e4, Reflect.get(matches, "length"));
+	const element = Reflect.get(matches, 0);
+	if (element === void 0) return { matchCount };
+	const associated = Reflect.get(element, "control") ?? element;
+	const tagName = String(Reflect.get(associated, "tagName") ?? "").toLowerCase();
+	const inputType = String(Reflect.get(associated, "type") ?? "").toLowerCase();
+	const role = String(Reflect.apply(Reflect.get(element, "getAttribute"), element, ["role"]) ?? "").toLowerCase();
+	const kind = tagName === "button" || role === "button" ? "button" : inputType === "checkbox" || role === "checkbox" || role === "switch" ? "checkbox" : inputType === "radio" || role === "radio" ? "radio" : tagName === "select" ? "select" : tagName === "input" || tagName === "textarea" ? "text" : tagName === "a" ? "link" : "other";
+	const checked = Reflect.get(associated, "checked");
+	const selected = tagName === "select" ? Reflect.get(associated, "selectedIndex") >= 0 : Reflect.get(associated, "selected");
+	const disabled = Reflect.get(associated, "disabled");
+	const required = Reflect.get(associated, "required");
+	const validity = Reflect.get(associated, "validity");
+	const form = Reflect.get(associated, "form");
+	const formMatches = form === null || form === void 0 ? void 0 : Reflect.get(form, "matches");
+	const ariaChecked = Reflect.apply(Reflect.get(element, "getAttribute"), element, ["aria-checked"]);
+	const ariaDisabled = Reflect.apply(Reflect.get(element, "getAttribute"), element, ["aria-disabled"]);
+	const ariaSelected = Reflect.apply(Reflect.get(element, "getAttribute"), element, ["aria-selected"]);
+	return {
+		matchCount,
+		kind,
+		...typeof checked === "boolean" ? { checked } : ariaChecked === "true" || ariaChecked === "false" ? { checked: ariaChecked === "true" } : {},
+		...typeof selected === "boolean" ? { selected } : ariaSelected === "true" || ariaSelected === "false" ? { selected: ariaSelected === "true" } : {},
+		disabled: typeof disabled === "boolean" ? disabled : ariaDisabled === "true",
+		...typeof required === "boolean" ? { required } : {},
+		...validity !== void 0 && typeof Reflect.get(validity, "valid") === "boolean" ? { valid: Reflect.get(validity, "valid") } : {},
+		...typeof formMatches === "function" ? { formValid: Reflect.apply(formMatches, form, [":valid"]) } : {}
+	};
+}, selector);
+const boundedBestEffort = async (promise, millis) => {
+	let timer;
+	try {
+		return await Promise.race([promise.catch(() => void 0), new Promise((resolve) => {
+			timer = setTimeout(resolve, millis);
+		})]);
+	} finally {
+		clearTimeout(timer);
+	}
+};
+const readActionTargetAfter = (page, selector) => boundedBestEffort(readActionTarget(page, selector).then(Schema.decodeUnknownSync(ActionTargetState)), ACTION_POST_STATE_MILLIS);
+const makeActionRequestTracker = (page, signal) => {
+	const pending = /* @__PURE__ */ new Set();
+	let total = 0;
+	let status2xx = 0;
+	let status3xx = 0;
+	let status4xx = 0;
+	let status5xx = 0;
+	let failed = 0;
+	let lastChange = performance.now();
+	let closed = false;
+	let wake;
+	let timer;
+	const relevant = (request) => {
+		const resourceType = request.resourceType();
+		return resourceType === "fetch" || resourceType === "xhr";
+	};
+	const onRequest = (request) => {
+		if (!relevant(request)) return;
+		pending.add(request);
+		total++;
+		lastChange = performance.now();
+	};
+	const onFinished = (request) => {
+		if (!pending.delete(request)) return;
+		let status;
+		try {
+			status = request.response()?.status();
+		} catch {}
+		if (status !== void 0) {
+			if (status >= 200 && status < 300) status2xx++;
+			else if (status >= 300 && status < 400) status3xx++;
+			else if (status >= 400 && status < 500) status4xx++;
+			else if (status >= 500 && status < 600) status5xx++;
+		}
+		lastChange = performance.now();
+	};
+	const onFailed = (request) => {
+		if (!pending.delete(request)) return;
+		failed++;
+		lastChange = performance.now();
+	};
+	const close = () => {
+		if (closed) return;
+		closed = true;
+		page.off("request", onRequest);
+		page.off("requestfinished", onFinished);
+		page.off("requestfailed", onFailed);
+		signal.removeEventListener("abort", close);
+		clearTimeout(timer);
+		wake?.();
+	};
+	try {
+		page.on("request", onRequest);
+		page.on("requestfinished", onFinished);
+		page.on("requestfailed", onFailed);
+		signal.addEventListener("abort", close, { once: true });
+		if (signal.aborted) close();
+	} catch (cause) {
+		close();
+		throw cause;
+	}
+	const wait = async () => {
+		const startedAt = performance.now();
+		let settleTimedOut = false;
+		while (!closed) {
+			const now = performance.now();
+			if (pending.size === 0 && now - lastChange >= ACTION_NETWORK_QUIET_MILLIS) break;
+			if (now - startedAt >= ACTION_NETWORK_SETTLE_MILLIS) {
+				settleTimedOut = true;
+				break;
+			}
+			await new Promise((resolve) => {
+				wake = resolve;
+				timer = setTimeout(() => resolve(), 50);
+			});
+			wake = void 0;
+		}
+		return {
+			total,
+			status2xx,
+			status3xx,
+			status4xx,
+			status5xx,
+			failed,
+			pending: pending.size,
+			settleTimedOut
+		};
+	};
+	return {
+		wait,
+		close,
+		markActionSettled: () => {
+			lastChange = performance.now();
+		}
+	};
+};
+const disposeActionHandles = async (handles) => {
+	await boundedBestEffort(Promise.allSettled(handles.map(async (handle) => handle.dispose())), ACTION_POST_STATE_MILLIS);
+};
+const runObservedPageAction = async (page, selector, signal, onDispatch, action) => {
+	if (signal.aborted) throw new BrowserRunActionUndispatched(0);
+	const before = Schema.decodeUnknownSync(ActionTargetState)(await readActionTarget(page, selector));
+	if (before.matchCount !== 1 || before.invalidSelector === true) throw new BrowserRunActionUndispatched(before.matchCount);
+	const matches = await page.$$(selector);
+	if (matches.length !== 1 || matches[0] === void 0) {
+		await disposeActionHandles(matches);
+		throw new BrowserRunActionUndispatched(Math.min(1e4, matches.length));
+	}
+	if (signal.aborted) {
+		await disposeActionHandles(matches);
+		throw new BrowserRunActionUndispatched(1);
+	}
+	let tracker;
+	let disposing;
+	const dispose = () => disposing ??= disposeActionHandles(matches);
+	const onAbort = () => {
+		dispose();
+	};
+	signal.addEventListener("abort", onAbort, { once: true });
+	try {
+		tracker = makeActionRequestTracker(page, signal);
+		if (signal.aborted) throw new BrowserRunActionUndispatched(1);
+		onDispatch();
+		await action(matches[0]);
+		tracker.markActionSettled();
+		const network = await tracker.wait();
+		const after = signal.aborted ? void 0 : await readActionTargetAfter(page, selector);
+		return {
+			before,
+			...after === void 0 ? {} : { after },
+			afterUnavailable: after === void 0,
+			network
+		};
+	} finally {
+		tracker?.close();
+		signal.removeEventListener("abort", onAbort);
+		await dispose();
+	}
+};
+const makeProductionPage = (page) => {
+	const listeners = /* @__PURE__ */ new Map();
+	return {
+		close: () => page.close(),
+		setBypassServiceWorker: (enabled) => page.setBypassServiceWorker(enabled),
+		setRequestInterception: (enabled) => page.setRequestInterception(enabled),
+		onRequest: (listener) => {
+			const sdkListener = (request) => listener(makeProductionRequest(request));
+			listeners.set(listener, sdkListener);
+			page.on("request", sdkListener);
+		},
+		offRequest: (listener) => {
+			const sdkListener = listeners.get(listener);
+			if (sdkListener !== void 0) {
+				page.off("request", sdkListener);
+				listeners.delete(listener);
+			}
+		},
+		goto: async (url) => {
+			await page.goto(url, {
+				waitUntil: "domcontentloaded",
+				timeout: 3e4
+			});
+		},
+		url: () => page.url(),
+		readText: async (selector, maximumBytes) => {
+			const observation = Schema.decodeUnknownSync(TextObservation)(await page.evaluate((requestedSelector, maximum, maximumControls) => {
+				const pageDocument = Reflect.get(globalThis, "document");
+				const matches = requestedSelector === void 0 ? void 0 : Reflect.apply(Reflect.get(pageDocument, "querySelectorAll"), pageDocument, [requestedSelector]);
+				const selectorMatchCount = matches === void 0 || matches === null ? 1 : Math.min(1e4, Reflect.get(matches, "length"));
+				const element = matches === void 0 || matches === null ? Reflect.get(pageDocument, "body") : Reflect.get(matches, 0);
+				if (element === null) return { _tag: "MissingElement" };
+				if (element === void 0) return { _tag: "MissingElement" };
+				const innerText = Reflect.get(element, "innerText");
+				const textContent = Reflect.get(element, "textContent");
+				const pageText = typeof innerText === "string" ? innerText : typeof textContent === "string" ? textContent : "";
+				const primaryControlSelector = "input,select,textarea,label,button,[role=\"checkbox\"],[role=\"radio\"],[role=\"option\"],[role=\"switch\"],[role=\"tab\"],[role=\"button\"]";
+				const optionSelector = "select option";
+				const secondaryControlSelector = "a[href]";
+				const controlSelector = `${primaryControlSelector},${optionSelector},${secondaryControlSelector}`;
+				const selectorFor = (candidate) => {
+					const parts = [];
+					let current = candidate;
+					while (current !== null && current !== void 0) {
+						const tagName = String(Reflect.get(current, "tagName") ?? "").toLowerCase();
+						if (tagName === "") break;
+						const parent = Reflect.get(current, "parentElement");
+						if (parent === null) {
+							parts.push(tagName);
+							break;
+						}
+						let sibling = Reflect.get(current, "previousElementSibling");
+						let index = 1;
+						while (sibling !== null && sibling !== void 0) {
+							if (String(Reflect.get(sibling, "tagName") ?? "").toLowerCase() === tagName) index++;
+							sibling = Reflect.get(sibling, "previousElementSibling");
+						}
+						parts.push(`${tagName}:nth-of-type(${index})`);
+						current = parent;
+					}
+					return parts.reverse().join(" > ");
+				};
+				const visible = (candidate) => {
+					const hidden = Reflect.get(candidate, "hidden");
+					const ariaHidden = Reflect.apply(Reflect.get(candidate, "getAttribute"), candidate, ["aria-hidden"]);
+					const rects = Reflect.apply(Reflect.get(candidate, "getClientRects"), candidate, []);
+					return hidden !== true && ariaHidden !== "true" && typeof rects === "object" && rects !== null && Reflect.get(rects, "length") > 0;
+				};
+				const candidates = [];
+				let controlsTruncated = false;
+				const consider = (candidate) => {
+					const tagName = String(Reflect.get(candidate, "tagName") ?? "").toLowerCase();
+					const visibilityTarget = tagName === "option" ? Reflect.apply(Reflect.get(candidate, "closest"), candidate, ["select"]) : candidate;
+					if (!(tagName !== "label" || Reflect.get(candidate, "control") !== null) || typeof visibilityTarget !== "object" || visibilityTarget === null || !visible(visibilityTarget)) return;
+					candidates.push(candidate);
+					if (candidates.length > maximumControls) controlsTruncated = true;
+				};
+				const elementMatches = Reflect.get(element, "matches");
+				if (typeof elementMatches === "function" && Reflect.apply(elementMatches, element, [controlSelector])) consider(element);
+				const considerSelector = (candidateSelector) => {
+					const descendants = Reflect.apply(Reflect.get(element, "querySelectorAll"), element, [candidateSelector]);
+					if (typeof descendants !== "object" || descendants === null) return;
+					const descendantCount = Reflect.get(descendants, "length");
+					for (let index = 0; index < descendantCount && !controlsTruncated; index++) consider(Reflect.get(descendants, index));
+				};
+				considerSelector(primaryControlSelector);
+				if (!controlsTruncated) considerSelector(optionSelector);
+				if (!controlsTruncated) considerSelector(secondaryControlSelector);
+				const controls = candidates.slice(0, maximumControls).map((candidate) => {
+					const associated = Reflect.get(candidate, "control") ?? candidate;
+					const tagName = String(Reflect.get(candidate, "tagName") ?? "").toLowerCase();
+					const inputType = String(Reflect.get(associated, "type") ?? "").toLowerCase();
+					const role = String(Reflect.apply(Reflect.get(candidate, "getAttribute"), candidate, ["role"]) ?? "").toLowerCase();
+					const ariaLabel = Reflect.apply(Reflect.get(candidate, "getAttribute"), candidate, ["aria-label"]);
+					const candidateText = tagName === "textarea" || tagName === "input" || tagName === "select" ? void 0 : Reflect.get(candidate, tagName === "option" ? "label" : "innerText");
+					const associatedLabels = Reflect.get(associated, "labels");
+					const associatedLabel = associatedLabels !== void 0 && associatedLabels !== null && Reflect.get(associatedLabels, "length") > 0 ? Reflect.get(Reflect.get(associatedLabels, 0), "innerText") : void 0;
+					const label = String(typeof ariaLabel === "string" && ariaLabel !== "" ? ariaLabel : typeof candidateText === "string" && candidateText !== "" ? candidateText : associatedLabel ?? "").replace(/\s+/g, " ").trim().slice(0, 200);
+					const checked = Reflect.get(associated, "checked");
+					const selected = tagName === "select" ? Reflect.get(associated, "selectedIndex") >= 0 : Reflect.get(associated, "selected");
+					const disabled = Reflect.get(associated, "disabled");
+					const required = Reflect.get(associated, "required");
+					const validity = Reflect.get(associated, "validity");
+					const form = Reflect.get(associated, "form");
+					const formMatches = form === null || form === void 0 ? void 0 : Reflect.get(form, "matches");
+					const ariaChecked = Reflect.apply(Reflect.get(candidate, "getAttribute"), candidate, ["aria-checked"]);
+					const ariaSelected = Reflect.apply(Reflect.get(candidate, "getAttribute"), candidate, ["aria-selected"]);
+					const ariaDisabled = Reflect.apply(Reflect.get(candidate, "getAttribute"), candidate, ["aria-disabled"]);
+					return {
+						selector: selectorFor(candidate),
+						kind: tagName === "label" ? `label:${inputType || "control"}` : tagName === "input" ? `input:${inputType || "text"}` : role !== "" ? `role:${role}` : tagName,
+						...label === "" ? {} : { label },
+						...typeof checked === "boolean" ? { checked } : ariaChecked === "true" || ariaChecked === "false" ? { checked: ariaChecked === "true" } : {},
+						...typeof selected === "boolean" ? { selected } : ariaSelected === "true" || ariaSelected === "false" ? { selected: ariaSelected === "true" } : {},
+						...typeof disabled === "boolean" ? { disabled } : ariaDisabled === "true" || ariaDisabled === "false" ? { disabled: ariaDisabled === "true" } : {},
+						...typeof required === "boolean" ? { required } : {},
+						...validity !== void 0 && typeof Reflect.get(validity, "valid") === "boolean" ? { valid: Reflect.get(validity, "valid") } : {},
+						...typeof formMatches === "function" ? { formValid: Reflect.apply(formMatches, form, [":valid"]) } : {}
+					};
+				});
+				const text = JSON.stringify({
+					pageText,
+					selectorMatchCount,
+					controls,
+					controlsTruncated
+				});
+				const observed = new TextEncoder().encode(text).byteLength;
+				return observed > maximum ? {
+					_tag: "OverLimit",
+					observed
+				} : {
+					_tag: "Text",
+					text
+				};
+			}, selector, maximumBytes, MAX_OBSERVED_CONTROLS));
+			if (observation._tag === "Text") Schema.decodeUnknownSync(PageObservation)(observation.text);
+			return observation;
+		},
+		fill: (selector, value, signal, onDispatch) => runObservedPageAction(page, selector, signal, onDispatch, (element) => element.evaluate((element, nextValue) => {
+			let prototype = Reflect.getPrototypeOf(element);
+			let setValue;
+			while (prototype !== null) {
+				const setter = Reflect.getOwnPropertyDescriptor(prototype, "value")?.set;
+				if (typeof setter === "function") {
+					setValue = setter;
+					break;
+				}
+				prototype = Reflect.getPrototypeOf(prototype);
+			}
+			if (setValue === void 0) throw new Error("The selector did not resolve to a fillable field");
+			const focus = Reflect.get(element, "focus");
+			if (typeof focus === "function") Reflect.apply(focus, element, []);
+			Reflect.apply(setValue, element, [nextValue]);
+			const dispatchEvent = Reflect.get(element, "dispatchEvent");
+			if (typeof dispatchEvent === "function") {
+				Reflect.apply(dispatchEvent, element, [new Event("input", { bubbles: true })]);
+				Reflect.apply(dispatchEvent, element, [new Event("change", { bubbles: true })]);
+			}
+		}, value)),
+		click: (selector, signal, onDispatch) => runObservedPageAction(page, selector, signal, onDispatch, (element) => element.click()),
+		screenshot: (fullPage) => page.screenshot({
+			type: "png",
+			fullPage
+		}),
+		scroll: (deltaX, deltaY) => page.evaluate((x, y) => {
+			const scrollBy = Reflect.get(globalThis, "scrollBy");
+			Reflect.apply(scrollBy, globalThis, [{
+				left: x,
+				top: y,
+				behavior: "instant"
+			}]);
+		}, deltaX, deltaY),
+		createCdpSession: async () => makeProductionCdpSession(await page.createCDPSession()),
+		setViewport: (viewport) => page.setViewport(viewport)
+	};
+};
+const makeProductionContext = (context) => ({
+	newPage: async () => makeProductionPage(await context.newPage()),
+	close: () => context.close()
+});
+const makeProductionBrowser = (browser) => ({
+	createContext: async () => makeProductionContext(await browser.createBrowserContext()),
+	close: () => browser.close(),
+	sessionId: () => browser.sessionId(),
+	isConnected: () => browser.isConnected(),
+	onDisconnected: (listener) => {
+		browser.on("disconnected", listener);
+	},
+	offDisconnected: (listener) => {
+		browser.off("disconnected", listener);
+	}
+});
+const protocolError = (message, cause) => InteractiveBrowserProtocolError.make({
+	implementation: browserRunInteractiveImplementation,
+	message,
+	...cause === void 0 ? {} : { cause }
+});
+const actionError = (operation, cause) => InteractiveBrowserActionError.make({
+	implementation: browserRunInteractiveImplementation,
+	operation,
+	message: `The interactive browser ${operation} operation failed`,
+	...cause === void 0 ? {} : { cause }
+});
+const undispatchedActionError = (operation) => InteractiveBrowserActionError.make({
+	implementation: browserRunInteractiveImplementation,
+	operation,
+	message: `The interactive browser ${operation} operation was not dispatched`
+});
+/** Recognizes a local pre-dispatch refusal without exposing selector or page content. */
+const isBrowserRunUndispatchedActionError = (error) => Schema.is(InteractiveBrowserActionError)(error) && error.implementation.identity === browserRunInteractiveImplementation.identity && (error.operation === "click" || error.operation === "fill") && error.message === `The interactive browser ${error.operation} operation was not dispatched`;
+const policyError = (message) => InteractiveBrowserPolicyDeniedError.make({
+	implementation: browserRunInteractiveImplementation,
+	message
+});
+const expiredError = () => InteractiveBrowserExpiredError.make({
+	implementation: browserRunInteractiveImplementation,
+	message: "The remote browser is no longer usable"
+});
+const causeText = (cause) => {
+	if (cause instanceof Error) return cause.message.slice(0, 8e3);
+	return String(cause).slice(0, 8e3);
+};
+const isCapacityRefusal = (cause) => /(^|\D)429(\D|$)|browser time limit|capacity|too many concurrent/i.test(causeText(cause));
+const isRemoteClosure = (cause) => /target closed|browser.*closed|session.*closed|connection.*closed|not connected|websocket.*closed/i.test(causeText(cause));
+const snapshotPolicy = Effect.fn("BrowserRunInteractive.snapshotPolicy")(function* (input) {
+	const decoded = yield* Schema.decodeUnknownEffect(InteractiveBrowserPolicy)(input).pipe(Effect.mapError(() => policyError("The interactive browser policy is malformed")));
+	if (decoded.network._tag === "PublicWeb") return yield* InteractiveBrowserUnsupportedError.make({
+		implementation: browserRunInteractiveImplementation,
+		feature: "policy",
+		message: "Cloudflare Browser Run cannot enforce the PublicWeb network policy for all session traffic"
+	});
+	return Object.freeze({
+		network: decoded.network._tag === "ExactHosts" ? Object.freeze({
+			_tag: decoded.network._tag,
+			allowedHosts: Object.freeze([...decoded.network.allowedHosts])
+		}) : Object.freeze({ _tag: decoded.network._tag }),
+		maxActions: decoded.maxActions,
+		maxElapsedMillis: decoded.maxElapsedMillis,
+		maxReturnedBytes: decoded.maxReturnedBytes
+	});
+});
+const hostAllowed = (policy, value) => {
+	if (policy.network._tag === "Unrestricted") return true;
+	try {
+		const url = new URL(value);
+		return url.protocol === "https:" && url.username === "" && url.password === "" && policy.network.allowedHosts.some((host) => host === url.host);
+	} catch {
+		return false;
+	}
+};
+const keepAliveMillis = (policy) => Math.max(MIN_KEEP_ALIVE_MILLIS, Math.min(MAX_KEEP_ALIVE_MILLIS, policy.maxElapsedMillis));
+const closeLateAcquisition = async (signal, acquire, close) => {
+	const acquired = await acquire();
+	if (!signal.aborted) return acquired;
+	try {
+		await close(acquired);
+	} catch {}
+	throw new Error("The interrupted browser acquisition completed late");
+};
+const closeWithWarning = (close, warning) => Effect.tryPromise({
+	try: close,
+	catch: () => protocolError(warning)
+}).pipe(Effect.timeoutOrElse({
+	duration: Duration.millis(CLEANUP_STEP_TIMEOUT_MILLIS),
+	orElse: () => Effect.fail(protocolError(warning))
+}), Effect.catchCause(() => Effect.logWarning(warning)));
+const deadlineError = Effect.fn("BrowserRunInteractive.deadlineError")(function* (policy, startedAt) {
+	const now = yield* Effect.clockWith((clock) => clock.currentTimeMillis);
+	return yield* InteractiveBrowserLimitError.make({
+		implementation: browserRunInteractiveImplementation,
+		limit: "elapsed",
+		maximum: policy.maxElapsedMillis,
+		observed: Math.max(policy.maxElapsedMillis, now - startedAt),
+		message: "The browser elapsed-time limit was reached"
+	});
+});
+const withinDeadline = Effect.fn("BrowserRunInteractive.withinDeadline")(function* (effect, policy, startedAt, onTimeout) {
+	const now = yield* Effect.clockWith((clock) => clock.currentTimeMillis);
+	const elapsed = Math.max(0, now - startedAt);
+	const remaining = policy.maxElapsedMillis - elapsed;
+	if (remaining <= 0) return yield* deadlineError(policy, startedAt);
+	return yield* effect.pipe(Effect.timeoutOrElse({
+		duration: Duration.millis(remaining),
+		orElse: () => Effect.sync(() => onTimeout?.()).pipe(Effect.andThen(deadlineError(policy, startedAt)))
+	}));
+});
+const stateFailure = (state) => {
+	if (state.violation.value !== void 0) return state.violation.value;
+	if (state.closed.value || state.disconnected.value || state.uncertain.value) return expiredError();
+};
+var BrowserRunRemoteFailure = class {
+	cause;
+	constructor(cause) {
+		this.cause = cause;
+	}
+};
+const awaitPendingRequests = (state) => Effect.suspend(() => {
+	const pending = [...state.pendingRequests];
+	return pending.length === 0 ? Effect.void : Effect.promise(() => Promise.all(pending)).pipe(Effect.asVoid, Effect.andThen(awaitPendingRequests(state)));
+});
+const decodeNavigationResult = Effect.fn("BrowserRunInteractive.decodeNavigationResult")(function* (page, policy) {
+	const url = yield* Effect.try({
+		try: page.url,
+		catch: (cause) => protocolError("Reading the browser navigation URL failed", cause)
+	});
+	const result = yield* Schema.decodeUnknownEffect(BrowserNavigationResult)({ url }).pipe(Effect.mapError((cause) => protocolError("The browser returned a malformed navigation URL", cause)));
+	if (!hostAllowed(policy, result.url)) return yield* policyError("The browser returned an off-policy page URL");
+	return result;
+});
+const decodeActionResult = Effect.fn("BrowserRunInteractive.decodeActionResult")(function* (page, policy) {
+	const url = yield* Effect.try({
+		try: page.url,
+		catch: (cause) => protocolError("Reading the browser page URL failed", cause)
+	});
+	const result = yield* Schema.decodeUnknownEffect(BrowserActionResult)({ url }).pipe(Effect.mapError((cause) => protocolError("The browser returned a malformed page URL", cause)));
+	if (!hostAllowed(policy, result.url)) return yield* policyError("The browser returned an off-policy page URL");
+	return result;
+});
+const makeRequestListener = (policy, state) => (request) => {
+	let allowed = false;
+	try {
+		allowed = hostAllowed(policy, request.url());
+	} catch {
+		allowed = false;
+	}
+	if (!allowed) state.violation.value = policyError("The browser requested an off-policy URL");
+	let settlement;
+	try {
+		settlement = allowed ? request.continue() : request.abort();
+	} catch {
+		state.violation.value = protocolError("Resolving an intercepted browser request failed");
+		return;
+	}
+	const observed = settlement.catch(() => {
+		state.violation.value = protocolError("Resolving an intercepted browser request failed");
+	}).finally(() => {
+		state.pendingRequests.delete(observed);
+	});
+	state.pendingRequests.add(observed);
+};
+const makeHandle = Effect.fn("BrowserRunInteractive.makeHandle")(function* (page, policy, startedAt, state, close) {
+	const permits = yield* Semaphore.make(1);
+	const actions = yield* Ref.make(0);
+	const remote = (operation, evaluate) => Effect.tryPromise({
+		try: evaluate,
+		catch: (cause) => new BrowserRunRemoteFailure(cause)
+	}).pipe(Effect.catch((failure) => {
+		const cause = failure.cause;
+		if (cause instanceof BrowserRunActionUndispatched) return Effect.logInfo("Browser interactive action was not dispatched").pipe(Effect.annotateLogs({
+			"browser.action": operation,
+			"browser.selector_match_count": cause.matchCount
+		}), Effect.andThen(Effect.fail(undispatchedActionError(operation))));
+		if (state.disconnected.value || isRemoteClosure(cause)) {
+			state.disconnected.value = true;
+			return Effect.fail(expiredError());
+		}
+		return Effect.fail(actionError(operation, cause));
+	}));
+	const observedAction = (operation, evaluate) => Effect.suspend(() => {
+		let dispatched = false;
+		let pending;
+		return remote(operation, (signal) => {
+			pending = evaluate(signal, () => {
+				dispatched = true;
+			});
+			return pending;
+		}).pipe(Effect.onInterrupt(() => Effect.gen(function* () {
+			state.uncertain.value = true;
+			yield* Effect.logWarning("Browser interactive action interrupted").pipe(Effect.annotateLogs({
+				"browser.action": operation,
+				"browser.action_dispatched": dispatched,
+				"browser.action_outcome_unknown": dispatched
+			}));
+			const completion = pending;
+			if (completion !== void 0) yield* Effect.promise(() => boundedBestEffort(completion, 500));
+		})));
+	});
+	const decodeActionObservation = Effect.fn("BrowserRunInteractive.decodeActionObservation")(function* (raw) {
+		return yield* Schema.decodeUnknownEffect(ActionObservation)(raw).pipe(Effect.mapError((cause) => protocolError("The browser returned a malformed action observation", cause)));
+	});
+	const logActionObservation = (operation, observation) => Effect.logInfo("Browser interactive action observed").pipe(Effect.annotateLogs({
+		"browser.action": operation,
+		"browser.selector_match_count": observation.before.matchCount,
+		...observation.before.kind === void 0 ? {} : { "browser.target_kind": observation.before.kind },
+		...observation.before.checked === void 0 ? {} : { "browser.target_checked_before": observation.before.checked },
+		...observation.after?.checked === void 0 ? {} : { "browser.target_checked_after": observation.after.checked },
+		...observation.before.selected === void 0 ? {} : { "browser.target_selected_before": observation.before.selected },
+		...observation.after?.selected === void 0 ? {} : { "browser.target_selected_after": observation.after.selected },
+		...observation.before.disabled === void 0 ? {} : { "browser.target_disabled_before": observation.before.disabled },
+		...observation.after?.disabled === void 0 ? {} : { "browser.target_disabled_after": observation.after.disabled },
+		...observation.before.required === void 0 ? {} : { "browser.target_required_before": observation.before.required },
+		...observation.after?.required === void 0 ? {} : { "browser.target_required_after": observation.after.required },
+		...observation.before.valid === void 0 ? {} : { "browser.target_valid_before": observation.before.valid },
+		...observation.after?.valid === void 0 ? {} : { "browser.target_valid_after": observation.after.valid },
+		...observation.before.formValid === void 0 ? {} : { "browser.form_valid_before": observation.before.formValid },
+		...observation.after?.formValid === void 0 ? {} : { "browser.form_valid_after": observation.after.formValid },
+		"browser.target_after_unavailable": observation.afterUnavailable,
+		"browser.fetch_xhr_total": observation.network.total,
+		"browser.fetch_xhr_2xx": observation.network.status2xx,
+		"browser.fetch_xhr_3xx": observation.network.status3xx,
+		"browser.fetch_xhr_4xx": observation.network.status4xx,
+		"browser.fetch_xhr_5xx": observation.network.status5xx,
+		"browser.fetch_xhr_failed": observation.network.failed,
+		"browser.fetch_xhr_pending": observation.network.pending,
+		"browser.network_settle_timed_out": observation.network.settleTimedOut
+	}));
+	const run = (effect, preflight = Effect.void, consumeAction = true) => permits.withPermitsIfAvailable(1)(Effect.gen(function* () {
+		const unavailable = stateFailure(state);
+		if (unavailable !== void 0) return yield* unavailable;
+		yield* preflight;
+		if (consumeAction) {
+			const admitted = yield* Ref.modify(actions, (count) => count >= policy.maxActions ? [{
+				allowed: false,
+				observed: count + 1
+			}, count] : [{
+				allowed: true,
+				observed: count + 1
+			}, count + 1]);
+			if (!admitted.allowed) return yield* InteractiveBrowserLimitError.make({
+				implementation: browserRunInteractiveImplementation,
+				limit: "actions",
+				maximum: policy.maxActions,
+				observed: admitted.observed,
+				message: "The browser action limit was reached"
+			});
+		}
+		const completed = effect.pipe(Effect.catch((error) => {
+			const failure = stateFailure(state);
+			return Effect.fail(failure ?? error);
+		}), Effect.flatMap((result) => awaitPendingRequests(state).pipe(Effect.flatMap(() => {
+			const failure = stateFailure(state);
+			return failure === void 0 ? Effect.succeed(result) : Effect.fail(failure);
+		}))));
+		return yield* withinDeadline(completed, policy, startedAt, () => {
+			state.uncertain.value = true;
+		}).pipe(Effect.onInterrupt(() => Effect.sync(() => {
+			state.uncertain.value = true;
+		})), Effect.catch((error) => {
+			if (Schema.is(InteractiveBrowserLimitError)(error) && error.limit === "elapsed") return Effect.fail(error);
+			const failure = stateFailure(state);
+			if (Schema.is(InteractiveBrowserActionError)(error) && !isBrowserRunUndispatchedActionError(error)) state.uncertain.value = true;
+			return Effect.fail(failure ?? error);
+		}));
+	})).pipe(Effect.flatMap((result) => Option.isSome(result) ? Effect.succeed(result.value) : Effect.fail(InteractiveBrowserBusyError.make({
+		implementation: browserRunInteractiveImplementation,
+		message: "The browser handle already has an operation in flight"
+	}))));
+	return {
+		handle: {
+			navigate: (request) => run(Effect.gen(function* () {
+				yield* remote("navigate", () => page.goto(request.url));
+				return yield* decodeNavigationResult(page, policy);
+			}), Effect.suspend(() => Schema.is(InteractiveBrowserTargetUrl)(request.url) && hostAllowed(policy, request.url) ? Effect.void : Effect.fail(policyError("The navigation URL is outside the browser policy")))),
+			readText: (request) => run(Effect.gen(function* () {
+				const raw = yield* remote("read-text", () => page.readText(request.selector, policy.maxReturnedBytes));
+				const observation = yield* Schema.decodeUnknownEffect(TextObservation)(raw).pipe(Effect.mapError((cause) => protocolError("The browser returned a malformed text observation", cause)));
+				if (observation._tag === "MissingElement") return yield* actionError("read-text");
+				if (observation._tag === "OverLimit") return yield* InteractiveBrowserLimitError.make({
+					implementation: browserRunInteractiveImplementation,
+					limit: "returned-bytes",
+					maximum: policy.maxReturnedBytes,
+					observed: observation.observed,
+					message: "The browser returned-text limit was reached"
+				});
+				const observed = new TextEncoder().encode(observation.text).byteLength;
+				if (observed > policy.maxReturnedBytes) return yield* InteractiveBrowserLimitError.make({
+					implementation: browserRunInteractiveImplementation,
+					limit: "returned-bytes",
+					maximum: policy.maxReturnedBytes,
+					observed,
+					message: "The browser returned-text limit was reached"
+				});
+				return yield* Schema.decodeUnknownEffect(BrowserTextResult)({ text: observation.text }).pipe(Effect.mapError((cause) => protocolError("The browser returned malformed page text", cause)));
+			})),
+			fill: (request) => run(Effect.gen(function* () {
+				const observation = yield* observedAction("fill", (signal, onDispatch) => page.fill(request.selector, request.value, signal, onDispatch)).pipe(Effect.flatMap(decodeActionObservation));
+				yield* logActionObservation("fill", observation);
+				return yield* decodeActionResult(page, policy);
+			})),
+			click: (request) => run(Effect.gen(function* () {
+				const observation = yield* observedAction("click", (signal, onDispatch) => page.click(request.selector, signal, onDispatch)).pipe(Effect.flatMap(decodeActionObservation));
+				yield* logActionObservation("click", observation);
+				return yield* decodeActionResult(page, policy);
+			})),
+			screenshot: (request) => Schema.decodeUnknownEffect(BrowserScreenshotRequest)(request).pipe(Effect.mapError(() => policyError("The browser screenshot request is malformed")), Effect.flatMap((decoded) => run(Effect.gen(function* () {
+				const raw = yield* remote("screenshot", () => page.screenshot(decoded.fullPage));
+				const bytes = yield* Schema.decodeUnknownEffect(PngBytes)(raw).pipe(Effect.mapError(() => protocolError("The browser returned a malformed PNG screenshot")));
+				if (bytes.length > policy.maxReturnedBytes) return yield* InteractiveBrowserLimitError.make({
+					implementation: browserRunInteractiveImplementation,
+					limit: "returned-bytes",
+					maximum: policy.maxReturnedBytes,
+					observed: bytes.length,
+					message: "The browser screenshot byte limit was reached"
+				});
+				return yield* Schema.decodeUnknownEffect(PageScreenshotResult)({
+					implementation: browserRunInteractiveImplementation,
+					mediaType: "image/png",
+					bytes: new Uint8Array(bytes)
+				}).pipe(Effect.mapError(() => protocolError("The browser returned a malformed PNG screenshot")));
+			}), decodeActionResult(page, policy).pipe(Effect.asVoid)))),
+			scroll: (request) => Schema.decodeUnknownEffect(BrowserScrollRequest)(request).pipe(Effect.mapError(() => policyError("The browser scroll request is malformed")), Effect.flatMap((decoded) => run(remote("scroll", () => page.scroll(decoded.deltaX, decoded.deltaY)).pipe(Effect.andThen(decodeActionResult(page, policy))), decodeActionResult(page, policy).pipe(Effect.asVoid)))),
+			close
+		},
+		run
+	};
+});
+const remainingMillis = Effect.fn("BrowserRunInteractive.remainingMillis")(function* (policy, startedAt) {
+	const now = yield* Effect.clockWith((clock) => clock.currentTimeMillis);
+	return Math.max(0, policy.maxElapsedMillis - Math.max(0, now - startedAt));
+});
+const closeEntry = (close, warning) => ({
+	close: Effect.tryPromise({
+		try: close,
+		catch: (cause) => actionError("close", cause)
+	}).pipe(Effect.timeoutOrElse({
+		duration: Duration.millis(CLEANUP_STEP_TIMEOUT_MILLIS),
+		orElse: () => Effect.fail(actionError("close"))
+	})),
+	warning
+});
+const syncCloseEntry = (close, warning) => ({
+	close: Effect.try({
+		try: close,
+		catch: (cause) => actionError("close", cause)
+	}),
+	warning
+});
+const runTeardown = (entries) => Effect.forEach([...entries].reverse(), (entry) => entry.close.pipe(Effect.match({
+	onFailure: (error) => ({
+		error,
+		warning: entry.warning
+	}),
+	onSuccess: () => void 0
+}))).pipe(Effect.map((failures) => failures.filter((failure) => failure !== void 0)));
+const cdpCommand = (page, state, command, parameters, output, malformedMessage) => Effect.scoped(Effect.gen(function* () {
+	const cdp = yield* Effect.acquireRelease(Effect.tryPromise({
+		try: (signal) => closeLateAcquisition(signal, page.createCdpSession, (acquired) => acquired.detach()),
+		catch: (cause) => state.disconnected.value || isRemoteClosure(cause) ? expiredError() : protocolError("Creating the Cloudflare browser control session failed", cause)
+	}), (acquired) => closeWithWarning(acquired.detach, "Detaching the Cloudflare browser control session failed"), { interruptible: true });
+	const raw = yield* Effect.tryPromise({
+		try: () => cdp.send(command, parameters),
+		catch: (cause) => state.disconnected.value || isRemoteClosure(cause) ? expiredError() : protocolError("The Cloudflare browser control command failed", cause)
+	});
+	return yield* Schema.decodeUnknownEffect(output)(raw).pipe(Effect.mapError(() => protocolError(malformedMessage)));
+}));
+const makeHostService = (binding) => {
+	const closeSession = binding.closeSession;
+	const terminate = Effect.fn("BrowserRunInteractiveHost.terminate")(function* (sessionId, entries) {
+		const deadline = (yield* Clock.currentTimeMillis) + 1e4;
+		yield* closeSession(sessionId).pipe(Effect.interruptible, Effect.timeoutOrElse({
+			duration: "10 seconds",
+			orElse: () => Effect.fail(actionError("close"))
+		}));
+		const remaining = deadline - (yield* Clock.currentTimeMillis);
+		if (remaining <= 0) return yield* Effect.logWarning("Local browser teardown skipped after confirmed termination deadline");
+		yield* runTeardown(entries).pipe(Effect.flatMap((failures) => Effect.forEach(failures, (failure) => Effect.logWarning(failure.warning), { discard: true })), Effect.interruptible, Effect.timeout(`${remaining} millis`), Effect.catchCause(() => Effect.logWarning("Local browser teardown incomplete after confirmed termination")));
+	});
+	const closeAcquired = Effect.fn("BrowserRunInteractiveHost.closeAcquired")(function* (browser) {
+		const sessionId = yield* Effect.try({
+			try: browser.sessionId,
+			catch: () => actionError("close")
+		}).pipe(Effect.flatMap(Schema.decodeUnknownEffect(BrowserRunSessionId)), Effect.mapError(() => actionError("close")), Effect.onError(() => closeWithWarning(browser.close, "Closing an unidentified browser failed")));
+		yield* terminate(Redacted.make(sessionId), [closeEntry(browser.close, "Closing the local browser connection failed")]);
+	});
+	const open = Effect.fn("BrowserRunInteractiveHost.open")(function* (policy) {
+		const fixedPolicy = yield* snapshotPolicy(policy);
+		const startedAt = yield* Effect.clockWith((clock) => clock.currentTimeMillis);
+		const runCleanup = Effect.runPromiseWith(Context.make(Clock.Clock, yield* Clock.Clock));
+		const state = {
+			closed: { value: false },
+			disconnected: { value: false },
+			uncertain: { value: false },
+			violation: { value: void 0 },
+			pendingRequests: /* @__PURE__ */ new Set()
+		};
+		const lifecycle = { managedTeardownInstalled: false };
+		const closers = [];
+		const releaseBeforeManaged = (entry) => Effect.suspend(() => lifecycle.managedTeardownInstalled ? Effect.void : entry.close.pipe(Effect.catchCause(() => Effect.logWarning(entry.warning))));
+		const browser = yield* Effect.acquireRelease(withinDeadline(Effect.tryPromise({
+			try: (signal) => closeLateAcquisition(signal, () => binding.launch(keepAliveMillis(fixedPolicy)), (acquired) => runCleanup(closeAcquired(acquired))),
+			catch: (cause) => isCapacityRefusal(cause) ? InteractiveBrowserCapacityError.make({
+				implementation: browserRunInteractiveImplementation,
+				message: "Browser Run has no capacity for a new browser session"
+			}) : protocolError("Launching the Browser Run session failed", cause)
+		}), fixedPolicy, startedAt), (acquired) => {
+			state.disconnected.value = true;
+			return lifecycle.managedTeardownInstalled ? Effect.void : closeAcquired(acquired).pipe(Effect.catch(() => Effect.logWarning("Whole-browser cleanup remains unconfirmed")));
+		}, { interruptible: true });
+		closers.push(closeEntry(browser.close, "Closing the interactive browser failed"));
+		const disconnected = () => {
+			state.disconnected.value = true;
+		};
+		yield* Effect.acquireRelease(Effect.try({
+			try: () => browser.onDisconnected(disconnected),
+			catch: (cause) => protocolError("Installing the browser disconnect listener failed", cause)
+		}), () => releaseBeforeManaged(syncCloseEntry(() => browser.offDisconnected(disconnected), "Removing the browser disconnect listener failed")));
+		closers.push(syncCloseEntry(() => browser.offDisconnected(disconnected), "Removing the browser disconnect listener failed"));
+		if (!(yield* Effect.try({
+			try: browser.isConnected,
+			catch: (cause) => protocolError("Reading the Browser Run connection state failed", cause)
+		}))) {
+			state.disconnected.value = true;
+			return yield* expiredError();
+		}
+		const sessionIdValue = yield* Effect.try({
+			try: browser.sessionId,
+			catch: (cause) => protocolError("Reading the Browser Run session identity failed", cause)
+		}).pipe(Effect.flatMap((value) => Schema.decodeUnknownEffect(BrowserRunSessionId)(value).pipe(Effect.mapError(() => protocolError("The Browser Run session identity was malformed")))));
+		const context = yield* Effect.acquireRelease(withinDeadline(Effect.tryPromise({
+			try: (signal) => closeLateAcquisition(signal, browser.createContext, (acquired) => acquired.close()),
+			catch: (cause) => state.disconnected.value || isRemoteClosure(cause) ? expiredError() : protocolError("Creating the browser context failed", cause)
+		}), fixedPolicy, startedAt), (acquired) => releaseBeforeManaged(closeEntry(acquired.close, "Closing the interactive browser context failed")), { interruptible: true });
+		closers.push(closeEntry(context.close, "Closing the interactive browser context failed"));
+		const page = yield* Effect.acquireRelease(withinDeadline(Effect.tryPromise({
+			try: (signal) => closeLateAcquisition(signal, context.newPage, (acquired) => acquired.close()),
+			catch: (cause) => state.disconnected.value || isRemoteClosure(cause) ? expiredError() : protocolError("Creating the browser page failed", cause)
+		}), fixedPolicy, startedAt), (acquired) => releaseBeforeManaged(closeEntry(acquired.close, "Closing the interactive browser page failed")), { interruptible: true });
+		closers.push(closeEntry(page.close, "Closing the interactive browser page failed"));
+		yield* withinDeadline(Effect.tryPromise({
+			try: () => page.setBypassServiceWorker(true),
+			catch: (cause) => protocolError("Bypassing browser service workers failed", cause)
+		}), fixedPolicy, startedAt);
+		const requestListener = makeRequestListener(fixedPolicy, state);
+		yield* Effect.acquireRelease(Effect.try({
+			try: () => page.onRequest(requestListener),
+			catch: (cause) => protocolError("Installing the browser request listener failed", cause)
+		}), () => releaseBeforeManaged(syncCloseEntry(() => page.offRequest(requestListener), "Removing the browser request policy failed")));
+		closers.push(syncCloseEntry(() => page.offRequest(requestListener), "Removing the browser request policy failed"));
+		yield* withinDeadline(Effect.tryPromise({
+			try: () => page.setRequestInterception(true),
+			catch: (cause) => protocolError("Installing the browser request policy failed", cause)
+		}), fixedPolicy, startedAt);
+		yield* withinDeadline(awaitPendingRequests(state), fixedPolicy, startedAt);
+		const setupFailure = stateFailure(state);
+		if (setupFailure !== void 0) return yield* setupFailure;
+		const teardown = yield* Effect.uninterruptible(Effect.gen(function* () {
+			const cached = yield* Effect.cached(terminate(Redacted.make(sessionIdValue), closers));
+			lifecycle.managedTeardownInstalled = true;
+			yield* Effect.addFinalizer(() => Effect.uninterruptible(Effect.sync(() => {
+				state.closed.value = true;
+				state.disconnected.value = true;
+			}).pipe(Effect.andThen(cached), Effect.catch(() => Effect.logWarning("Whole-browser cleanup remains unconfirmed")))));
+			return cached;
+		}));
+		const close = Effect.uninterruptible(Effect.sync(() => {
+			state.closed.value = true;
+			state.disconnected.value = true;
+		}).pipe(Effect.andThen(teardown)));
+		const runtime = yield* makeHandle(page, fixedPolicy, startedAt, state, close);
+		const currentPagePreflight = decodeActionResult(page, fixedPolicy).pipe(Effect.asVoid);
+		const requestFitsSession = (requestedMillis) => remainingMillis(fixedPolicy, startedAt).pipe(Effect.flatMap((remaining) => remaining > 0 && requestedMillis <= remaining ? Effect.void : Effect.fail(policyError("The host browser request exceeds the remaining session time"))));
+		return {
+			handle: runtime.handle,
+			sessionId: Redacted.make(sessionIdValue),
+			resizeViewport: (viewport) => decodeViewport(viewport).pipe(Effect.flatMap((decoded) => runtime.run(Effect.tryPromise({
+				try: () => page.setViewport(decoded),
+				catch: (cause) => {
+					if (state.disconnected.value || isRemoteClosure(cause)) {
+						state.disconnected.value = true;
+						return expiredError();
+					}
+					return protocolError("Resizing the browser viewport failed", cause);
+				}
+			}), currentPagePreflight, false))),
+			getLiveView: (request) => Schema.decodeUnknownEffect(BrowserRunLiveViewRequest)(request).pipe(Effect.mapError(() => policyError("The Live View request is malformed")), Effect.flatMap((decoded) => runtime.run(cdpCommand(page, state, "Cloudflare.getLiveView", {
+				mode: decoded.mode,
+				expiresInMs: decoded.expiresInMs
+			}, LiveViewObservation, "Cloudflare returned a malformed Live View response").pipe(Effect.flatMap((observation) => Schema.decodeUnknownEffect(BrowserRunLiveViewResult)({ devtoolsFrontendUrl: Redacted.make(observation.devtoolsFrontendUrl) }).pipe(Effect.mapError(() => protocolError("Cloudflare returned a malformed Live View response"))))), currentPagePreflight.pipe(Effect.andThen(requestFitsSession(decoded.expiresInMs)))))),
+			handoff: (request) => Schema.decodeUnknownEffect(BrowserRunHandoffRequest)(request).pipe(Effect.mapError(() => policyError("The browser handoff request is malformed")), Effect.flatMap((decoded) => runtime.run(cdpCommand(page, state, "Cloudflare.handoff", {
+				instructions: decoded.instructions,
+				timeout: decoded.timeout
+			}, HandoffObservation, "Cloudflare returned a malformed browser handoff response").pipe(Effect.flatMap((observation) => Schema.decodeUnknownEffect(BrowserRunHandoffResult)({ handoffId: Redacted.make(observation.handoffId) }).pipe(Effect.mapError(() => protocolError("Cloudflare returned a malformed browser handoff response"))))), currentPagePreflight.pipe(Effect.andThen(requestFitsSession(decoded.timeout)))))),
+			getHandoffState: runtime.run(cdpCommand(page, state, "Cloudflare.getHandoffState", {}, HandoffStateObservation, "Cloudflare returned a malformed browser handoff state").pipe(Effect.flatMap((observation) => Schema.decodeUnknownEffect(BrowserRunHandoffState)({
+				active: observation.active,
+				...observation.handoffId === void 0 ? {} : { handoffId: Redacted.make(observation.handoffId) },
+				...observation.durationMs === void 0 ? {} : { durationMs: observation.durationMs }
+			}).pipe(Effect.mapError(() => protocolError("Cloudflare returned a malformed browser handoff state"))))), currentPagePreflight),
+			close
+		};
+	});
+	return BrowserRunInteractiveHost.of({
+		open,
+		closeSession,
+		cleanupSemantics: "confirmed-terminal"
+	});
+};
+/** Cloudflare host controls and private session identity for one scoped Browser Run pass. */
+const browserRunInteractiveHostLayer = () => Layer.effect(BrowserRunInteractiveHost, Effect.gen(function* () {
+	return makeHostService(yield* BrowserRunInteractiveBinding);
+}));
+/** Worker-only generic adapter; Cloudflare identity and controls remain host-only. */
+const browserRunInteractiveLayer = () => Layer.effect(InteractiveBrowser, Effect.gen(function* () {
+	const binding = yield* BrowserRunInteractiveBinding;
+	const host = makeHostService(binding);
+	return InteractiveBrowser.of({ open: (policy) => host.open(policy).pipe(Effect.map((session) => session.handle)) });
+}));
+const interactiveBindingLayer = (options) => BrowserRunInteractiveBinding.layer(options).pipe(Layer.provide(BrowserRunSessionLifecycle.layer(options)));
+/** Worker-only assembly; importing ordinary capture never loads Puppeteer. */
+const CloudflareInteractiveBrowser = {
+	/**
+	* Assemble binding, confirmed-session cleanup, and the generic browser service.
+	* HttpClient and construction errors remain visible. Opening a pass still requires
+	* an explicit policy and Scope; no browser is launched during Layer construction.
+	*/
+	layer: (options) => browserRunInteractiveLayer().pipe(Layer.provide(interactiveBindingLayer(options))),
+	/** Opt into private host controls instead of exposing them through the generic service. */
+	hostLayer: (options) => browserRunInteractiveHostLayer().pipe(Layer.provide(interactiveBindingLayer(options)))
+};
+//#endregion
+export { BrowserRunCleanupError, BrowserRunHandoffRequest, BrowserRunHandoffResult, BrowserRunHandoffState, BrowserRunInteractiveBinding, BrowserRunInteractiveHost, BrowserRunLiveViewRequest, BrowserRunLiveViewResult, BrowserRunSessionLifecycle, BrowserRunViewport, CloudflareInteractiveBrowser, browserRunInteractiveHostLayer, browserRunInteractiveImplementation, browserRunInteractiveLayer, isBrowserRunUndispatchedActionError };
+
+//# sourceMappingURL=InteractiveBrowser.mjs.map