@effect-agent/platform-cloudflare 0.1.0-beta.31 → 0.1.0-beta.33

package/dist/interactive-browser.mjs

@@ -1,5 +1,5 @@
-import { Context, Duration, Effect, Layer, Option, Ref, Schema, Semaphore } from "effect";
-import { BrowserActionResult, BrowserNavigationResult, BrowserTextResult, InteractiveBrowser, InteractiveBrowserActionError, InteractiveBrowserBusyError, InteractiveBrowserCapacityError, InteractiveBrowserExpiredError, InteractiveBrowserLimitError, InteractiveBrowserPolicy, InteractiveBrowserPolicyDeniedError, InteractiveBrowserProtocolError, SandboxImplementation } from "@effect-agent/sandbox";
+import { Context, Duration, Effect, Layer, Option, Redacted, Ref, Schema, Semaphore } from "effect";
+import { BrowserActionResult, BrowserNavigationResult, BrowserScreenshotRequest, BrowserScrollRequest, BrowserTextResult, InteractiveBrowser, InteractiveBrowserActionError, InteractiveBrowserBusyError, InteractiveBrowserCapacityError, InteractiveBrowserExpiredError, InteractiveBrowserLimitError, InteractiveBrowserPolicy, InteractiveBrowserPolicyDeniedError, InteractiveBrowserProtocolError, PageScreenshotResult, SandboxImplementation } from "@effect-agent/sandbox";
 import puppeteer from "@cloudflare/puppeteer";
 //#region src/interactive-browser.ts
 const browserRunInteractiveImplementation = SandboxImplementation.make({
@@ -8,7 +8,17 @@ const browserRunInteractiveImplementation = SandboxImplementation.make({
 });
 const MIN_KEEP_ALIVE_MILLIS = 1e4;
 const MAX_KEEP_ALIVE_MILLIS = 6e5;
-const BoundedRemoteText = Schema.String.check(Schema.isMaxLength(8 * 1024 * 1024));
+const MAX_TEXT_LENGTH = 8 * 1024 * 1024;
+const MAX_SCREENSHOT_BYTES = 8 * 1024 * 1024;
+const MIN_LIVE_VIEW_EXPIRY_MILLIS = 6e4;
+const MAX_LIVE_VIEW_EXPIRY_MILLIS = 60 * 6e4;
+const MAX_HANDOFF_TIMEOUT_MILLIS = 30 * 6e4;
+const MAX_HOST_TEXT_LENGTH = 8 * 1024;
+const CLEANUP_STEP_TIMEOUT_MILLIS = 1e4;
+const CLOSE_SESSION_TIMEOUT_MILLIS = 1e4;
+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"),
@@ -20,17 +30,71 @@ const TextObservation = Schema.Union([
 		observed: Schema.Natural
 	})
 ]);
+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-only request for a redacted Cloudflare Live View URL. */
+var BrowserRunLiveViewRequest = class extends Schema.Class("BrowserRunLiveViewRequest")({
+	mode: Schema.Literal("tab"),
+	expiresInMs: PositiveInt.check(Schema.isBetween({
+		minimum: MIN_LIVE_VIEW_EXPIRY_MILLIS,
+		maximum: MAX_LIVE_VIEW_EXPIRY_MILLIS
+	}))
+}) {};
+var BrowserRunLiveViewResult = class extends Schema.Class("BrowserRunLiveViewResult")({ devtoolsFrontendUrl: Schema.Redacted(LiveViewUrl) }) {};
+/** Start one bounded handoff; controller ownership remains a consumer concern. */
+var BrowserRunHandoffRequest = class extends Schema.Class("BrowserRunHandoffRequest")({
+	instructions: BoundedHostText.check(Schema.isMaxLength(1024)),
+	timeout: PositiveInt.check(Schema.isLessThanOrEqualTo(MAX_HANDOFF_TIMEOUT_MILLIS))
+}) {};
+var BrowserRunHandoffResult = class extends Schema.Class("BrowserRunHandoffResult")({ handoffId: Schema.Redacted(BoundedHostText) }) {};
+var BrowserRunHandoffState = class extends Schema.Class("BrowserRunHandoffState")({
+	active: Schema.Boolean,
+	handoffId: Schema.optionalKey(Schema.Redacted(BoundedHostText)),
+	durationMs: Schema.optionalKey(HandoffDuration)
+}) {};
 /** Host-supplied Browser Run binding projected into one fakeable launch operation. */
 var BrowserRunInteractiveBinding = class BrowserRunInteractiveBinding extends Context.Service()("@effect-agent/platform-cloudflare/BrowserRunInteractiveBinding") {
 	static layer(options) {
-		return Layer.succeed(BrowserRunInteractiveBinding)({ launch: async (keepAliveMillis) => makeProductionBrowser(await puppeteer.launch(options.browser, { keep_alive: keepAliveMillis })) });
+		return Layer.succeed(BrowserRunInteractiveBinding)({
+			launch: async (keepAliveMillis) => makeProductionBrowser(await puppeteer.launch(options.browser, { keep_alive: keepAliveMillis })),
+			connect: async (sessionId) => makeProductionBrowser(await puppeteer.connect(options.browser, sessionId))
+		});
 	}
 };
