@effect-agent/platform-cloudflare 0.1.0-beta.13 → 0.1.0-beta.131

package/dist/InteractiveBrowser-CxFT-Nwm.mjs

@@ -0,0 +1,1923 @@
+import { Cause, Clock, Context, Data, Duration, Effect, Encoding, ErrorReporter, Layer, Option, Predicate, Redacted, Schema, Scope, Semaphore, Stream } from "effect";
+import { PageScreenshotResult } from "effect-agent/page-screenshot";
+import { SandboxImplementation } from "effect-agent/sandbox";
+import { FetchHttpClient, HttpClient, HttpClientRequest } from "effect/unstable/http";
+import { BrowserActionResult, BrowserExpectedTargetState, BrowserFileSelectionResult, BrowserNavigationResult, BrowserScreenshotRequest, BrowserScrollRequest, BrowserSelectFileRequest, BrowserTextResult, InteractiveBrowser, InteractiveBrowserActionError, InteractiveBrowserBusyError, InteractiveBrowserCapacityError, InteractiveBrowserExpiredError, InteractiveBrowserLimitError, InteractiveBrowserPolicy, InteractiveBrowserPolicyDeniedError, InteractiveBrowserProtocolError, InteractiveBrowserTargetUrl, InteractiveBrowserUnsupportedError } from "effect-agent/interactive-browser";
+import puppeteer from "puppeteer-core/lib/esm/puppeteer/puppeteer-core-browser.js";
+//#region src/internal/browser-failure.ts
+/** Source-authored stages and classifications only; never retain SDK text or session capabilities. */
+var BrowserRunFailure = class extends Data.TaggedError("BrowserRunFailure") {
+	[ErrorReporter.severity] = "Error";
+};
+/** A public projection of an already reported private failure must not produce another issue. */
+const reportedBrowserError = (error) => Object.assign(error, { [ErrorReporter.ignore]: true });
+const reasonSchema = Schema.Literals([
+	"provider",
+	"timeout",
+	"malformed",
+	"configuration",
+	"authorization",
+	"rate-limited",
+	"pending"
+]);
+const statusSchema = Schema.Int.check(Schema.isBetween({
+	minimum: 100,
+	maximum: 599
+}));
+const failureNames = /* @__PURE__ */ new Set([
+	"TypeError",
+	"RangeError",
+	"SyntaxError",
+	"TimeoutError",
+	"SchemaError"
+]);
+const browserFailure = (operation, cause) => cause instanceof BrowserRunFailure ? cause : new BrowserRunFailure({
+	operation,
+	reason: Predicate.isObject(cause) && "reason" in cause && Schema.is(reasonSchema)(cause.reason) ? cause.reason : "provider",
+	...Predicate.isObject(cause) && "status" in cause && Schema.is(statusSchema)(cause.status) ? { status: cause.status } : {},
+	...Predicate.isObject(cause) && "cause" in cause && cause.cause instanceof BrowserRunFailure ? { cause: cause.cause } : Predicate.isObject(cause) && "name" in cause && typeof cause.name === "string" && failureNames.has(cause.name) ? { cause: { name: cause.name } } : {}
+});
+/** Keep mixed defects and interruptions distinct while discarding all foreign diagnostic content. */
+const reportBrowserCause = (operation, cause) => ErrorReporter.report(Cause.fromReasons(cause.reasons.filter((reason) => !Cause.isFailReason(reason) || !ErrorReporter.isIgnored(reason.error)).map((reason) => {
+	switch (reason._tag) {
+		case "Fail": return Cause.makeFailReason(browserFailure(operation, reason.error));
+		case "Die": return Cause.makeDieReason(browserFailure(operation, reason.defect));
+		case "Interrupt": return reason;
+	}
+})));
+//#endregion
+//#region src/internal/browser-binding.ts
+const Acquired = Schema.Struct({ sessionId: Schema.String.check(Schema.isUUID()) });
+const VersionReply = Schema.fromJsonString(Schema.Struct({
+	id: Schema.optionalKey(Schema.Int),
+	result: Schema.optionalKey(Schema.Unknown),
+	error: Schema.optionalKey(Schema.Unknown)
+}));
+const Version = Schema.Struct({
+	product: Schema.NonEmptyString,
+	protocolVersion: Schema.NonEmptyString
+});
+/** Native transport port shared by both scoped adapters; the Layer owns the foreign binding. */
+var BrowserRunBinding = class extends Context.Service()("@effect-agent/platform-cloudflare/internal/BrowserRunBinding") {
+	static layer(browser) {
+		const upgrade = async (sessionId, operation, signal) => {
+			const response = await browser.fetch(`https://browser-rendering.cloudflare.com/v1/devtools/browser/${sessionId}`, {
+				headers: { Upgrade: "websocket" },
+				...signal === void 0 ? {} : { signal }
+			});
+			if (response.status !== 101) {
+				const failure = new BrowserRunFailure({
+					operation,
+					reason: "provider",
+					status: response.status
+				});
+				try {
+					await response.body?.cancel();
+				} catch {}
+				throw failure;
+			}
+			const socket = response.webSocket;
+			if (socket === null) throw new BrowserRunFailure({
+				operation,
+				reason: "malformed"
+			});
+			return socket;
+		};
+		return Layer.succeed(this)({
+			acquire: async (keepAliveMillis, operation) => {
+				const response = await browser.fetch(`https://browser-rendering.cloudflare.com/v1/devtools/browser?keep_alive=${keepAliveMillis}&recording=false`, { method: "POST" });
+				if (response.status !== 200) {
+					const failure = new BrowserRunFailure({
+						operation,
+						reason: "provider",
+						status: response.status
+					});
+					try {
+						await response.body?.cancel();
+					} catch {}
+					throw failure;
+				}
+				return Schema.decodeUnknownSync(Acquired)(await response.json()).sessionId;
+			},
+			connect: (sessionId, operation, signal) => {
+				let socket;
+				let retired = false;
+				let closedByAbort = false;
+				let retirementFailure;
+				const disconnectOperation = operation === "session.connect" ? "session.disconnect" : "interactive.disconnect";
+				const transport = {
+					send: (message) => {
+						if (retired || socket === void 0) throw new BrowserRunFailure({
+							operation,
+							reason: "provider"
+						});
+						socket.send(message);
+					},
+					close: () => retireNow()
+				};
+				const onMessage = (event) => {
+					if (!retired) transport.onmessage?.(event.data);
+				};
+				const fence = () => {
+					if (retired) return;
+					retired = true;
+					const notify = transport.onclose;
+					transport.onmessage = void 0;
+					transport.onclose = void 0;
+					try {
+						notify?.();
+					} finally {
+						socket?.removeEventListener("message", onMessage);
+					}
+				};
+				const retireNow = () => {
+					try {
+						fence();
+					} catch (cause) {
+						retirementFailure ??= browserFailure(disconnectOperation, cause);
+					}
+					try {
+						if (socket !== void 0 && socket.readyState < WebSocket.CLOSED) socket.close();
+					} catch (cause) {
+						retirementFailure ??= browserFailure(disconnectOperation, cause);
+					}
+					if (retirementFailure !== void 0) throw retirementFailure;
+				};
+				const abort = () => {
+					closedByAbort = socket?.readyState === WebSocket.OPEN;
+					try {
+						retireNow();
+					} catch {}
+				};
+				signal?.addEventListener("abort", abort, { once: true });
+				return {
+					browser: (async () => {
+						try {
+							signal?.throwIfAborted();
+							socket = await upgrade(sessionId, operation, signal);
+							socket.accept();
+							if (retired || signal?.aborted) {
+								retireNow();
+								signal?.throwIfAborted();
+								throw new BrowserRunFailure({
+									operation,
+									reason: "provider"
+								});
+							}
+							socket.addEventListener("message", onMessage);
+							socket.addEventListener("close", () => {
+								try {
+									retireNow();
+								} catch (cause) {
+									retirementFailure ??= browserFailure(disconnectOperation, cause);
+								}
+							}, { once: true });
+							return await puppeteer.connect({
+								transport,
+								defaultViewport: null
+							});
+						} catch (cause) {
+							try {
+								retireNow();
+							} catch {}
+							const failure = browserFailure(operation, cause);
+							throw cause instanceof Error && signal?.aborted === true && (cause === signal.reason || closedByAbort && cause.name === "TargetCloseError") ? reportedBrowserError(failure) : failure;
+						} finally {
+							signal?.removeEventListener("abort", abort);
+						}
+					})(),
+					retire: Effect.callback((resume) => {
+						const connected = socket;
+						const onClose = () => resume(Effect.void);
+						try {
+							retireNow();
+							if (connected === void 0 || connected.readyState === WebSocket.CLOSED) resume(Effect.void);
+							else connected.addEventListener("close", onClose, { once: true });
+						} catch (cause) {
+							resume(Effect.fail(browserFailure(disconnectOperation, cause)));
+						}
+						return Effect.sync(() => connected?.removeEventListener("close", onClose));
+					})
+				};
+			},
+			keepAlive: Effect.fnUntraced(function* (sessionId) {
+				const operation = "session.keepAlive";
+				const runReport = Effect.runPromiseWith(yield* Effect.context());
+				const release = (socket) => Effect.sync(() => socket.close()).pipe(Effect.catchCause((cause) => reportBrowserCause(operation, cause)));
+				const socket = yield* Effect.acquireRelease(Effect.tryPromise({
+					try: async (signal) => {
+						let acquired;
+						try {
+							acquired = await upgrade(sessionId, operation, signal);
+							acquired.accept();
+							signal.throwIfAborted();
+							return acquired;
+						} catch (cause) {
+							if (acquired !== void 0) await runReport(release(acquired));
+							if (signal.aborted && cause !== signal.reason) await runReport(reportBrowserCause(operation, Cause.fail(cause)));
+							throw cause;
+						}
+					},
+					catch: (cause) => browserFailure(operation, cause)
+				}), release, { interruptible: true });
+				yield* Effect.callback((resume) => {
+					const finish = (result) => {
+						removeListeners();
+						resume(result);
+					};
+					const fail = (reason) => finish(Effect.fail(new BrowserRunFailure({
+						operation,
+						reason
+					})));
+					const onMessage = (event) => {
+						try {
+							if (typeof event.data !== "string" || event.data.length > 16384) {
+								fail("malformed");
+								return;
+							}
+							const reply = Schema.decodeSync(VersionReply)(event.data);
+							if (reply.id !== 1) return;
+							if (reply.error !== void 0) {
+								fail("provider");
+								return;
+							}
+							Schema.decodeUnknownSync(Version)(reply.result);
+							finish(Effect.void);
+						} catch {
+							fail("malformed");
+						}
+					};
+					const onClose = () => fail("provider");
+					const removeListeners = () => {
+						socket.removeEventListener("message", onMessage);
+						socket.removeEventListener("close", onClose);
+						socket.removeEventListener("error", onClose);
+					};
+					socket.addEventListener("message", onMessage);
+					socket.addEventListener("close", onClose);
+					socket.addEventListener("error", onClose);
+					try {
+						socket.send(JSON.stringify({
+							id: 1,
+							method: "Browser.getVersion"
+						}));
+					} catch (cause) {
+						finish(Effect.fail(browserFailure(operation, cause)));
+					}
+					return Effect.sync(removeListeners);
+				});
+			}, Effect.scoped)
+		});
+	}
+};
+//#endregion
+//#region src/internal/browser-file-selection.ts
+function setFileSelection(element, encoded, name, type) {
+	if (Reflect.get(element, "type") !== "file" || Reflect.get(element, "disabled") || Reflect.get(element, "webkitdirectory")) throw new Error("The target is not an enabled file input");
+	const bytes = Uint8Array.from(atob(encoded), (character) => character.charCodeAt(0));
+	const transfer = new (Reflect.get(globalThis, "DataTransfer"))();
+	transfer.items.add(new File([bytes], name, { type }));
+	Reflect.set(element, "files", transfer.files);
+	const selected = Reflect.get(element, "files");
+	if (selected?.length !== 1 || selected[0]?.size !== bytes.length || selected[0]?.name !== name || selected[0]?.type !== type) throw new Error("The input did not retain the selected file");
+	const dispatch = Reflect.get(element, "dispatchEvent");
+	Reflect.apply(dispatch, element, [new Event("input", { bubbles: true })]);
+	Reflect.apply(dispatch, element, [new Event("change", { bubbles: true })]);
+}
+const makeFileSelection = (page) => async (request, signal) => {
+	const encoded = Encoding.encodeBase64(request.bytes);
+	const session = request.target === "chooser" ? await page.createCDPSession() : void 0;
+	if (session !== void 0) try {
+		await session.send("Page.enable");
+		await session.send("Page.setInterceptFileChooserDialog", { enabled: true });
+	} catch (cause) {
+		await session.detach();
+		throw cause;
+	}
+	const select = async (element) => {
+		if (session === void 0) return element.evaluate(setFileSelection, encoded, request.fileName, request.mediaType);
+		let onOpened = () => {};
+		let onAbort = () => {};
+		let timer;
+		const opened = new Promise((resolve, reject) => {
+			onOpened = (event) => event.backendNodeId === void 0 ? reject(/* @__PURE__ */ new Error("The chooser has no file input")) : resolve(event.backendNodeId);
+			onAbort = () => reject(/* @__PURE__ */ new Error("File selection interrupted"));
+			session.on("Page.fileChooserOpened", onOpened);
+			signal.addEventListener("abort", onAbort, { once: true });
+			timer = setTimeout(() => reject(/* @__PURE__ */ new Error("No file chooser opened")), 5e3);
+			if (signal.aborted) onAbort();
+		});
+		try {
+			const [backendNodeId] = await Promise.all([opened, element.click()]);
+			if (signal.aborted) throw new Error("File selection interrupted");
+			const objectId = (await session.send("DOM.resolveNode", { backendNodeId })).object.objectId;
+			if (objectId === void 0) throw new Error("The chooser has no file input");
+			if (signal.aborted) throw new Error("File selection interrupted");
+			if ((await session.send("Runtime.callFunctionOn", {
+				objectId,
+				functionDeclaration: `function(encoded, name, type) { (${setFileSelection.toString()})(this, encoded, name, type); }`,
+				arguments: [
+					{ value: encoded },
+					{ value: request.fileName },
+					{ value: request.mediaType }
+				],
+				returnByValue: true
+			})).exceptionDetails !== void 0) throw new Error("The chooser did not select the file");
+		} finally {
+			clearTimeout(timer);
+			session.off("Page.fileChooserOpened", onOpened);
+			signal.removeEventListener("abort", onAbort);
+		}
+	};
+	return {
+		validate: async (element) => request.target === "chooser" || await element.evaluate((input) => Reflect.get(input, "type") === "file" && !Reflect.get(input, "disabled") && !Reflect.get(input, "webkitdirectory")),
+		select,
+		close: async () => {
+			if (session !== void 0) try {
+				await session.send("Page.setInterceptFileChooserDialog", { enabled: false });
+			} finally {
+				await session.detach();
+			}
+		}
+	};
+};
+//#endregion
+//#region src/internal/browser-session-lifecycle.ts
+var BrowserRunCleanupError = class extends Schema.TaggedError()("BrowserRunCleanupError", {
+	reason: Schema.Literals([
+		"configuration",
+		"authorization",
+		"rate-limited",
+		"provider",
+		"malformed",
+		"timeout",
+		"pending"
+	]),
+	status: Schema.optionalKey(Schema.Int),
+	cause: Schema.optionalKey(Schema.Defect())
+}) {};
+const Identity = Schema.String.check(Schema.isUUID());
+const Account = Schema.String.check(Schema.isPattern(/^[a-f0-9]{32}$/));
+const Closed = Schema.Struct({ status: Schema.Literals(["closing", "closed"]) });
+const Metadata = Schema.Struct({
+	sessionId: Identity,
+	endTime: Schema.optionalKey(Schema.Finite)
+});
+const Absent = Schema.Struct({ error: Schema.Literal("Session not found") });
+var BrowserRunSessionLifecycle = class extends Context.Service()("@effect-agent/platform-cloudflare/BrowserRunSessionLifecycle") {
+	static layer(options) {
+		return Layer.effect(this, Effect.gen(function* () {
+			if (!Schema.is(Account)(options.accountId) || Redacted.value(options.apiToken).length === 0) return yield* new BrowserRunCleanupError({ reason: "configuration" });
+			const client = yield* HttpClient.HttpClient;
+			const request = Effect.fn("BrowserRunSessionLifecycle.request")(function* (method, sessionId) {
+				const path = method === "DELETE" ? "browser" : "session";
+				const response = yield* client.execute(HttpClientRequest.make(method)(`https://api.cloudflare.com/client/v4/accounts/${options.accountId}/browser-rendering/devtools/${path}/${sessionId}`).pipe(HttpClientRequest.bearerToken(options.apiToken))).pipe(Effect.provideService(FetchHttpClient.RequestInit, { redirect: "manual" }), Effect.mapError((cause) => new BrowserRunCleanupError({
+					reason: "provider",
+					cause: browserFailure("browser.close.request", cause)
+				})));
+				if (response.status === 401 || response.status === 403) return yield* new BrowserRunCleanupError({
+					reason: "authorization",
+					status: response.status
+				});
+				if (response.status === 429) return yield* new BrowserRunCleanupError({
+					reason: "rate-limited",
+					status: response.status
+				});
+				if (response.status !== 200 && response.status !== 404) return yield* new BrowserRunCleanupError({
+					reason: "provider",
+					status: response.status
+				});
+				if (response.headers["content-type"]?.split(";", 1)[0]?.trim() !== "application/json") return yield* new BrowserRunCleanupError({ reason: "malformed" });
+				const bytes = yield* Stream.runFoldEffect(response.stream, () => /* @__PURE__ */ new Uint8Array(), (body, chunk) => {
+					if (body.byteLength + chunk.byteLength > 16384) return Effect.fail(new BrowserRunCleanupError({ reason: "malformed" }));
+					const combined = new Uint8Array(body.byteLength + chunk.byteLength);
+					combined.set(body);
+					combined.set(chunk, body.byteLength);
+					return Effect.succeed(combined);
+				}).pipe(Effect.mapError((cause) => new BrowserRunCleanupError({
+					reason: "malformed",
+					cause: browserFailure("browser.close.response", cause)
+				})));
+				const body = yield* Effect.try({
+					try: () => new TextDecoder("utf-8", {
+						fatal: true,
+						ignoreBOM: false
+					}).decode(bytes),
+					catch: (cause) => new BrowserRunCleanupError({
+						reason: "malformed",
+						cause: browserFailure("browser.close.decode", cause)
+					})
+				});
+				if (response.status === 404) {
+					const absent = Schema.decodeOption(Schema.fromJsonString(Absent))(body, { onExcessProperty: "error" });
+					if (Option.isSome(absent)) return true;
+					return yield* new BrowserRunCleanupError({ reason: "malformed" });
+				}
+				if (method === "DELETE") return (yield* Schema.decodeEffect(Schema.fromJsonString(Closed))(body).pipe(Effect.mapError((cause) => new BrowserRunCleanupError({
+					reason: "malformed",
+					cause: browserFailure("browser.close.response", cause)
+				})))).status === "closed";
+				const result = yield* Schema.decodeEffect(Schema.fromJsonString(Metadata))(body).pipe(Effect.mapError((cause) => new BrowserRunCleanupError({
+					reason: "malformed",
+					cause: browserFailure("browser.close.response", cause)
+				})));
+				if (result.sessionId !== sessionId) return yield* new BrowserRunCleanupError({ reason: "malformed" });
+				return result.endTime !== void 0 && result.endTime > 0;
+			});
+			return { close: Effect.fn("BrowserRunSessionLifecycle.close")(function* (sessionId) {
+				const id = yield* Schema.decodeEffect(Identity)(Redacted.value(sessionId)).pipe(Effect.mapError(() => new BrowserRunCleanupError({ reason: "configuration" })));
+				if (yield* request("DELETE", id)) return;
+				for (let read = 0; read < 2; read++) if (yield* request("GET", id)) return;
+				return yield* new BrowserRunCleanupError({ reason: "pending" });
+			}, Effect.timeoutOrElse({
+				duration: "10 seconds",
+				orElse: () => Effect.fail(new BrowserRunCleanupError({ reason: "timeout" }))
+			}), Effect.withTracerEnabled(false)) };
+		}));
+	}
+};
+//#endregion
+//#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,
+	inputMillis: Schema.optionalKey(Schema.Finite),
+	observationMillis: Schema.optionalKey(Schema.Finite)
+});
+const BrowserRunPageObservation = Schema.fromJsonString(Schema.Struct({
+	documentId: Schema.NonEmptyString,
+	pageText: BoundedRemoteText,
+	selectorMatchCount: Schema.Natural,
+	controlsTruncated: Schema.Boolean,
+	controls: Schema.Array(Schema.Struct({
+		nodeId: Schema.NonEmptyString,
+		selector: BoundedRemoteText,
+		...BrowserExpectedTargetState.fields
+	})).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.decodeEffect(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 allocation and connection transport. */
+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 binding = yield* BrowserRunBinding;
+			const viewport = options.viewport === void 0 ? void 0 : yield* decodeViewport(options.viewport);
+			return {
+				acquire: async (keepAliveMillis) => binding.acquire(keepAliveMillis, "interactive.acquire"),
+				connect: async (sessionId, signal) => makeProductionBrowser(await binding.connect(sessionId, "interactive.connect", signal).browser, sessionId, viewport),
+				closeSession: (sessionId) => lifecycle.close(sessionId).pipe(Effect.mapError((cause) => actionError("close", cause)))
+			};
+		})).pipe(Layer.provide(BrowserRunBinding.layer(options.browser)));
+	}
+};
+/** Private target identity; never include this checkpoint in model-visible records. */
+var BrowserRunPageIdentity = class extends Schema.Class("BrowserRunPageIdentity")({
+	contextId: BrowserRunSessionId,
+	targetId: BrowserRunSessionId
+}) {};
+/** Host-owned recovery data. Persist with the application's input receipts and ownership fence. */
+var BrowserRunInteractiveCheckpoint = class extends Schema.Class("BrowserRunInteractiveCheckpoint")({
+	sessionId: Schema.RedactedFromValue(BrowserRunSessionId),
+	page: BrowserRunPageIdentity,
+	policy: InteractiveBrowserPolicy,
+	startedAt: Schema.Natural,
+	consumedActions: Schema.Natural.check(Schema.isLessThanOrEqualTo(1e3)),
+	inputState: Schema.Literals([
+		"idle",
+		"running",
+		"unknown"
+	])
+}) {};
+/** 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);
+};
+/** Runs entirely in the page realm for both observations and the last bound-element guard. */
+const observePage = (target, requestedSelector, maximum, maximumControls, input) => {
+	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 = target ?? (matches === void 0 || matches === null ? Reflect.get(pageDocument, "body") : Reflect.get(matches, 0));
+	if (target !== void 0 && Reflect.get(target, "isConnected") !== true) return { _tag: "MissingElement" };
+	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 identityKey = Symbol.for("@effect-agent/browser-observation");
+	let identity = Reflect.get(globalThis, identityKey);
+	if (identity === void 0 || identity.document !== pageDocument) {
+		identity = {
+			document: pageDocument,
+			documentId: crypto.getRandomValues(/* @__PURE__ */ new Uint32Array(4)).join("-"),
+			nodes: /* @__PURE__ */ new WeakMap()
+		};
+		Reflect.set(globalThis, identityKey, identity);
+	}
+	const controls = candidates.slice(0, maximumControls).map((candidate) => {
+		let nodeId = identity.nodes.get(candidate);
+		if (nodeId === void 0) {
+			nodeId = crypto.getRandomValues(/* @__PURE__ */ new Uint32Array(4)).join("-");
+			identity.nodes.set(candidate, nodeId);
+		}
+		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 {
+			nodeId,
+			...inputType === "" ? {} : { inputType: inputType.slice(0, 64) },
+			selector: selectorFor(candidate),
+			kind: (tagName === "label" ? `label:${inputType || "control"}` : tagName === "input" ? `input:${inputType || "text"}` : role !== "" ? `role:${role}` : tagName).slice(0, 128),
+			...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"]) } : {}
+		};
+	});
+	if (input !== void 0) {
+		const expected = input.expectedTarget;
+		const control = controls.find((candidate) => candidate.nodeId === expected.nodeId);
+		if (target === void 0 || identity.documentId !== expected.documentId || identity.nodes.get(target) !== expected.nodeId || control === void 0 || expected.state !== void 0 && [
+			"kind",
+			"inputType",
+			"label",
+			"checked",
+			"selected",
+			"disabled",
+			"required",
+			"valid",
+			"formValid"
+		].some((field) => control[field] !== expected.state?.[field]) || Reflect.get(target, "isConnected") !== true) return { _tag: "MissingElement" };
+		if (expected.scopeSelector !== void 0) {
+			let roots;
+			try {
+				roots = Reflect.apply(Reflect.get(pageDocument, "querySelectorAll"), pageDocument, [expected.scopeSelector]);
+			} catch {
+				return { _tag: "MissingElement" };
+			}
+			if (typeof roots !== "object" || roots === null) return { _tag: "MissingElement" };
+			const root = Reflect.get(roots, 0);
+			if (Reflect.get(roots, "length") !== 1 || root === void 0 || !Reflect.apply(Reflect.get(root, "contains"), root, [target])) return { _tag: "MissingElement" };
+		}
+		if (input.mode === "click") {
+			const prototype = Reflect.get(Reflect.get(globalThis, "HTMLElement"), "prototype");
+			Reflect.apply(Reflect.get(prototype, "click"), target, []);
+		} else {
+			let prototype = Reflect.getPrototypeOf(target);
+			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 || input.value === void 0) return { _tag: "MissingElement" };
+			Reflect.apply(setValue, target, [input.value]);
+			const dispatchEvent = Reflect.get(target, "dispatchEvent");
+			Reflect.apply(dispatchEvent, target, [new Event("input", { bubbles: true })]);
+			Reflect.apply(dispatchEvent, target, [new Event("change", { bubbles: true })]);
+		}
+		return {
+			_tag: "Text",
+			text: ""
+		};
+	}
+	const text = JSON.stringify({
+		documentId: identity.documentId,
+		pageText,
+		selectorMatchCount,
+		controls,
+		controlsTruncated
+	});
+	const observed = new TextEncoder().encode(text).byteLength;
+	return observed > maximum ? {
+		_tag: "OverLimit",
+		observed
+	} : {
+		_tag: "Text",
+		text
+	};
+};
+const runObservedPageAction = async (page, selector, signal, onDispatch, action, validate, onComplete) => {
+	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 {
+		if (validate !== void 0 && !await validate(matches[0])) throw new BrowserRunActionUndispatched(1);
+		tracker = makeActionRequestTracker(page, signal);
+		if (signal.aborted) throw new BrowserRunActionUndispatched(1);
+		onDispatch();
+		const inputStarted = performance.now();
+		await action(matches[0]);
+		const inputFinished = performance.now();
+		onComplete?.();
+		tracker.markActionSettled();
+		const network = await tracker.wait();
+		const after = signal.aborted ? void 0 : await readActionTargetAfter(page, selector);
+		return {
+			before,
+			inputMillis: Math.max(0, inputFinished - inputStarted),
+			observationMillis: Math.max(0, performance.now() - inputFinished),
+			...after === void 0 ? {} : { after },
+			afterUnavailable: after === void 0,
+			network
+		};
+	} finally {
+		tracker?.close();
+		signal.removeEventListener("abort", onAbort);
+		await dispose();
+	}
+};
+const guardedPageInput = async (element, expectedTarget, mode, value) => {
+	if (Schema.decodeUnknownSync(TextObservation)(await element.evaluate(observePage, void 0, 262144, 1, {
+		mode,
+		expectedTarget,
+		...value === void 0 ? {} : { value }
+	}))._tag !== "Text") throw new BrowserRunActionUndispatched(1);
+};
+const makeProductionPage = (page) => {
+	const prepareFileSelection = makeFileSelection(page);
+	const listeners = /* @__PURE__ */ new Map();
+	return {
+		identity: async () => {
+			const cdp = await page.createCDPSession();
+			try {
+				const { targetInfo } = await cdp.send("Target.getTargetInfo");
+				return Schema.decodeUnknownSync(BrowserRunPageIdentity)({
+					contextId: targetInfo.browserContextId,
+					targetId: targetInfo.targetId
+				});
+			} finally {
+				await cdp.detach();
+			}
+		},
+		close: async () => {
+			if (!page.browser().isConnected()) return;
+			try {
+				await page.close();
+			} catch (cause) {
+				if (!isRemoteClosure(cause)) throw cause;
+			}
+		},
+		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(observePage, void 0, selector, maximumBytes, MAX_OBSERVED_CONTROLS));
+			if (observation._tag === "Text") Schema.decodeSync(BrowserRunPageObservation)(observation.text);
+			return observation;
+		},
+		fill: (selector, value, signal, onDispatch, onComplete, expectedTarget) => runObservedPageAction(page, selector, signal, onDispatch, (element) => expectedTarget !== void 0 ? guardedPageInput(element, expectedTarget, "fill", value) : 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), void 0, onComplete),
+		click: (selector, signal, onDispatch, onComplete, expectedTarget) => runObservedPageAction(page, selector, signal, onDispatch, (element) => expectedTarget === void 0 ? element.click() : guardedPageInput(element, expectedTarget, "click"), void 0, onComplete),
+		selectFile: async (request, signal, onDispatch, onComplete) => {
+			const selection = await prepareFileSelection(request, signal);
+			try {
+				return await runObservedPageAction(page, request.selector, signal, onDispatch, selection.select, selection.validate, onComplete);
+			} finally {
+				await selection.close();
+			}
+		},
+		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, viewport) => ({
+	newPage: async () => {
+		const page = await context.newPage();
+		if (viewport !== void 0) await page.setViewport(viewport);
+		return makeProductionPage(page);
+	},
+	close: async () => {
+		if (!context.browser().isConnected()) return;
+		try {
+			await context.close();
+		} catch (cause) {
+			if (!isRemoteClosure(cause)) throw cause;
+		}
+	}
+});
+const makeProductionBrowser = (browser, sessionId, viewport) => ({
+	detach: () => browser.disconnect(),
+	reattach: async (identity) => {
+		const context = browser.browserContexts().find((candidate) => candidate.id === identity.contextId);
+		if (context === void 0) return void 0;
+		const pages = await context.pages();
+		if (pages.length > 64) throw new Error("The browser target inventory exceeds its bound");
+		for (const candidate of pages) {
+			const page = makeProductionPage(candidate);
+			if ((await page.identity?.())?.targetId === identity.targetId) return {
+				context: makeProductionContext(context),
+				page
+			};
+		}
+	},
+	createContext: async () => makeProductionContext(await browser.createBrowserContext(), viewport),
+	close: async () => {
+		if (!browser.isConnected()) return;
+		try {
+			await browser.close();
+		} catch (cause) {
+			if (!isRemoteClosure(cause)) throw cause;
+		}
+	},
+	sessionId: () => 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 failReportedProtocol = (operation, error, evidence = error.evidence) => reportBrowserCause(operation, Cause.fail(error)).pipe(Effect.andThen(Effect.fail(reportedBrowserError(InteractiveBrowserProtocolError.make({
+	implementation: browserRunInteractiveImplementation,
+	message: error.message,
+	...evidence === void 0 ? {} : { evidence }
+})))));
+const actionError = (operation, cause, evidence) => InteractiveBrowserActionError.make({
+	implementation: browserRunInteractiveImplementation,
+	operation,
+	...evidence === void 0 ? {} : { evidence },
+	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`,
+	evidence: {
+		stage: "preparation",
+		dispatch: "not-dispatched",
+		session: "attached"
+	}
+});
+/** 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.evidence?.dispatch === "not-dispatched";
+const policyError = (message) => InteractiveBrowserPolicyDeniedError.make({
+	implementation: browserRunInteractiveImplementation,
+	message
+});
+const expiredError = (session = "lost") => InteractiveBrowserExpiredError.make({
+	implementation: browserRunInteractiveImplementation,
+	message: "The remote browser is no longer usable",
+	evidence: {
+		stage: "preparation",
+		dispatch: "not-dispatched",
+		session
+	}
+});
+const causeText = (cause) => {
+	if (cause instanceof Error) return cause.message.slice(0, 8e3);
+	return String(cause).slice(0, 8e3);
+};
+const isCapacityRefusal = (cause) => cause instanceof BrowserRunFailure && cause.status === 429;
+const isRemoteClosure = (cause) => /target closed|browser.*closed|session.*closed|connection.*closed|not connected|websocket.*closed/i.test(causeText(cause));
+const inputMayStillRun = (cause) => isRemoteClosure(cause) || cause instanceof Error && cause.name === "TimeoutError" || cause instanceof BrowserRunFailure && cause.reason === "timeout";
+const snapshotPolicy = Effect.fn("BrowserRunInteractive.snapshotPolicy")(function* (input) {
+	const decoded = yield* Schema.decodeEffect(InteractiveBrowserPolicy, { onExcessProperty: "error" })(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));
+var LateBrowserAcquisition = class extends Error {};
+const closeLateAcquisition = async (signal, acquire, close) => {
+	const acquired = await acquire();
+	if (!signal.aborted) return acquired;
+	try {
+		await close(acquired);
+	} catch {}
+	throw new LateBrowserAcquisition("The interrupted browser acquisition completed late");
+};
+const closeWithWarning = (close, warning) => Effect.tryPromise({
+	try: close,
+	catch: (cause) => protocolError(warning, cause)
+}).pipe(Effect.timeoutOrElse({
+	duration: Duration.millis(CLEANUP_STEP_TIMEOUT_MILLIS),
+	orElse: () => Effect.fail(protocolError(warning))
+}), Effect.catchCause((cause) => reportBrowserCause("interactive.cleanup", cause).pipe(Effect.andThen(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 trackPendingInput = (state, pending) => {
+	state.pendingInputs.add(pending);
+	pending.then(() => state.pendingInputs.delete(pending), (cause) => {
+		state.pendingInputs.delete(pending);
+		if (state.disconnected.value || inputMayStillRun(cause)) state.uncertain.value = true;
+		if (isRemoteClosure(cause)) state.disconnected.value = true;
+	});
+	return pending;
+};
+const makeHostInputObserver = Effect.fnUntraced(function* (state, operation) {
+	const reporterContext = yield* Effect.context();
+	return (pending, signal) => {
+		pending.then(void 0, (cause) => {
+			if (signal.aborted) return Effect.runPromiseWith(reporterContext)(reportBrowserCause(operation, Cause.fail(cause)));
+		});
+		return trackPendingInput(state, pending);
+	};
+});
+const stateFailure = (state) => {
+	if (state.violation.value !== void 0) return state.violation.value;
+	if (state.closed.value) return expiredError();
+	if (state.disconnected.value) return expiredError("disconnected");
+};
+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 (cause) {
+		state.violation.value = protocolError("Resolving an intercepted browser request failed", cause);
+		return;
+	}
+	const observed = settlement.catch((cause) => {
+		state.violation.value = protocolError("Resolving an intercepted browser request failed", cause);
+	}).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);
+	let currentOperation;
+	let generation = 0;
+	let evidence = {
+		stage: "preparation",
+		dispatch: "not-dispatched",
+		session: "attached"
+	};
+	const reporterContext = yield* Effect.context();
+	const remote = (operation, evaluate, observed = false) => Effect.suspend(() => {
+		currentOperation = operation;
+		const mutating = operation !== "read-text" && operation !== "screenshot";
+		const currentGeneration = ++generation;
+		evidence = {
+			stage: observed ? "preparation" : mutating ? "input" : "observation",
+			dispatch: observed || !mutating ? "not-dispatched" : "running",
+			session: "attached"
+		};
+		return Effect.tryPromise({
+			try: (signal) => {
+				const pending = evaluate(signal);
+				if (mutating) trackPendingInput(state, pending);
+				pending.then(() => {
+					if (mutating && generation === currentGeneration) evidence = {
+						...evidence,
+						stage: "observation",
+						dispatch: "completed"
+					};
+				}, (cause) => {
+					if (state.disconnected.value || isRemoteClosure(cause)) {
+						state.disconnected.value = true;
+						if (mutating) state.uncertain.value = true;
+					}
+					if (generation === currentGeneration && evidence.dispatch === "running") evidence = {
+						...evidence,
+						dispatch: "unknown"
+					};
+					if (signal.aborted && !(cause instanceof BrowserRunActionUndispatched)) Effect.runPromiseWith(reporterContext)(reportBrowserCause("interactive.input.late", Cause.fail(cause)));
+				});
+				return pending;
+			},
+			catch: (cause) => new BrowserRunRemoteFailure(cause)
+		}).pipe(Effect.catch((failure) => {
+			if (failure.cause instanceof BrowserRunActionUndispatched) return Effect.logInfo("Browser interactive action was not dispatched").pipe(Effect.annotateLogs({
+				"browser.action": operation,
+				"browser.selector_match_count": failure.cause.matchCount
+			}), Effect.andThen(Effect.fail(undispatchedActionError(operation))));
+			if (mutating && inputMayStillRun(failure.cause)) state.uncertain.value = true;
+			if (isRemoteClosure(failure.cause)) {
+				state.disconnected.value = true;
+				if (mutating) state.uncertain.value = true;
+			}
+			evidence = {
+				...evidence,
+				dispatch: evidence.dispatch === "running" ? "unknown" : evidence.dispatch,
+				session: state.disconnected.value ? "disconnected" : "attached"
+			};
+			return reportBrowserCause(`interactive.${operation}.${evidence.stage}.${evidence.dispatch}`, Cause.fail(failure.cause)).pipe(Effect.andThen(Effect.fail(reportedBrowserError(actionError(operation, void 0, evidence)))));
+		}));
+	});
+	const observedAction = (operation, evaluate) => remote(operation, (signal) => {
+		const observedGeneration = generation;
+		return evaluate(signal, () => {
+			if (generation === observedGeneration) evidence = {
+				...evidence,
+				stage: "input",
+				dispatch: "running"
+			};
+		}, () => {
+			if (generation === observedGeneration) evidence = {
+				...evidence,
+				stage: "observation",
+				dispatch: "completed"
+			};
+		});
+	}, true).pipe(Effect.onInterrupt(() => Effect.logWarning("Browser interactive action interrupted").pipe(Effect.annotateLogs({
+		"browser.action": operation,
+		"browser.action_dispatched": evidence.dispatch !== "not-dispatched",
+		"browser.action_outcome_unknown": evidence.dispatch === "running" || evidence.dispatch === "unknown"
+	}))));
+	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.input_millis": observation.inputMillis,
+		"browser.observation_millis": observation.observationMillis,
+		"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, mutating = true) => permits.withPermitsIfAvailable(1)(Effect.gen(function* () {
+		const unavailable = stateFailure(state);
+		if (unavailable !== void 0) {
+			if (unavailable._tag === "InteractiveBrowserProtocolError") {
+				yield* reportBrowserCause("interactive.policy", Cause.fail(unavailable));
+				const safe = reportedBrowserError(InteractiveBrowserProtocolError.make({
+					implementation: browserRunInteractiveImplementation,
+					message: unavailable.message,
+					evidence: unavailable.evidence ?? {
+						stage: "preparation",
+						dispatch: "not-dispatched",
+						session: "attached"
+					}
+				}));
+				if (state.violation.value === unavailable) state.violation.value = safe;
+				return yield* safe;
+			}
+			return yield* unavailable;
+		}
+		if (mutating && (state.uncertain.value || state.pendingInputs.size > 0)) return yield* InteractiveBrowserBusyError.make({
+			implementation: browserRunInteractiveImplementation,
+			message: "Earlier browser input has not been proven stopped"
+		});
+		currentOperation = void 0;
+		generation++;
+		yield* preflight;
+		if (consumeAction) {
+			const admitted = {
+				allowed: state.actions.value < policy.maxActions,
+				observed: state.actions.value + 1
+			};
+			if (admitted.allowed) state.actions.value++;
+			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.flatMap((result) => awaitPendingRequests(state).pipe(Effect.andThen(Effect.suspend(() => {
+			const failure = stateFailure(state);
+			return failure === void 0 ? Effect.succeed(result) : Effect.fail(failure);
+		})))));
+		return yield* withinDeadline(completed, policy, startedAt).pipe(Effect.mapError((error) => currentOperation === void 0 ? error : error._tag === "InteractiveBrowserLimitError" ? InteractiveBrowserLimitError.make({
+			implementation: error.implementation,
+			limit: error.limit,
+			maximum: error.maximum,
+			observed: error.observed,
+			message: error.message,
+			evidence
+		}) : error._tag === "InteractiveBrowserPolicyDeniedError" ? InteractiveBrowserPolicyDeniedError.make({
+			implementation: error.implementation,
+			message: error.message,
+			evidence
+		}) : error), Effect.catchIf((error) => currentOperation !== void 0 && error._tag !== "InteractiveBrowserActionError" && error._tag !== "InteractiveBrowserLimitError" && error._tag !== "InteractiveBrowserPolicyDeniedError" && error._tag !== "InteractiveBrowserExpiredError", (error) => {
+			const safe = reportedBrowserError(error._tag === "InteractiveBrowserProtocolError" ? InteractiveBrowserProtocolError.make({
+				implementation: browserRunInteractiveImplementation,
+				message: error.message,
+				evidence
+			}) : actionError(currentOperation ?? "read-text", void 0, evidence));
+			if (state.violation.value === error) state.violation.value = safe;
+			return reportBrowserCause(`interactive.${currentOperation}.observation`, Cause.fail(error)).pipe(Effect.andThen(Effect.fail(safe)));
+		}));
+	})).pipe(Effect.flatMap(Effect.fromOption(() => 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", void 0, evidence);
+				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.decodeEffect(BrowserTextResult)({ text: observation.text }).pipe(Effect.mapError((cause) => protocolError("The browser returned malformed page text", cause)));
+			}), Effect.void, true, false),
+			fill: (request) => run(Effect.gen(function* () {
+				const observation = yield* observedAction("fill", (signal, onDispatch, onComplete) => page.fill(request.selector, request.value, signal, onDispatch, onComplete, request.expectedTarget)).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, onComplete) => page.click(request.selector, signal, onDispatch, onComplete, request.expectedTarget)).pipe(Effect.flatMap(decodeActionObservation));
+				yield* logActionObservation("click", observation);
+				return yield* decodeActionResult(page, policy);
+			})),
+			selectFile: (request) => Schema.decodeEffect(BrowserSelectFileRequest)(request).pipe(Effect.mapError(() => policyError("The browser file selection request is malformed")), Effect.flatMap((decoded) => run(Effect.gen(function* () {
+				const observation = yield* observedAction("select-file", (signal, onDispatch, onComplete) => page.selectFile(decoded, signal, onDispatch, onComplete)).pipe(Effect.flatMap(decodeActionObservation));
+				yield* logActionObservation("select-file", observation);
+				const result = yield* decodeActionResult(page, policy);
+				return BrowserFileSelectionResult.make({
+					url: result.url,
+					fileName: decoded.fileName,
+					mediaType: decoded.mediaType,
+					size: decoded.bytes.length
+				});
+			})))),
+			screenshot: (request) => Schema.decodeEffect(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.decodeEffect(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), true, false))),
+			scroll: (request) => Schema.decodeEffect(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 cleanupContext = yield* Effect.context();
+	const observeInput = yield* makeHostInputObserver(state, "interactive.control.late");
+	const cdp = yield* Effect.acquireRelease(Effect.tryPromise({
+		try: (signal) => {
+			const pending = closeLateAcquisition(signal, page.createCdpSession, (acquired) => Effect.runPromiseWith(cleanupContext)(Effect.tryPromise({
+				try: () => acquired.detach(),
+				catch: (cause) => actionError("close", cause)
+			}).pipe(Effect.tapCause((cause) => reportBrowserCause("interactive.lateDetach", cause)))));
+			pending.then(void 0, (cause) => {
+				if (signal.aborted && !(cause instanceof LateBrowserAcquisition)) return Effect.runPromiseWith(cleanupContext)(reportBrowserCause("interactive.connect", Cause.fail(cause)));
+			});
+			return pending;
+		},
+		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: (signal) => {
+			const pending = cdp.send(command, parameters);
+			return command === "Cloudflare.getHandoffState" ? pending : observeInput(pending, signal);
+		},
+		catch: (cause) => state.disconnected.value || isRemoteClosure(cause) ? expiredError() : protocolError("The Cloudflare browser control command failed", cause)
+	});
+	return yield* Schema.decodeUnknownEffect(output)(raw).pipe(Effect.catch((error) => reportBrowserCause("interactive.command.decode", Cause.fail(error)).pipe(Effect.andThen(Effect.fail(reportedBrowserError(protocolError(malformedMessage)))))));
+})).pipe(Effect.catchTag("InteractiveBrowserProtocolError", (error) => failReportedProtocol("interactive.control", error)));
+const makeHostService = (binding) => {
+	const owners = /* @__PURE__ */ new Map();
+	const closeSession = (sessionId) => binding.closeSession(sessionId).pipe(Effect.tap(() => Effect.sync(() => {
+		owners.delete(Redacted.value(sessionId));
+	})));
+	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) => reportBrowserCause("interactive.cleanup", Cause.fail(failure.error)).pipe(Effect.andThen(Effect.logWarning(failure.warning))), { discard: true })), Effect.interruptible, Effect.timeout(`${remaining} millis`), Effect.catchCause((cause) => reportBrowserCause("interactive.cleanup", cause).pipe(Effect.andThen(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: (cause) => actionError("close", cause)
+		}).pipe(Effect.flatMap(Schema.decodeUnknownEffect(BrowserRunSessionId)), Effect.mapError((cause) => actionError("close", cause)), 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 acquire = Effect.fn("BrowserRunInteractiveHost.acquire")(function* (policy, resume, pendingInput = false) {
+		const scope = yield* Scope.Scope;
+		const fixedPolicy = yield* snapshotPolicy(policy);
+		const startedAt = resume?.startedAt ?? (yield* Clock.currentTimeMillis);
+		const runCleanup = (effect) => Effect.runPromiseWith(cleanupContext)(effect.pipe(Effect.tapCause((cause) => reportBrowserCause("interactive.lateCleanup", cause))));
+		const cleanupContext = yield* Effect.context();
+		const observeLate = (signal, pending) => {
+			pending.then(void 0, (cause) => {
+				if (signal.aborted && !(cause instanceof LateBrowserAcquisition)) return runCleanup(reportBrowserCause("interactive.acquire", Cause.fail(cause)));
+			});
+			return pending;
+		};
+		const state = {
+			closed: { value: false },
+			disconnected: { value: false },
+			uncertain: { value: pendingInput || resume !== void 0 && resume.inputState !== "idle" },
+			pendingInputs: /* @__PURE__ */ new Set(),
+			actions: { value: resume?.consumedActions ?? 0 },
+			violation: { value: void 0 },
+			pendingRequests: /* @__PURE__ */ new Set()
+		};
+		const lifecycle = {
+			managedTeardownInstalled: false,
+			retained: resume !== void 0
+		};
+		const closers = [];
+		const releaseBeforeManaged = (entry) => Effect.suspend(() => lifecycle.managedTeardownInstalled || lifecycle.retained ? Effect.void : entry.close.pipe(Effect.catchCause((cause) => reportBrowserCause("interactive.cleanup", cause).pipe(Effect.andThen(Effect.logWarning(entry.warning))))));
+		const sessionIdValue = yield* Effect.acquireRelease(withinDeadline(resume === void 0 ? Effect.tryPromise({
+			try: (signal) => observeLate(signal, closeLateAcquisition(signal, () => binding.acquire(keepAliveMillis(fixedPolicy)), (id) => runCleanup(Schema.decodeUnknownEffect(BrowserRunSessionId)(id).pipe(Effect.flatMap((value) => terminate(Redacted.make(value), [])))))),
+			catch: (cause) => isCapacityRefusal(cause) ? InteractiveBrowserCapacityError.make({
+				implementation: browserRunInteractiveImplementation,
+				message: "Browser Run has no capacity for a new browser session"
+			}) : protocolError("Acquiring the Browser Run session failed", cause)
+		}).pipe(Effect.flatMap(Schema.decodeUnknownEffect(BrowserRunSessionId)), Effect.catchTag("SchemaError", () => protocolError("The Browser Run session identity was malformed"))) : Effect.succeed(Redacted.value(resume.sessionId)), fixedPolicy, startedAt), (id) => Effect.suspend(() => {
+			state.closed.value = true;
+			state.disconnected.value = true;
+			return lifecycle.managedTeardownInstalled || lifecycle.retained ? Effect.void : terminate(Redacted.make(id), []).pipe(Effect.catchCause((cause) => reportBrowserCause("interactive.close", cause).pipe(Effect.andThen(Effect.logWarning("Whole-browser cleanup remains unconfirmed")))));
+		}), { interruptible: true });
+		const owner = Symbol();
+		const releaseOwner = () => {
+			if (owners.get(sessionIdValue) === owner) owners.delete(sessionIdValue);
+		};
+		const connect = yield* Effect.cached(Effect.gen(function* () {
+			if (owners.has(sessionIdValue)) return yield* InteractiveBrowserBusyError.make({
+				implementation: browserRunInteractiveImplementation,
+				message: "The previous local browser owner must detach before resuming"
+			});
+			yield* Effect.acquireRelease(Effect.sync(() => {
+				owners.set(sessionIdValue, owner);
+			}), () => Effect.sync(() => {
+				if (!lifecycle.managedTeardownInstalled) releaseOwner();
+			}));
+			const browser = yield* Effect.acquireRelease(withinDeadline(Effect.tryPromise({
+				try: (signal) => observeLate(signal, closeLateAcquisition(signal, () => binding.connect(sessionIdValue, signal), (acquired) => runCleanup(resume === void 0 ? closeAcquired(acquired) : closeEntry(acquired.detach ?? (async () => {}), "Detaching the browser failed").close))),
+				catch: (cause) => resume !== void 0 && cause instanceof BrowserRunFailure && (cause.status === 404 || cause.status === 410) ? expiredError() : protocolError("Connecting to the Browser Run session failed", cause)
+			}).pipe(Effect.timeoutOrElse({
+				duration: "10 seconds",
+				orElse: () => Effect.fail(protocolError("Connecting to the Browser Run session timed out"))
+			})), fixedPolicy, startedAt), (acquired) => lifecycle.managedTeardownInstalled ? Effect.void : lifecycle.retained ? closeEntry(acquired.detach ?? (async () => {}), "Detaching the browser failed").close.pipe(Effect.tap(() => Effect.sync(releaseOwner)), Effect.catchCause((cause) => reportBrowserCause("interactive.detach", cause))) : releaseBeforeManaged(closeEntry(acquired.close, "Closing the local browser connection failed")), { interruptible: true });
+			if (resume !== void 0) {
+				if ((yield* Effect.try({
+					try: browser.sessionId,
+					catch: (cause) => protocolError("Reading the reattached browser identity failed", cause)
+				})) !== sessionIdValue) return yield* protocolError("The reattached browser session identity did not match");
+			}
+			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 reattached = resume === void 0 ? void 0 : yield* withinDeadline(Effect.tryPromise({
+				try: async () => {
+					if (browser.reattach === void 0 || browser.detach === void 0) throw new Error("The browser binding does not support exact reattachment");
+					return await browser.reattach(resume.page);
+				},
+				catch: (cause) => protocolError("Reattaching the exact browser page failed", cause)
+			}).pipe(Effect.timeoutOrElse({
+				duration: "10 seconds",
+				orElse: () => Effect.fail(protocolError("Reattaching the exact browser page timed out"))
+			})), fixedPolicy, startedAt);
+			if (resume !== void 0 && reattached === void 0) return yield* expiredError();
+			const context = reattached?.context ?? (yield* Effect.acquireRelease(withinDeadline(Effect.tryPromise({
+				try: (signal) => observeLate(signal, closeLateAcquisition(signal, browser.createContext, (acquired) => runCleanup(Effect.tryPromise({
+					try: () => acquired.close(),
+					catch: (cause) => actionError("close", cause)
+				})))),
+				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 = reattached?.page ?? (yield* Effect.acquireRelease(withinDeadline(Effect.tryPromise({
+				try: (signal) => observeLate(signal, closeLateAcquisition(signal, context.newPage, (acquired) => runCleanup(Effect.tryPromise({
+					try: () => acquired.close(),
+					catch: (cause) => actionError("close", cause)
+				})))),
+				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 detach = yield* Effect.cached(Effect.uninterruptible(Effect.gen(function* () {
+				if (browser.detach === void 0) return yield* protocolError("The browser binding does not support detachment");
+				lifecycle.retained = true;
+				state.closed.value = true;
+				state.disconnected.value = true;
+				if (state.pendingInputs.size > 0) state.uncertain.value = true;
+				yield* closeEntry(async () => {
+					page.offRequest(requestListener);
+					browser.offDisconnected(disconnected);
+					await browser.detach?.();
+				}, "Detaching the browser transport failed").close;
+				releaseOwner();
+			}).pipe(Effect.catchTag("InteractiveBrowserActionError", (error) => reportBrowserCause("interactive.detach", Cause.fail(error)).pipe(Effect.andThen(Effect.fail(reportedBrowserError(actionError("close")))))), Effect.catchTag("InteractiveBrowserProtocolError", (error) => failReportedProtocol("interactive.detach", error)))));
+			const teardown = yield* Effect.uninterruptible(Effect.gen(function* () {
+				const cached = yield* Effect.cached(terminate(Redacted.make(sessionIdValue), closers).pipe(Effect.tapCause((cause) => reportBrowserCause("interactive.close", cause)), Effect.mapError(reportedBrowserError)));
+				lifecycle.managedTeardownInstalled = true;
+				lifecycle.retained = false;
+				yield* Effect.addFinalizer(() => Effect.uninterruptible(Effect.sync(() => {
+					state.closed.value = true;
+					state.disconnected.value = true;
+				}).pipe(Effect.andThen(Effect.suspend(() => lifecycle.retained ? detach : cached)), Effect.catchCause((cause) => reportBrowserCause("interactive.close", cause).pipe(Effect.andThen(Effect.logWarning("Whole-browser cleanup remains unconfirmed")))))));
+				return cached;
+			}));
+			const close = Effect.uninterruptible(Effect.suspend(() => {
+				if (lifecycle.retained || owners.get(sessionIdValue) !== owner) return Effect.void;
+				state.closed.value = true;
+				state.disconnected.value = true;
+				return 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"))));
+			const inputState = Effect.sync(() => state.uncertain.value ? "unknown" : state.pendingInputs.size > 0 ? "running" : "idle");
+			const pageIdentity = yield* Effect.cached(Effect.tryPromise({
+				try: async () => {
+					if (page.identity === void 0) throw new Error("The browser binding does not expose page identity");
+					return await page.identity();
+				},
+				catch: (cause) => protocolError("Reading the exact browser page identity failed", cause)
+			}).pipe(Effect.catchTag("InteractiveBrowserProtocolError", (error) => failReportedProtocol("interactive.checkpoint", error))));
+			const observeResize = yield* makeHostInputObserver(state, "interactive.resize.late");
+			return {
+				handle: runtime.handle,
+				checkpoint: withinDeadline(Effect.gen(function* () {
+					const identity = resume?.page ?? (yield* pageIdentity);
+					return BrowserRunInteractiveCheckpoint.make({
+						sessionId: Redacted.make(sessionIdValue),
+						page: identity,
+						policy: InteractiveBrowserPolicy.make(fixedPolicy),
+						startedAt,
+						consumedActions: state.actions.value,
+						inputState: yield* inputState
+					});
+				}), fixedPolicy, startedAt),
+				detach,
+				inputState,
+				drainInput: Effect.suspend(() => Effect.promise(() => boundedBestEffort(Promise.allSettled(state.pendingInputs), 500)).pipe(Effect.andThen(inputState))),
+				sessionId: Redacted.make(sessionIdValue),
+				resizeViewport: (viewport) => decodeViewport(viewport).pipe(Effect.flatMap((decoded) => runtime.run(Effect.tryPromise({
+					try: (signal) => observeResize(page.setViewport(decoded), signal),
+					catch: (cause) => {
+						if (state.disconnected.value || isRemoteClosure(cause)) {
+							state.disconnected.value = true;
+							return expiredError();
+						}
+						return protocolError("Resizing the browser viewport failed", cause);
+					}
+				}).pipe(Effect.catchTag("InteractiveBrowserProtocolError", (error) => failReportedProtocol("interactive.resize", error))), currentPagePreflight, false))),
+				getLiveView: (request) => Schema.decodeEffect(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.decodeEffect(BrowserRunLiveViewResult)({ devtoolsFrontendUrl: Redacted.make(observation.devtoolsFrontendUrl) }).pipe(Effect.mapError(() => protocolError("Cloudflare returned a malformed Live View response"))))), currentPagePreflight.pipe(Effect.andThen(requestFitsSession(decoded.expiresInMs))), true, true))),
+				handoff: (request) => Schema.decodeEffect(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.decodeEffect(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.decodeEffect(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, true, false),
+				close
+			};
+		}).pipe(Effect.provideService(Scope.Scope, scope)));
+		return {
+			sessionId: Redacted.make(sessionIdValue),
+			connect: Effect.suspend(() => state.closed.value ? expiredError() : connect)
+		};
+	});
+	return BrowserRunInteractiveHost.of({
+		acquire,
+		open: (policy) => acquire(policy).pipe(Effect.flatMap((acquired) => acquired.connect)),
+		resume: (checkpoint, options) => Schema.decodeEffect(Schema.toType(BrowserRunInteractiveCheckpoint))(checkpoint).pipe(Effect.mapError(() => policyError("The browser checkpoint is malformed")), Effect.flatMap((decoded) => acquire(decoded.policy, decoded, options.pendingInput)), Effect.flatMap((acquired) => acquired.connect), Effect.catchTag("InteractiveBrowserProtocolError", (error) => failReportedProtocol("interactive.resume", error, {
+			stage: "preparation",
+			dispatch: "not-dispatched",
+			session: "disconnected"
+		}))),
+		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 { reportedBrowserError as C, reportBrowserCause as S, BrowserRunCleanupError as _, BrowserRunInteractiveCheckpoint as a, BrowserRunFailure as b, BrowserRunLiveViewResult as c, BrowserRunViewport as d, CloudflareInteractiveBrowser as f, isBrowserRunUndispatchedActionError as g, browserRunInteractiveLayer as h, BrowserRunInteractiveBinding as i, BrowserRunPageIdentity as l, browserRunInteractiveImplementation as m, BrowserRunHandoffResult as n, BrowserRunInteractiveHost as o, browserRunInteractiveHostLayer as p, BrowserRunHandoffState as r, BrowserRunLiveViewRequest as s, BrowserRunHandoffRequest as t, BrowserRunPageObservation as u, BrowserRunSessionLifecycle as v, browserFailure as x, BrowserRunBinding as y };
+
+//# sourceMappingURL=InteractiveBrowser-CxFT-Nwm.mjs.map