@effect-agent/platform-cloudflare 0.1.0-beta.107 → 0.1.0-beta.108

package/dist/ProtectedBrowser.mjs

@@ -1,6 +1,6 @@
-import { h as BrowserRunSessionLifecycle, o as BrowserRunLiveViewRequest, r as BrowserRunHandoffState, s as BrowserRunLiveViewResult, t as BrowserRunHandoffRequest } from "./InteractiveBrowser-xVNX7ARl.mjs";
-import { Clock, Context, Crypto, Effect, Layer, Redacted, Schema, Semaphore } from "effect";
-import puppeteer from "@cloudflare/puppeteer";
+import { _ as BrowserRunFailure, b as reportBrowserCause, g as BrowserRunBinding, h as BrowserRunSessionLifecycle, o as BrowserRunLiveViewRequest, r as BrowserRunHandoffState, s as BrowserRunLiveViewResult, t as BrowserRunHandoffRequest, v as browserFailure, x as reportedBrowserError, y as inheritBrowserReport } from "./InteractiveBrowser-l6J4eP6T.mjs";
+import { Cause, Clock, Context, Crypto, Effect, Layer, Redacted, Schema, Semaphore } from "effect";
+import "@cloudflare/puppeteer";
 import { InteractiveBrowserPolicy } from "effect-agent/interactive-browser";
 import { BrowserCredentialAccess, CardCredential, CredentialObservationDecision, CredentialOffer, CredentialOfferMetadata, CredentialOrigin, CredentialTarget, CredentialUseResult, ListCredentialOffers, LoginCredential, ProtectedBrowser, ProtectedBrowserCheckpoint, ProtectedBrowserClick, ProtectedBrowserControl, ProtectedBrowserError, ProtectedBrowserFill, ProtectedBrowserNavigate, ProtectedBrowserObservation, UseCredential } from "effect-agent/protected-browser";
 //#region src/protected-browser/policy.ts
@@ -91,15 +91,18 @@ const makeProtectedBrowserPolicy = Effect.fn("ProtectedBrowser.open")(function*
 		driver.invalidate();
 		cleanup = yield* driver.close.pipe(Effect.interruptible, Effect.timeoutOrElse({
 			duration: "10 seconds",
-			orElse: () => Effect.succeed("unconfirmed")
-		}), Effect.catchCause(() => Effect.succeed("unconfirmed")));
+			orElse: () => Effect.fail(new BrowserRunFailure({
+				operation: "protected.close",
+				reason: "timeout"
+			}))
+		}), Effect.catchCause((cause) => reportBrowserCause("protected.close", cause).pipe(Effect.as("unconfirmed"))));
 		return cleanup;
 	})));
-	yield* Effect.addFinalizer(() => detached ? Effect.void : close.pipe(Effect.flatMap((result) => result === "unconfirmed" ? Effect.logWarning("Protected browser exact-session closure unconfirmed") : Effect.void)));
-	const remote = (effect) => effect.pipe(Effect.mapError((error) => fail(error.reason)));
-	const decode = (schema, value) => Schema.decodeUnknownEffect(schema)(value).pipe(Effect.mapError(() => fail("provider")));
-	const caller = access.caller.pipe(Effect.mapError((error) => fail(error.reason)));
-	const pageContext = remote(driver.context);
+	yield* Effect.addFinalizer(() => detached ? Effect.void : close);
+	const publicFailure = (effect) => effect.pipe(Effect.catchCause((cause) => Effect.failCause(Cause.map(cause, (error) => inheritBrowserReport(error, fail(error.reason))))));
+	const decode = (schema, value) => Schema.decodeUnknownEffect(schema)(value).pipe(Effect.catch((error) => reportBrowserCause("protected.policy.decode", Cause.fail(error)).pipe(Effect.andThen(Effect.fail(reportedBrowserError(fail("provider")))))));
+	const caller = access.caller.pipe(publicFailure);
+	const pageContext = publicFailure(driver.context);
 	const permitObservation = Effect.gen(function* () {
 		const context = yield* pageContext;
 		let origins;
@@ -112,7 +115,7 @@ const makeProtectedBrowserPolicy = Effect.fn("ProtectedBrowser.open")(function*
 				exposures: [...exposures],
 				humanExposure,
 				humanOrigins
-			}).pipe(Effect.mapError((error) => fail(error.reason)));
+			}).pipe(publicFailure);
 			if (Redacted.value(yield* caller) !== Redacted.value(principal)) return yield* fail("denied");
 			const decision = yield* Schema.decodeEffect(CredentialObservationDecision)(rawDecision).pipe(Effect.mapError(() => fail("observation-blocked")));
 			if (decision === "deny") return yield* fail("observation-blocked");
@@ -122,13 +125,13 @@ const makeProtectedBrowserPolicy = Effect.fn("ProtectedBrowser.open")(function*
 			}
 			observation = "approved-after-exposure";
 		}