+/** 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()
+});
 const makeProductionPage = (page) => {
 	const listeners = /* @__PURE__ */ new Map();
 	return {
@@ -74,10 +138,20 @@ const makeProductionPage = (page) => {
 		}, selector, maximumBytes),
 		fill: async (selector, value) => {
 			await page.$eval(selector, (element, nextValue) => {
-				if (!("value" in element)) throw new Error("The selector did not resolve to a fillable field");
+				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.set(element, "value", nextValue);
+				Reflect.apply(setValue, element, [nextValue]);
 				const dispatchEvent = Reflect.get(element, "dispatchEvent");
 				if (typeof dispatchEvent === "function") {
 					Reflect.apply(dispatchEvent, element, [new Event("input", { bubbles: true })]);
@@ -85,7 +159,20 @@ const makeProductionPage = (page) => {
 				}
 			}, value);
 		},
-		click: (selector) => page.click(selector)
+		click: (selector) => page.click(selector),
+		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())
 	};
 };
 const makeProductionContext = (context) => ({
@@ -95,6 +182,7 @@ const makeProductionContext = (context) => ({
 const makeProductionBrowser = (browser) => ({
 	createContext: async () => makeProductionContext(await browser.createBrowserContext()),
 	close: () => browser.close(),
+	sessionId: () => browser.sessionId(),
 	isConnected: () => browser.isConnected(),
 	onDisconnected: (listener) => {
 		browser.on("disconnected", listener);
@@ -143,18 +231,21 @@ const hostAllowed = (policy, value) => {
 	}
 };
 const keepAliveMillis = (policy) => Math.max(MIN_KEEP_ALIVE_MILLIS, Math.min(MAX_KEEP_ALIVE_MILLIS, policy.maxElapsedMillis));
-const closeLateAcquisition = async (signal, acquire) => {
+const closeLateAcquisition = async (signal, acquire, close) => {
 	const acquired = await acquire();
 	if (!signal.aborted) return acquired;
 	try {
-		await acquired.close();
+		await close(acquired);
 	} catch {}
 	throw new Error("The interrupted browser acquisition completed late");
 };
 const closeWithWarning = (close, warning) => Effect.tryPromise({
 	try: close,
 	catch: () => protocolError(warning)
-}).pipe(Effect.catchCause(() => Effect.logWarning(warning)));
+}).pipe(Effect.timeoutOrElse({
+	duration: Duration.millis(CLEANUP_STEP_TIMEOUT_MILLIS),
+	orElse: () => Effect.fail(protocolError(warning))
+}), Effect.catchCause(() => Effect.logWarning(warning)));
 const deadlineError = Effect.fn("BrowserRunInteractive.deadlineError")(function* (policy, startedAt) {
 	const now = yield* Effect.clockWith((clock) => clock.currentTimeMillis);
 	return yield* InteractiveBrowserLimitError.make({
@@ -177,7 +268,7 @@ const withinDeadline = Effect.fn("BrowserRunInteractive.withinDeadline")(functio
 });
 const stateFailure = (state) => {
 	if (state.violation.value !== void 0) return state.violation.value;
-	if (state.disconnected.value || state.uncertain.value) return expiredError();
+	if (state.closed.value || state.disconnected.value || state.uncertain.value) return expiredError();
 };
 const awaitPendingRequests = (state) => Effect.suspend(() => {
 	const pending = [...state.pendingRequests];
@@ -223,7 +314,7 @@ const makeRequestListener = (policy, state) => (request) => {
 	});
 	state.pendingRequests.add(observed);
 };
-const makeHandle = Effect.fn("BrowserRunInteractive.makeHandle")(function* (page, policy, startedAt, state) {
+const makeHandle = Effect.fn("BrowserRunInteractive.makeHandle")(function* (page, policy, startedAt, state, close) {
 	const permits = yield* Semaphore.make(1);
 	const actions = yield* Ref.make(0);
 	const remote = (operation, evaluate) => Effect.tryPromise({
@@ -275,65 +366,131 @@ const makeHandle = Effect.fn("BrowserRunInteractive.makeHandle")(function* (page
 		message: "The browser handle already has an operation in flight"
 	}))));
 	return {
-		navigate: (request) => run(Effect.gen(function* () {
-			yield* remote("navigate", () => page.goto(request.url));
-			return yield* decodeNavigationResult(page, policy);
-		}), Effect.suspend(() => hostAllowed(policy, request.url) ? Effect.void : Effect.fail(policyError("The navigation URL is outside the browser policy")))),
-		readText: (request) => run(Effect.gen(function* () {
-			const raw = yield* remote("read-text", () => page.readText(request.selector, policy.maxReturnedBytes));
-			const observation = yield* Schema.decodeUnknownEffect(TextObservation)(raw).pipe(Effect.mapError((cause) => protocolError("The browser returned a malformed text observation", cause)));
-			if (observation._tag === "MissingElement") return yield* actionError("read-text");
-			if (observation._tag === "OverLimit") return yield* InteractiveBrowserLimitError.make({
-				implementation: browserRunInteractiveImplementation,
-				limit: "returned-bytes",
-				maximum: policy.maxReturnedBytes,
-				observed: observation.observed,
-				message: "The browser returned-text limit was reached"
-			});
-			const observed = new TextEncoder().encode(observation.text).byteLength;
-			if (observed > policy.maxReturnedBytes) return yield* InteractiveBrowserLimitError.make({
-				implementation: browserRunInteractiveImplementation,
-				limit: "returned-bytes",
-				maximum: policy.maxReturnedBytes,
-				observed,
-				message: "The browser returned-text limit was reached"
-			});
-			return yield* Schema.decodeUnknownEffect(BrowserTextResult)({ text: observation.text }).pipe(Effect.mapError((cause) => protocolError("The browser returned malformed page text", cause)));
-		})),
-		fill: (request) => run(remote("fill", () => page.fill(request.selector, request.value)).pipe(Effect.andThen(decodeActionResult(page, policy)))),
-		click: (request) => run(remote("click", () => page.click(request.selector)).pipe(Effect.andThen(decodeActionResult(page, policy))))
+		handle: {
+			navigate: (request) => run(Effect.gen(function* () {
+				yield* remote("navigate", () => page.goto(request.url));
+				return yield* decodeNavigationResult(page, policy);
+			}), Effect.suspend(() => hostAllowed(policy, request.url) ? Effect.void : Effect.fail(policyError("The navigation URL is outside the browser policy")))),
+			readText: (request) => run(Effect.gen(function* () {
+				const raw = yield* remote("read-text", () => page.readText(request.selector, policy.maxReturnedBytes));
+				const observation = yield* Schema.decodeUnknownEffect(TextObservation)(raw).pipe(Effect.mapError((cause) => protocolError("The browser returned a malformed text observation", cause)));
+				if (observation._tag === "MissingElement") return yield* actionError("read-text");
+				if (observation._tag === "OverLimit") return yield* InteractiveBrowserLimitError.make({
+					implementation: browserRunInteractiveImplementation,
+					limit: "returned-bytes",
+					maximum: policy.maxReturnedBytes,
+					observed: observation.observed,
+					message: "The browser returned-text limit was reached"
+				});
+				const observed = new TextEncoder().encode(observation.text).byteLength;
+				if (observed > policy.maxReturnedBytes) return yield* InteractiveBrowserLimitError.make({
+					implementation: browserRunInteractiveImplementation,
+					limit: "returned-bytes",
+					maximum: policy.maxReturnedBytes,
+					observed,
+					message: "The browser returned-text limit was reached"
+				});
+				return yield* Schema.decodeUnknownEffect(BrowserTextResult)({ text: observation.text }).pipe(Effect.mapError((cause) => protocolError("The browser returned malformed page text", cause)));
+			})),
+			fill: (request) => run(remote("fill", () => page.fill(request.selector, request.value)).pipe(Effect.andThen(decodeActionResult(page, policy)))),
+			click: (request) => run(remote("click", () => page.click(request.selector)).pipe(Effect.andThen(decodeActionResult(page, policy)))),
+			screenshot: (request) => Schema.decodeUnknownEffect(BrowserScreenshotRequest)(request).pipe(Effect.mapError(() => policyError("The browser screenshot request is malformed")), Effect.flatMap((decoded) => run(Effect.gen(function* () {
+				const raw = yield* remote("screenshot", () => page.screenshot(decoded.fullPage));
+				const bytes = yield* Schema.decodeUnknownEffect(PngBytes)(raw).pipe(Effect.mapError(() => protocolError("The browser returned a malformed PNG screenshot")));
+				if (bytes.length > policy.maxReturnedBytes) return yield* InteractiveBrowserLimitError.make({
+					implementation: browserRunInteractiveImplementation,
+					limit: "returned-bytes",
+					maximum: policy.maxReturnedBytes,
+					observed: bytes.length,
+					message: "The browser screenshot byte limit was reached"
+				});
+				return yield* Schema.decodeUnknownEffect(PageScreenshotResult)({
+					implementation: browserRunInteractiveImplementation,
+					mediaType: "image/png",
+					bytes: new Uint8Array(bytes)
+				}).pipe(Effect.mapError(() => protocolError("The browser returned a malformed PNG screenshot")));
+			}), decodeActionResult(page, policy).pipe(Effect.asVoid)))),
+			scroll: (request) => Schema.decodeUnknownEffect(BrowserScrollRequest)(request).pipe(Effect.mapError(() => policyError("The browser scroll request is malformed")), Effect.flatMap((decoded) => run(remote("scroll", () => page.scroll(decoded.deltaX, decoded.deltaY)).pipe(Effect.andThen(decodeActionResult(page, policy))), decodeActionResult(page, policy).pipe(Effect.asVoid)))),
+			close
+		},
+		run
 	};
 });
-/** Worker-only Cloudflare Puppeteer adapter; the caller supplies the Browser Run binding Layer. */
-const browserRunInteractiveLayer = () => Layer.effect(InteractiveBrowser, Effect.gen(function* () {
-	const binding = yield* BrowserRunInteractiveBinding;
-	return InteractiveBrowser.of({ open: (policy) => Effect.gen(function* () {
+const remainingMillis = Effect.fn("BrowserRunInteractive.remainingMillis")(function* (policy, startedAt) {
+	const now = yield* Effect.clockWith((clock) => clock.currentTimeMillis);
+	return Math.max(0, policy.maxElapsedMillis - Math.max(0, now - startedAt));
+});
+const closeEntry = (close, warning) => ({
+	close: Effect.tryPromise({
+		try: close,
+		catch: (cause) => actionError("close", cause)
+	}).pipe(Effect.timeoutOrElse({
+		duration: Duration.millis(CLEANUP_STEP_TIMEOUT_MILLIS),
+		orElse: () => Effect.fail(actionError("close"))
+	})),
+	warning
+});
+const syncCloseEntry = (close, warning) => ({
+	close: Effect.try({
+		try: close,
+		catch: (cause) => actionError("close", cause)
+	}),
+	warning
+});
+const runTeardown = (entries) => Effect.forEach([...entries].reverse(), (entry) => entry.close.pipe(Effect.match({
+	onFailure: (error) => ({
+		error,
+		warning: entry.warning
+	}),
+	onSuccess: () => void 0
+}))).pipe(Effect.map((failures) => failures.filter((failure) => failure !== void 0)));
+const cdpCommand = (page, state, command, parameters, output, malformedMessage) => Effect.scoped(Effect.gen(function* () {
+	const cdp = yield* Effect.acquireRelease(Effect.tryPromise({
+		try: (signal) => closeLateAcquisition(signal, page.createCdpSession, (acquired) => acquired.detach()),
+		catch: (cause) => state.disconnected.value || isRemoteClosure(cause) ? expiredError() : protocolError("Creating the Cloudflare browser control session failed", cause)
+	}), (acquired) => closeWithWarning(acquired.detach, "Detaching the Cloudflare browser control session failed"), { interruptible: true });
+	const raw = yield* Effect.tryPromise({
+		try: () => cdp.send(command, parameters),
+		catch: (cause) => state.disconnected.value || isRemoteClosure(cause) ? expiredError() : protocolError("The Cloudflare browser control command failed", cause)
+	});
+	return yield* Schema.decodeUnknownEffect(output)(raw).pipe(Effect.mapError(() => protocolError(malformedMessage)));
+}));
+const makeHostService = (binding) => {
+	const open = Effect.fn("BrowserRunInteractiveHost.open")(function* (policy) {
 		const fixedPolicy = yield* snapshotPolicy(policy);
 		const startedAt = yield* Effect.clockWith((clock) => clock.currentTimeMillis);
 		const state = {
+			closed: { value: false },
 			disconnected: { value: false },
 			uncertain: { value: false },
 			violation: { value: void 0 },
 			pendingRequests: /* @__PURE__ */ new Set()
 		};
+		const lifecycle = {
+			managedTeardownInstalled: false,
+			explicitCloseInvoked: false
+		};
+		const closers = [];
+		const releaseBeforeManaged = (entry) => Effect.suspend(() => lifecycle.managedTeardownInstalled ? Effect.void : entry.close.pipe(Effect.catchCause(() => Effect.logWarning(entry.warning))));
 		const browser = yield* Effect.acquireRelease(withinDeadline(Effect.tryPromise({
-			try: (signal) => closeLateAcquisition(signal, () => binding.launch(keepAliveMillis(fixedPolicy))),
+			try: (signal) => closeLateAcquisition(signal, () => binding.launch(keepAliveMillis(fixedPolicy)), (acquired) => acquired.close()),
 			catch: (cause) => isCapacityRefusal(cause) ? InteractiveBrowserCapacityError.make({
 				implementation: browserRunInteractiveImplementation,
 				message: "Browser Run has no capacity for a new browser session"
 			}) : protocolError("Launching the Browser Run session failed", cause)
-		}), fixedPolicy, startedAt), (acquired) => Effect.sync(() => {
+		}), fixedPolicy, startedAt), (acquired) => {
 			state.disconnected.value = true;
-		}).pipe(Effect.andThen(closeWithWarning(acquired.close, "Closing the interactive browser failed"))), { interruptible: true });
+			return releaseBeforeManaged(closeEntry(acquired.close, "Closing the interactive browser failed"));
+		}, { interruptible: true });
+		closers.push(closeEntry(browser.close, "Closing the interactive browser failed"));
 		const disconnected = () => {
 			state.disconnected.value = true;
 		};
 		yield* Effect.acquireRelease(Effect.try({
 			try: () => browser.onDisconnected(disconnected),
 			catch: (cause) => protocolError("Installing the browser disconnect listener failed", cause)
-		}), () => Effect.sync(() => {
-			browser.offDisconnected(disconnected);
-		}).pipe(Effect.catchCause(() => Effect.logWarning("Removing the browser disconnect listener failed"))));
+		}), () => 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)
@@ -341,14 +498,20 @@ const browserRunInteractiveLayer = () => Layer.effect(InteractiveBrowser, Effect
 			state.disconnected.value = true;
 			return yield* expiredError();
 		}
+		const sessionIdValue = yield* Effect.try({
+			try: browser.sessionId,
+			catch: (cause) => protocolError("Reading the Browser Run session identity failed", cause)
+		}).pipe(Effect.flatMap((value) => Schema.decodeUnknownEffect(BrowserRunSessionId)(value).pipe(Effect.mapError(() => protocolError("The Browser Run session identity was malformed")))));
 		const context = yield* Effect.acquireRelease(withinDeadline(Effect.tryPromise({
-			try: (signal) => closeLateAcquisition(signal, browser.createContext),
+			try: (signal) => closeLateAcquisition(signal, browser.createContext, (acquired) => acquired.close()),
 			catch: (cause) => state.disconnected.value || isRemoteClosure(cause) ? expiredError() : protocolError("Creating the browser context failed", cause)
-		}), fixedPolicy, startedAt), (acquired) => closeWithWarning(acquired.close, "Closing the interactive browser context failed"), { interruptible: true });
+		}), fixedPolicy, startedAt), (acquired) => releaseBeforeManaged(closeEntry(acquired.close, "Closing the interactive browser context failed")), { interruptible: true });
+		closers.push(closeEntry(context.close, "Closing the interactive browser context failed"));
 		const page = yield* Effect.acquireRelease(withinDeadline(Effect.tryPromise({
-			try: (signal) => closeLateAcquisition(signal, context.newPage),
+			try: (signal) => closeLateAcquisition(signal, context.newPage, (acquired) => acquired.close()),
 			catch: (cause) => state.disconnected.value || isRemoteClosure(cause) ? expiredError() : protocolError("Creating the browser page failed", cause)
-		}), fixedPolicy, startedAt), (acquired) => closeWithWarning(acquired.close, "Closing the interactive browser page failed"), { interruptible: true });
+		}), 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)
@@ -357,9 +520,8 @@ const browserRunInteractiveLayer = () => Layer.effect(InteractiveBrowser, Effect
 		yield* Effect.acquireRelease(Effect.try({
 			try: () => page.onRequest(requestListener),
 			catch: (cause) => protocolError("Installing the browser request listener failed", cause)
-		}), () => Effect.sync(() => {
-			page.offRequest(requestListener);
-		}).pipe(Effect.catchCause(() => Effect.logWarning("Removing the browser request policy failed"))));
+		}), () => 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)
@@ -367,10 +529,78 @@ const browserRunInteractiveLayer = () => Layer.effect(InteractiveBrowser, Effect
 		yield* withinDeadline(awaitPendingRequests(state), fixedPolicy, startedAt);
 		const setupFailure = stateFailure(state);
 		if (setupFailure !== void 0) return yield* setupFailure;
-		return yield* makeHandle(page, fixedPolicy, startedAt, state);
-	}) });
+		const teardown = yield* Effect.uninterruptible(Effect.gen(function* () {
+			const cached = yield* Effect.cached(runTeardown(closers));
+			lifecycle.managedTeardownInstalled = true;
+			yield* Effect.addFinalizer(() => Effect.uninterruptible(Effect.sync(() => {
+				state.closed.value = true;
+				state.disconnected.value = true;
+			}).pipe(Effect.andThen(cached), Effect.flatMap((failures) => lifecycle.explicitCloseInvoked ? Effect.void : Effect.forEach(failures, (failure) => Effect.logWarning(failure.warning)).pipe(Effect.asVoid)))));
+			return cached;
+		}));
+		const close = Effect.uninterruptible(Effect.sync(() => {
+			lifecycle.explicitCloseInvoked = true;
+			state.closed.value = true;
+			state.disconnected.value = true;
+		}).pipe(Effect.andThen(teardown), Effect.flatMap((failures) => failures[0] === void 0 ? Effect.void : Effect.fail(failures[0].error))));
+		const runtime = yield* makeHandle(page, fixedPolicy, startedAt, state, close);
+		const currentPagePreflight = decodeActionResult(page, fixedPolicy).pipe(Effect.asVoid);
+		const requestFitsSession = (requestedMillis) => remainingMillis(fixedPolicy, startedAt).pipe(Effect.flatMap((remaining) => remaining > 0 && requestedMillis <= remaining ? Effect.void : Effect.fail(policyError("The host browser request exceeds the remaining session time"))));
+		return {
+			handle: runtime.handle,
+			sessionId: Redacted.make(sessionIdValue),
+			getLiveView: (request) => Schema.decodeUnknownEffect(BrowserRunLiveViewRequest)(request).pipe(Effect.mapError(() => policyError("The Live View request is malformed")), Effect.flatMap((decoded) => runtime.run(cdpCommand(page, state, "Cloudflare.getLiveView", {
+				mode: decoded.mode,
+				expiresInMs: decoded.expiresInMs
+			}, LiveViewObservation, "Cloudflare returned a malformed Live View response").pipe(Effect.flatMap((observation) => Schema.decodeUnknownEffect(BrowserRunLiveViewResult)({ devtoolsFrontendUrl: Redacted.make(observation.devtoolsFrontendUrl) }).pipe(Effect.mapError(() => protocolError("Cloudflare returned a malformed Live View response"))))), currentPagePreflight.pipe(Effect.andThen(requestFitsSession(decoded.expiresInMs)))))),
+			handoff: (request) => Schema.decodeUnknownEffect(BrowserRunHandoffRequest)(request).pipe(Effect.mapError(() => policyError("The browser handoff request is malformed")), Effect.flatMap((decoded) => runtime.run(cdpCommand(page, state, "Cloudflare.handoff", {
+				instructions: decoded.instructions,
+				timeout: decoded.timeout
+			}, HandoffObservation, "Cloudflare returned a malformed browser handoff response").pipe(Effect.flatMap((observation) => Schema.decodeUnknownEffect(BrowserRunHandoffResult)({ handoffId: Redacted.make(observation.handoffId) }).pipe(Effect.mapError(() => protocolError("Cloudflare returned a malformed browser handoff response"))))), currentPagePreflight.pipe(Effect.andThen(requestFitsSession(decoded.timeout)))))),
+			getHandoffState: runtime.run(cdpCommand(page, state, "Cloudflare.getHandoffState", {}, HandoffStateObservation, "Cloudflare returned a malformed browser handoff state").pipe(Effect.flatMap((observation) => Schema.decodeUnknownEffect(BrowserRunHandoffState)({
+				active: observation.active,
+				...observation.handoffId === void 0 ? {} : { handoffId: Redacted.make(observation.handoffId) },
+				...observation.durationMs === void 0 ? {} : { durationMs: observation.durationMs }
+			}).pipe(Effect.mapError(() => protocolError("Cloudflare returned a malformed browser handoff state"))))), currentPagePreflight),
+			close
+		};
+	});
+	const closeSession = Effect.fn("BrowserRunInteractiveHost.closeSession")(function* (sessionId) {
+		const decoded = yield* Schema.decodeUnknownEffect(Schema.Redacted(BrowserRunSessionId))(sessionId).pipe(Effect.mapError(() => policyError("The Browser Run cleanup session identity is malformed")));
+		return yield* Effect.scoped(Effect.gen(function* () {
+			const closeAttempted = { value: false };
+			const browser = yield* Effect.acquireRelease(Effect.tryPromise({
+				try: (signal) => closeLateAcquisition(signal, () => binding.connect(Redacted.value(decoded)), (acquired) => acquired.close()),
+				catch: (cause) => actionError("close", cause)
+			}), (acquired) => closeAttempted.value ? Effect.void : closeWithWarning(acquired.close, "Closing the leaked Browser Run session failed"), { interruptible: true });
+			return yield* Effect.tryPromise({
+				try: () => {
+					closeAttempted.value = true;
+					return browser.close();
+				},
+				catch: (cause) => actionError("close", cause)
+			});
+		})).pipe(Effect.timeoutOrElse({
+			duration: Duration.millis(CLOSE_SESSION_TIMEOUT_MILLIS),
+			orElse: () => Effect.fail(actionError("close"))
+		}));
+	});
+	return BrowserRunInteractiveHost.of({
+		open,
+		closeSession
+	});
+};
+/** 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)) });
 }));
 //#endregion
-export { BrowserRunInteractiveBinding, browserRunInteractiveImplementation, browserRunInteractiveLayer };
+export { BrowserRunHandoffRequest, BrowserRunHandoffResult, BrowserRunHandoffState, BrowserRunInteractiveBinding, BrowserRunInteractiveHost, BrowserRunLiveViewRequest, BrowserRunLiveViewResult, browserRunInteractiveHostLayer, browserRunInteractiveImplementation, browserRunInteractiveLayer };
 
 //# sourceMappingURL=interactive-browser.mjs.map