-		yield* remote(driver.restrictObservation(origins));
+		yield* publicFailure(driver.restrictObservation(origins));
 		return {
 			...context,
 			frameOrigins: context.frameOrigins.filter((origin) => origins === void 0 || origins.includes(origin))
 		};
 	});
-	const target = (ref) => remote(driver.target(ref));
+	const target = (ref) => publicFailure(driver.target(ref));
 	const authorizeAction = Effect.fn("ProtectedBrowser.authorizeAction")(function* (action) {
 		if (access.authorizeAction === void 0) {
 			if (action._tag === "Submit") return yield* fail("unsupported");
@@ -139,7 +142,7 @@ const makeProtectedBrowserPolicy = Effect.fn("ProtectedBrowser.open")(function*
 			caller: principal,
 			action,
 			exposures: [...exposures]
-		}).pipe(Effect.mapError((error) => fail(error.reason)));
+		}).pipe(publicFailure);
 		if (Redacted.value(yield* caller) !== Redacted.value(principal)) return yield* fail("denied");
 		if (action._tag !== "Navigate") {
 			const current = yield* target(action.ref);
@@ -165,12 +168,15 @@ const makeProtectedBrowserPolicy = Effect.fn("ProtectedBrowser.open")(function*
 			duration: remaining,
 			orElse: () => Effect.fail(fail("timeout"))
 		}), Effect.catchCause((cause) => Effect.gen(function* () {
+			const unexpected = cause.reasons.filter((reason) => reason._tag === "Die" || reason._tag === "Fail" && !Schema.is(ProtectedBrowserError)(reason.error));
+			if (unexpected.length > 0) yield* reportBrowserCause("protected.operation", Cause.fromReasons(unexpected));
 			const error = cause.reasons.find((reason) => reason._tag === "Fail" && Schema.is(ProtectedBrowserError)(reason.error));
-			const reason = error?._tag === "Fail" && Schema.is(ProtectedBrowserError)(error.error) ? error.error.reason : "provider";
+			const reason = unexpected.length === 0 && error?._tag === "Fail" && Schema.is(ProtectedBrowserError)(error.error) ? error.error.reason : "provider";
 			const interrupt = cause.reasons.some((reason) => reason._tag === "Interrupt");
 			if (dispatch !== "not-dispatched" || interrupt || reason === "provider" || reason === "timeout") yield* close;
 			if (interrupt) return yield* Effect.interrupt;
-			return yield* fail(dispatch === "possibly-dispatched" && reason === "provider" ? "outcome-unknown" : reason);
+			const outcome = fail(dispatch === "possibly-dispatched" && reason === "provider" ? "outcome-unknown" : reason);
+			return yield* unexpected.length > 0 ? reportedBrowserError(outcome) : inheritBrowserReport(error?._tag === "Fail" ? error.error : void 0, outcome);
 		})), Effect.onInterrupt(() => close), Effect.withTracerEnabled(false));
 	})).pipe(Effect.flatMap(Effect.fromOption(() => new ProtectedBrowserError({
 		reason: "busy",
@@ -197,13 +203,13 @@ const makeProtectedBrowserPolicy = Effect.fn("ProtectedBrowser.open")(function*
 			});
 			offers.clear();
 			dispatch = "possibly-dispatched";
-			yield* remote(driver.navigate(decoded.url));
+			yield* publicFailure(driver.navigate(decoded.url));
 			dispatch = "dispatched";
 			yield* permitObservation;
 		})),
 		observe: run(Effect.gen(function* () {
 			const before = yield* permitObservation;
-			const result = yield* remote(driver.discover);
+			const result = yield* publicFailure(driver.discover);
 			const after = yield* permitObservation;
 			if (before.document !== after.document || result.document !== after.document || result.topOrigin !== after.topOrigin) return yield* fail("stale-reference");
 			if (result.frameOrigins.some((origin) => !after.frameOrigins.includes(origin))) return yield* fail("observation-blocked");
@@ -242,7 +248,7 @@ const makeProtectedBrowserPolicy = Effect.fn("ProtectedBrowser.open")(function*
 			};
 			yield* authorizeAction(action);
 			dispatch = "possibly-dispatched";
-			yield* remote(driver.click(decoded.ref)).pipe(Effect.catch((error) => {
+			yield* publicFailure(driver.click(decoded.ref)).pipe(Effect.catch((error) => {
 				if (error.reason === "needs-attention") dispatch = "not-dispatched";
 				return Effect.fail(error);
 			}));
@@ -261,7 +267,7 @@ const makeProtectedBrowserPolicy = Effect.fn("ProtectedBrowser.open")(function*
 				target: control.target,
 				role: control.role
 			});
-			yield* remote(driver.fill(decoded.ref, control.role, Redacted.make(decoded.value))).pipe(Effect.provideService(ProtectedBrowserDispatch, { mark: Effect.sync(() => {
+			yield* publicFailure(driver.fill(decoded.ref, control.role, Redacted.make(decoded.value))).pipe(Effect.provideService(ProtectedBrowserDispatch, { mark: Effect.sync(() => {
 				dispatch = "possibly-dispatched";
 			}) }));
 			dispatch = "dispatched";
@@ -278,7 +284,7 @@ const makeProtectedBrowserPolicy = Effect.fn("ProtectedBrowser.open")(function*
 				caller: principal,
 				kind: decoded.kind,
 				target: control.target
-			}).pipe(Effect.mapError((error) => fail(error.reason)));
+			}).pipe(publicFailure);
 			const now = yield* Clock.currentTimeMillis;
 			for (const [ref, offer] of offers) if (offer.expires <= now) offers.delete(ref);
 			if (candidates.length > 16 || offers.size + candidates.length > 64) return yield* fail("limit");
@@ -288,7 +294,7 @@ const makeProtectedBrowserPolicy = Effect.fn("ProtectedBrowser.open")(function*
 			const pending = /* @__PURE__ */ new Map();
 			for (const candidate of candidates) {
 				const metadata = yield* decode(CredentialOfferMetadata, candidate.metadata);
-				const ref = yield* crypto.randomUUIDv4.pipe(Effect.mapError(() => fail("provider")));
+				const ref = yield* crypto.randomUUIDv4.pipe(Effect.catch((error) => reportBrowserCause("protected.identity", Cause.fail(error)).pipe(Effect.andThen(Effect.fail(reportedBrowserError(fail("provider")))))));
 				pending.set(ref, {
 					caller: principal,
 					key: candidate.key,
@@ -336,12 +342,12 @@ const makeProtectedBrowserPolicy = Effect.fn("ProtectedBrowser.open")(function*
 			};
 			const authorize = Effect.gen(function* () {
 				if (Redacted.value(yield* caller) !== Redacted.value(principal)) return yield* fail("denied");
-				yield* access.authorize(authorization).pipe(Effect.mapError((error) => fail(error.reason)));
+				yield* access.authorize(authorization).pipe(publicFailure);
 				if (Redacted.value(yield* caller) !== Redacted.value(principal)) return yield* fail("denied");
 			});
 			yield* authorize;
 			yield* validate;
-			const raw = yield* access.resolve(authorization).pipe(Effect.mapError((error) => fail(error.reason)));
+			const raw = yield* access.resolve(authorization).pipe(publicFailure);
 			const material = yield* Schema.decodeEffect(offer.kind === "login" ? LoginCredential : CardCredential)(raw).pipe(Effect.mapError(() => fail("resolver")));
 			for (const field of decoded.fields) if (secretFor(material, field.role) === void 0) return yield* fail("missing-credential");
 			offers.delete(decoded.offer);
@@ -351,7 +357,7 @@ const makeProtectedBrowserPolicy = Effect.fn("ProtectedBrowser.open")(function*
 				const value = secretFor(material, field.role);
 				if (value === void 0) return yield* fail("missing-credential");
 				observation = "protected";
-				yield* remote(driver.fill(field.ref, field.role, value)).pipe(Effect.provideService(ProtectedBrowserDispatch, { mark: Effect.sync(() => {
+				yield* publicFailure(driver.fill(field.ref, field.role, value)).pipe(Effect.provideService(ProtectedBrowserDispatch, { mark: Effect.sync(() => {
 					dispatch = "possibly-dispatched";
 					if (!exposures.some((target) => sameTarget(target, offer.target))) exposures.push(offer.target);
 				}) }));
@@ -364,7 +370,7 @@ const makeProtectedBrowserPolicy = Effect.fn("ProtectedBrowser.open")(function*
 				yield* authorize;
 				const ref = decoded.submit;
 				dispatch = "possibly-dispatched";
-				yield* remote(driver.click(ref)).pipe(Effect.catch((error) => {
+				yield* publicFailure(driver.click(ref)).pipe(Effect.catch((error) => {
 					if (error.reason === "needs-attention") dispatch = "dispatched";
 					return Effect.fail(error);
 				}));
@@ -575,27 +581,30 @@ const Descriptions = Schema.Array(Schema.NullOr(Description)).check(Schema.isMax
 /** One host-private acquired session. The SDK handles and exact-session cleanup have one owner. */
 var ProtectedNativeSession = class extends Context.Service()("@effect-agent/platform-cloudflare/ProtectedNativeSession") {};
 const transportError = (reason) => new ProtectedTransportError({ reason });
-const decode = (schema, value) => Schema.decodeUnknownEffect(schema)(value).pipe(Effect.mapError(() => transportError("provider")));
-const remote = (run) => Effect.tryPromise({
+const decode = (schema, value) => Schema.decodeUnknownEffect(schema)(value).pipe(Effect.catch((error) => reportBrowserCause("protected.decode", Cause.fail(error)).pipe(Effect.andThen(Effect.fail(reportedBrowserError(transportError("provider")))))));
+const remote = (operation, run) => Effect.tryPromise({
 	try: async (signal) => {
 		try {
 			return {
 				ok: true,
 				value: await run(signal)
 			};
-		} catch {
-			return { ok: false };
+		} catch (cause) {
+			return {
+				ok: false,
+				failure: browserFailure(operation, cause)
+			};
 		}
 	},
-	catch: () => transportError("provider")
-}).pipe(Effect.flatMap((result) => result.ok ? Effect.succeed(result.value) : Effect.fail(transportError("provider"))));
+	catch: (cause) => browserFailure(operation, cause)
+}).pipe(Effect.flatMap((result) => result.ok ? Effect.succeed(result.value) : Effect.fail(result.failure)), Effect.catch((failure) => reportBrowserCause(operation, Cause.fail(failure)).pipe(Effect.andThen(Effect.fail(reportedBrowserError(transportError("provider")))))));
 /** Host-private scoped transport. Session capabilities are requirements; policy is per-pass data. */
 const makeProtectedNativeTransport = Effect.fn("ProtectedNativeTransport.make")(function* (policy) {
 	const session = yield* ProtectedNativeSession;
 	const { browser, page } = session;
 	const crypto = yield* Crypto.Crypto;
 	const clock = yield* Clock.Clock;
-	const uuid = crypto.randomUUIDv4.pipe(Effect.mapError(() => transportError("provider")));
+	const uuid = crypto.randomUUIDv4.pipe(Effect.catch((error) => reportBrowserCause("protected.identity", Cause.fail(error)).pipe(Effect.andThen(Effect.fail(reportedBrowserError(transportError("provider")))))));
 	let closed = false;
 	let violation = false;
 	let documentRef;
@@ -652,7 +661,7 @@ const makeProtectedNativeTransport = Effect.fn("ProtectedNativeTransport.make")(
 	});
 	const isCurrent = Effect.fn("ProtectedNativeTransport.isCurrent")(function* (state) {
 		if (state.frame.detached) return false;
-		return yield* remote(() => state.handle.evaluate((held) => {
+		return yield* remote("protected.validate-document", () => state.handle.evaluate((held) => {
 			if (typeof held !== "object" || held === null) return false;
 			return Reflect.get(held, "doc") === Reflect.get(globalThis, "document");
 		}));
@@ -661,7 +670,7 @@ const makeProtectedNativeTransport = Effect.fn("ProtectedNativeTransport.make")(
 		yield* check;
 		const state = controls.get(ref);
 		if (!state || observationOrigins !== void 0 && !observationOrigins.has(state.control.target.frameOrigin) || state.expires <= (yield* clock.currentTimeMillis) || !(yield* isCurrent(state.frame))) return yield* transportError("stale-reference");
-		const current = yield* remote(() => state.frame.handle.evaluate((held, index) => {
+		const current = yield* remote("protected.validate-control", () => state.frame.handle.evaluate((held, index) => {
 			if (typeof held !== "object" || held === null) return null;
 			return Reflect.apply(Reflect.get(held, "validate"), held, [index]);
 		}, state.index));
@@ -704,14 +713,14 @@ const makeProtectedNativeTransport = Effect.fn("ProtectedNativeTransport.make")(
 			yield* check;
 			yield* origin(url);
 			clear();
-			yield* remote(() => page.goto(url, { waitUntil: "load" }));
+			yield* remote("protected.navigate", () => page.goto(url, { waitUntil: "load" }));
 			yield* context;
 		}),
 		target: (ref) => get(ref).pipe(Effect.map((state) => state.control)),
 		discover: Effect.gen(function* () {
 			const before = yield* context;
 			controls.clear();
-			for (const state of frames.values()) yield* remote(() => state.handle.dispose());
+			for (const state of frames.values()) yield* remote("protected.dispose", () => state.handle.dispose());
 			frames.clear();
 			const discovered = [];
 			let text = "";
@@ -722,7 +731,7 @@ const makeProtectedNativeTransport = Effect.fn("ProtectedNativeTransport.make")(
 				if (observationOrigins !== void 0 && !observationOrigins.has(frameOrigin)) continue;
 				frameOrigins.add(frameOrigin);
 				if (typeof frame.isolatedRealm !== "function") return yield* transportError("unsupported");
-				const handle = yield* remote(() => frame.isolatedRealm().evaluateHandle(inspectFrame));
+				const handle = yield* remote("protected.discover", () => frame.isolatedRealm().evaluateHandle(inspectFrame));
 				const state = {
 					frame,
 					handle,
@@ -731,7 +740,7 @@ const makeProtectedNativeTransport = Effect.fn("ProtectedNativeTransport.make")(
 					forms: /* @__PURE__ */ new Map()
 				};
 				frames.set(frame, state);
-				const raw = yield* remote(() => handle.evaluate((held) => {
+				const raw = yield* remote("protected.describe-controls", () => handle.evaluate((held) => {
 					if (typeof held !== "object" || held === null) return null;
 					return Reflect.get(held, "original");
 				}));
@@ -773,7 +782,7 @@ const makeProtectedNativeTransport = Effect.fn("ProtectedNativeTransport.make")(
 					});
 					discovered.push(control);
 				}
-				const rawText = yield* remote(() => handle.evaluate((held) => {
+				const rawText = yield* remote("protected.read-text", () => handle.evaluate((held) => {
 					if (typeof held !== "object" || held === null) return null;
 					return Reflect.apply(Reflect.get(held, "text"), held, []);
 				}));
@@ -796,7 +805,7 @@ const makeProtectedNativeTransport = Effect.fn("ProtectedNativeTransport.make")(
 			const dispatch = yield* ProtectedBrowserDispatch;
 			const state = yield* get(ref);
 			yield* dispatch.mark;
-			const filled = yield* remote(() => state.frame.handle.evaluate((held, index, expectedRole, secret) => {
+			const filled = yield* remote("protected.fill", () => state.frame.handle.evaluate((held, index, expectedRole, secret) => {
 				if (typeof held !== "object" || held === null) return false;
 				return Reflect.apply(Reflect.get(held, "fill"), held, [
 					index,
@@ -809,7 +818,7 @@ const makeProtectedNativeTransport = Effect.fn("ProtectedNativeTransport.make")(
 		}),
 		click: Effect.fn("ProtectedNativeTransport.click")(function* (ref) {
 			const state = yield* get(ref);
-			const clicked = yield* remote(() => state.frame.handle.evaluate((held, index) => {
+			const clicked = yield* remote("protected.click", () => state.frame.handle.evaluate((held, index) => {
 				if (typeof held !== "object" || held === null) return false;
 				return Reflect.apply(Reflect.get(held, "click"), held, [index]);
 			}, state.index));
@@ -834,6 +843,7 @@ var BrowserRunProtectedBinding = class extends Context.Service()("@effect-agent/
 */
 const protectedBindingLayer = (options) => Layer.effect(BrowserRunProtectedBinding)(Effect.gen(function* () {
 	const lifecycle = yield* BrowserRunSessionLifecycle;
+	const binding = yield* BrowserRunBinding;
 	const crypto = yield* Crypto.Crypto;
 	return { open: Effect.fn("BrowserRunProtectedTransport.open")(function* (policy, identity) {
 		const failure = () => new ProtectedBrowserError({
@@ -850,108 +860,117 @@ const protectedBindingLayer = (options) => Layer.effect(BrowserRunProtectedBindi
 		let browser;
 		let driver;
 		let invalid = false;
-		const runCleanup = Effect.runPromiseWith(Context.make(Clock.Clock, yield* Clock.Clock));
+		const runCleanup = Effect.runPromiseWith(yield* Effect.context());
 		const terminate = Effect.gen(function* () {
 			invalid = true;
 			driver?.invalidate();
 			if (sessionId === void 0) return "unconfirmed";
-			const cleanup = yield* lifecycle.close(sessionId).pipe(Effect.as("confirmed"), Effect.catchCause(() => Effect.succeed("unconfirmed")), Effect.interruptible, Effect.timeoutOrElse({
+			const cleanup = yield* lifecycle.close(sessionId).pipe(Effect.as("confirmed"), Effect.catchCause((cause) => reportBrowserCause("protected.close", cause).pipe(Effect.as("unconfirmed"))), Effect.interruptible, Effect.timeoutOrElse({
 				duration: "10 seconds",
-				orElse: () => Effect.succeed("unconfirmed")
+				orElse: () => reportBrowserCause("protected.close", Cause.fail(new BrowserRunFailure({
+					operation: "protected.close",
+					reason: "timeout"
+				}))).pipe(Effect.as("unconfirmed"))
 			}));
 			const connected = browser;
-			if (connected !== void 0) yield* Effect.promise(() => connected.disconnect()).pipe(Effect.catchCause(() => Effect.void), Effect.interruptible, Effect.timeoutOrElse({
+			if (connected !== void 0) yield* Effect.promise(() => connected.disconnect()).pipe(Effect.catchCause((cause) => reportBrowserCause("protected.disconnect", cause)), Effect.interruptible, Effect.timeoutOrElse({
 				duration: "1 second",
-				orElse: () => Effect.void
+				orElse: () => reportBrowserCause("protected.disconnect", Cause.fail(new BrowserRunFailure({
+					operation: "protected.disconnect",
+					reason: "timeout"
+				})))
 			}));
 			return cleanup;
 		});
 		const close = yield* Effect.cached(terminate);
-		yield* Effect.addFinalizer(() => detached ? Effect.void : close.pipe(Effect.flatMap((state) => state === "confirmed" ? Effect.void : Effect.logWarning("Protected browser exact-session closure unconfirmed"))));
+		yield* Effect.addFinalizer(() => detached ? Effect.void : close);
+		let stage = identity === void 0 ? "protected.acquire" : "protected.connect";
 		const acquired = yield* Effect.tryPromise({
 			try: async (signal) => {
-				let recordingDisabled = false;
-				const acquired = identity === void 0 ? await puppeteer.acquire({ fetch: async (input, init) => {
-					const request = new Request(input, init);
-					const url = new URL(request.url);
-					if (url.pathname === "/v1/devtools/browser" && request.method === "POST") {
-						url.searchParams.set("recording", "false");
-						recordingDisabled = url.searchParams.get("recording") === "false";
-						return options.browser.fetch(new Request(url, request));
+				try {
+					sessionId = identity === void 0 ? Redacted.make(await binding.acquire(Math.min(6e5, Math.max(1e4, policy.maxElapsedMillis)), "protected.acquire")) : identity.sessionId;
+					if (signal.aborted || invalid) {
+						await runCleanup(terminate);
+						throw new ProtectedTransportError({ reason: "stale-reference" });
 					}
-					return options.browser.fetch(request);
-				} }, {
-					recording: false,
-					keep_alive: Math.min(6e5, Math.max(1e4, policy.maxElapsedMillis))
-				}) : { sessionId: Redacted.value(identity.sessionId) };
-				sessionId = Redacted.make(Schema.decodeSync(Schema.String.check(Schema.isUUID()))(acquired.sessionId));
-				if (identity === void 0 && !recordingDisabled || signal.aborted || invalid) {
-					await runCleanup(terminate);
-					throw new ProtectedTransportError({ reason: "stale-reference" });
-				}
-				browser = await puppeteer.connect(options.browser, acquired.sessionId);
-				if (signal.aborted || invalid) {
-					await runCleanup(terminate);
-					throw new ProtectedTransportError({ reason: "stale-reference" });
-				}
-				let page;
-				if (identity === void 0) page = await (await browser.createBrowserContext()).newPage();
-				else {
-					const context = browser.browserContexts().find((candidate) => candidate.id === Redacted.value(identity.contextId));
-					if (context === void 0) throw new ProtectedTransportError({ reason: "stale-reference" });
-					const pages = await context.pages();
-					let found;
-					for (const candidate of pages) {
-						const client = await candidate.createCDPSession();
-						const info = await client.send("Target.getTargetInfo");
-						await client.detach();
-						if (info.targetInfo.targetId === Redacted.value(identity.targetId)) found = candidate;
+					stage = "protected.connect";
+					browser = await binding.connect(Redacted.value(sessionId), stage);
+					if (signal.aborted || invalid) {
+						await runCleanup(terminate);
+						throw new ProtectedTransportError({ reason: "stale-reference" });
 					}
-					if (found === void 0 || pages.length !== 1) throw new ProtectedTransportError({ reason: "stale-reference" });
-					page = found;
-				}
-				control = await page.createCDPSession();
-				const info = await control.send("Target.getTargetInfo");
-				providerIdentity = Schema.decodeSync(ProtectedProviderIdentity)({
-					sessionId,
-					contextId: Redacted.make(page.browserContext().id ?? ""),
-					targetId: Redacted.make(info.targetInfo.targetId)
-				});
-				await page.setBypassServiceWorker(true);
-				await page.setRequestInterception(true);
-				page.on("request", (request) => {
-					let allowed = policy.network._tag === "Unrestricted";
-					try {
-						const url = new URL(request.url());
-						allowed ||= policy.network._tag === "ExactHosts" && url.protocol === "https:" && !url.username && !url.password && policy.network.allowedHosts.includes(url.host);
-					} catch {}
-					(allowed && !invalid ? request.continue() : request.abort("blockedbyclient")).catch(() => {
-						invalid = true;
-						driver?.invalidate();
+					let page;
+					if (identity === void 0) {
+						stage = "protected.context";
+						const context = await browser.createBrowserContext();
+						stage = "protected.page";
+						page = await context.newPage();
+					} else {
+						stage = "protected.resume";
+						const context = browser.browserContexts().find((candidate) => candidate.id === Redacted.value(identity.contextId));
+						if (context === void 0) throw new ProtectedTransportError({ reason: "stale-reference" });
+						const pages = await context.pages();
+						let found;
+						for (const candidate of pages) {
+							const client = await candidate.createCDPSession();
+							const info = await client.send("Target.getTargetInfo");
+							await client.detach();
+							if (info.targetInfo.targetId === Redacted.value(identity.targetId)) found = candidate;
+						}
+						if (found === void 0 || pages.length !== 1) throw new ProtectedTransportError({ reason: "stale-reference" });
+						page = found;
+					}
+					stage = "protected.control";
+					control = await page.createCDPSession();
+					const info = await control.send("Target.getTargetInfo");
+					stage = "protected.identity";
+					providerIdentity = Schema.decodeSync(ProtectedProviderIdentity)({
+						sessionId,
+						contextId: Redacted.make(page.browserContext().id ?? ""),
+						targetId: Redacted.make(info.targetInfo.targetId)
 					});
-				});
-				if (signal.aborted || invalid) {
-					await runCleanup(terminate);
-					throw new ProtectedTransportError({ reason: "stale-reference" });
+					stage = "protected.interception";
+					await page.setBypassServiceWorker(true);
+					await page.setRequestInterception(true);
+					page.on("request", (request) => {
+						let allowed = policy.network._tag === "Unrestricted";
+						try {
+							const url = new URL(request.url());
+							allowed ||= policy.network._tag === "ExactHosts" && url.protocol === "https:" && !url.username && !url.password && policy.network.allowedHosts.includes(url.host);
+						} catch {}
+						(allowed && !invalid ? request.continue() : request.abort("blockedbyclient")).catch(async (cause) => {
+							invalid = true;
+							driver?.invalidate();
+							await runCleanup(reportBrowserCause("protected.interception", Cause.fail(cause)));
+						});
+					});
+					if (signal.aborted || invalid) {
+						await runCleanup(terminate);
+						throw new ProtectedTransportError({ reason: "stale-reference" });
+					}
+					return ProtectedNativeSession.of({
+						browser,
+						page,
+						close,
+						release: Effect.suspend(() => detached ? Effect.void : close.pipe(Effect.asVoid))
+					});
+				} catch (cause) {
+					if (signal.aborted && !(cause instanceof ProtectedTransportError)) await runCleanup(reportBrowserCause(stage, Cause.fail(cause)));
+					throw cause;
 				}
-				return ProtectedNativeSession.of({
-					browser,
-					page,
-					close,
-					release: Effect.suspend(() => detached ? Effect.void : close.pipe(Effect.asVoid))
-				});
 			},
-			catch: failure
+			catch: (cause) => browserFailure(stage, cause)
 		}).pipe(Effect.timeoutOrElse({
 			duration: Math.min(policy.maxElapsedMillis, 3e4),
-			orElse: () => Effect.fail(new ProtectedBrowserError({
-				...failure(),
+			orElse: () => Effect.fail(new BrowserRunFailure({
+				operation: stage,
 				reason: "timeout"
 			}))
-		}), Effect.catch((error) => close.pipe(Effect.flatMap((cleanup) => Effect.fail(new ProtectedBrowserError({
-			...error,
+		}), Effect.catch((error) => reportBrowserCause(stage, Cause.fail(error)).pipe(Effect.andThen(close), Effect.flatMap((cleanup) => Effect.fail(reportedBrowserError(new ProtectedBrowserError({
+			...failure(),
+			reason: error.reason === "timeout" ? "timeout" : "provider",
 			cleanup
-		}))))));
+		})))))));
 		driver = yield* makeProtectedNativeTransport(policy).pipe(Effect.provideService(ProtectedNativeSession, acquired), Effect.provideService(Crypto.Crypto, crypto));
 		const exact = providerIdentity;
 		if (exact === void 0) return yield* failure();
@@ -964,11 +983,14 @@ const protectedBindingLayer = (options) => Layer.effect(BrowserRunProtectedBindi
 					const send = Reflect.get(control, "send");
 					return await Reflect.apply(send, control, [method, parameters]);
 				},
-				catch: failure
+				catch: (cause) => browserFailure("protected.command", cause)
 			}).pipe(Effect.timeoutOrElse({
 				duration: "10 seconds",
-				orElse: () => Effect.fail(failure())
-			})),
+				orElse: () => Effect.fail(new BrowserRunFailure({
+					operation: "protected.command",
+					reason: "timeout"
+				}))
+			}), Effect.catch((error) => reportBrowserCause("protected.command", Cause.fail(error)).pipe(Effect.andThen(Effect.fail(reportedBrowserError(failure())))))),
 			detach: Effect.tryPromise({
 				try: async () => {
 					if (invalid || detached || browser === void 0) throw void 0;
@@ -976,14 +998,17 @@ const protectedBindingLayer = (options) => Layer.effect(BrowserRunProtectedBindi
 					detached = true;
 					driver?.invalidate();
 				},
-				catch: failure
+				catch: (cause) => browserFailure("protected.detach", cause)
 			}).pipe(Effect.timeoutOrElse({
 				duration: "10 seconds",
-				orElse: () => Effect.fail(failure())
-			}))
+				orElse: () => Effect.fail(new BrowserRunFailure({
+					operation: "protected.detach",
+					reason: "timeout"
+				}))
+			}), Effect.catch((error) => reportBrowserCause("protected.detach", Cause.fail(error)).pipe(Effect.andThen(Effect.fail(reportedBrowserError(failure()))))))
 		};
 	}, Effect.withTracerEnabled(false)) };
-}));
+})).pipe(Layer.provide(BrowserRunBinding.layer(options.browser)));
 /** One binding implementation serves scoped tools and host-managed protected handoffs. */
 const browserRunProtectedBindingLayer = (options) => Layer.effect(BrowserRunProtectedTransport)(Effect.gen(function* () {
 	const binding = yield* BrowserRunProtectedBinding;
@@ -1048,7 +1073,7 @@ const browserRunProtectedHostLayer = () => Layer.effect(BrowserRunProtectedHost)
 			if (handoff?.handoffId === void 0) return yield* failure("denied");
 			yield* fits(0);
 			const raw = yield* provider.command("Cloudflare.getHandoffState", {});
-			const result = yield* Schema.decodeUnknownEffect(HandoffState)(raw).pipe(Effect.mapError(() => failure("provider")));
+			const result = yield* Schema.decodeUnknownEffect(HandoffState)(raw).pipe(Effect.catch((error) => reportBrowserCause("protected.host.decode", Cause.fail(error)).pipe(Effect.andThen(Effect.fail(reportedBrowserError(failure("provider")))))));
 			if (result.active && result.handoffId === void 0 || result.handoffId !== void 0 && result.handoffId !== Redacted.value(handoff.handoffId)) return yield* failure("denied");
 			return BrowserRunHandoffState.make({
 				active: result.active,
@@ -1079,13 +1104,13 @@ const browserRunProtectedHostLayer = () => Layer.effect(BrowserRunProtectedHost)
 				const result = yield* provider.command("Cloudflare.handoff", {
 					instructions: decoded.instructions,
 					timeout: decoded.timeout
-				}).pipe(Effect.flatMap(Schema.decodeUnknownEffect(Handoff)), Effect.catch(() => state.handle.close.pipe(Effect.flatMap((cleanup) => Effect.fail(new ProtectedBrowserError({
+				}).pipe(Effect.flatMap(Schema.decodeUnknownEffect(Handoff)), Effect.catchCause((cause) => Cause.hasInterruptsOnly(cause) ? Effect.interrupt : reportBrowserCause("protected.handoff", cause).pipe(Effect.andThen(state.handle.close), Effect.flatMap((cleanup) => Effect.fail(reportedBrowserError(new ProtectedBrowserError({
 					reason: "outcome-unknown",
 					dispatch: "possibly-dispatched",
 					milestone: suspended.milestone,
 					observation: "closed",
 					cleanup
-				}))))), Effect.onInterrupt(() => state.handle.close));
+				})))))), Effect.onInterrupt(() => state.handle.close));
 				handoff = BrowserRunProtectedCheckpoint.make({
 					...provider.identity,
 					protected: suspended,
@@ -1101,14 +1126,14 @@ const browserRunProtectedHostLayer = () => Layer.effect(BrowserRunProtectedHost)
 					mode: decoded.mode,
 					expiresInMs: decoded.expiresInMs
 				});
-				const result = yield* Schema.decodeUnknownEffect(LiveView)(raw).pipe(Effect.mapError(() => failure("provider")));
-				return yield* Schema.decodeEffect(BrowserRunLiveViewResult)({ devtoolsFrontendUrl: Redacted.make(result.devtoolsFrontendUrl) }).pipe(Effect.mapError(() => failure("provider")));
+				const result = yield* Schema.decodeUnknownEffect(LiveView)(raw).pipe(Effect.catch((error) => reportBrowserCause("protected.host.decode", Cause.fail(error)).pipe(Effect.andThen(Effect.fail(reportedBrowserError(failure("provider")))))));
+				return yield* Schema.decodeEffect(BrowserRunLiveViewResult)({ devtoolsFrontendUrl: Redacted.make(result.devtoolsFrontendUrl) }).pipe(Effect.catch((error) => reportBrowserCause("protected.host.decode", Cause.fail(error)).pipe(Effect.andThen(Effect.fail(reportedBrowserError(failure("provider")))))));
 			})),
 			getHandoffState: control(getHandoffState),
 			getReturnOrigin: control(Effect.gen(function* () {
 				if ((yield* getHandoffState).active) return yield* failure("busy");
-				const context = yield* provider.driver.context.pipe(Effect.mapError((error) => failure(error.reason)));
-				return yield* Schema.decodeEffect(CredentialOrigin)(context.topOrigin).pipe(Effect.mapError(() => failure("provider")));
+				const context = yield* provider.driver.context.pipe(Effect.mapError((error) => inheritBrowserReport(error, failure(error.reason))));
+				return yield* Schema.decodeEffect(CredentialOrigin)(context.topOrigin).pipe(Effect.catch((error) => reportBrowserCause("protected.host.decode", Cause.fail(error)).pipe(Effect.andThen(Effect.fail(reportedBrowserError(failure("provider")))))));
 			})),
 			returnControl: control(Effect.gen(function* () {
 				if ((yield* getHandoffState).active) return yield* failure("busy");
@@ -1126,7 +1151,7 @@ const browserRunProtectedHostLayer = () => Layer.effect(BrowserRunProtectedHost)
 	return {
 		open: (policy) => open(policy),
 		resume: (checkpoint) => Schema.decodeEffect(BrowserRunProtectedCheckpoint)(checkpoint).pipe(Effect.mapError(() => failure("denied")), Effect.flatMap((decoded) => open(decoded.protected.policy, decoded))),
-		closeSession: (id) => lifecycle.close(id).pipe(Effect.as("confirmed"), Effect.catchCause(() => Effect.succeed("unconfirmed")))
+		closeSession: (id) => lifecycle.close(id).pipe(Effect.as("confirmed"), Effect.catchCause((cause) => reportBrowserCause("protected.closeSession", cause).pipe(Effect.as("unconfirmed"))))
 	};
 }));
 //#endregion