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

package/dist/Session-D4nT9hOO.mjs

@@ -1,1379 +0,0 @@
-import { Identifier } from "./References.mjs";
-import { BrowserError, InitializationError, SessionError } from "./Errors.mjs";
-import { t as BrowserbaseClient } from "./Client-D1_xYM9o.mjs";
-import { ActionResult, Checkpoint, CheckpointOptions, ClickRequest, FillRequest, HoverRequest, InputReceipt, KeyStroke, NavigateRequest, NavigationResult, Observation, ObservationOptions, ObservedElement, PointerMoveRequest, PressRequest, ReadTextRequest, ScreenshotRequest, ScreenshotResult, ScrollRequest, StartNavigationRequest, Target, TextResult, TypeRequest, Viewport, WheelRequest } from "./BrowserData.mjs";
-import { isTerminalSessionStatus } from "./SessionData.mjs";
-import { n as nowMillis, r as until, t as deadlineAfter } from "./Deadline-CrViaogr.mjs";
-import { o as issueLiveView, t as BrowserbaseSessions } from "./Sessions-CtbseWEh.mjs";
-import { a as reported, i as noLocalConnection, n as reportCleanup, o as connectionAddress, r as makeCleanup, t as acquireRemote } from "./Acquisition-WBafHwXH.mjs";
-import { h as snapshot, m as invoke, s as Plan } from "./Bootstrap-BXuzZojd.mjs";
-import { o as publicError } from "./Images-DgscEfSf.mjs";
-import { o as bindingImplementation, t as BrowserbaseBrowserBinding } from "./BrowserBinding-DlJTGYZL.mjs";
-import { t as associate } from "./Association-CEps4hYP.mjs";
-import { t as associatePageControl } from "./PageControlAssociation-DabEg5AR.mjs";
-import { Cause, Clock, Deferred, Effect, Exit, FiberSet, Option, Redacted, Schema, Scope, Semaphore } from "effect";
-//#region src/internal/browser/BindingRunner.ts
-const makeBindingRunner = (capacity, handle, onFault) => {
-	if (!Number.isSafeInteger(capacity) || capacity < 1) throw new RangeError("Invalid binding callback capacity");
-	return Effect.gen(function* () {
-		const parent = yield* Scope.Scope;
-		const runtimeScope = yield* Scope.fork(parent, "sequential");
-		const run = yield* FiberSet.makeRuntimePromise().pipe(Scope.provide(runtimeScope));
-		let accepting = true;
-		let faulted = false;
-		let inFlight = 0;
-		const close = () => {
-			accepting = false;
-		};
-		const fault = () => {
-			if (!accepting || faulted) return;
-			faulted = true;
-			onFault();
-		};
-		yield* Scope.addFinalizer(runtimeScope, Effect.sync(close));
-		const submit = (input, failureMode = "fail-session") => {
-			if (!accepting || faulted) return {
-				_tag: "Rejected",
-				reason: "closed"
-			};
-			if (inFlight >= capacity) {
-				if (failureMode === "fail-session") fault();
-				return {
-					_tag: "Rejected",
-					reason: "capacity"
-				};
-			}
-			inFlight++;
-			const result = run(Effect.exit(Effect.suspend(() => handle(input)))).then((exit) => {
-				if (failureMode === "fail-session" && Exit.isFailure(exit)) fault();
-				return exit;
-			}, (error) => {
-				if (failureMode === "fail-session") fault();
-				throw error;
-			}).finally(() => {
-				inFlight--;
-			});
-			result.catch(() => {});
-			return {
-				_tag: "Accepted",
-				result
-			};
-		};
-		return {
-			close,
-			submit
-		};
-	});
-};
-//#endregion
-//#region src/internal/browser/Bootstrap.ts
-const guarded = (content, origins) => origins === void 0 ? `(() => {\n${content}\n})();` : `(() => {\nconst origins = ${JSON.stringify([...origins])};\nif (!origins.includes(globalThis.location && globalThis.location.origin)) return;\n${content}\n})();`;
-/**
-* Dependent steps become one script in declared order: a failing step stops the ones after it
-* rather than letting a later step observe half-initialized state. Origin-excluded steps are
-* skipped inside the document that reports the origin, never by guessing from a navigation URL.
-*/
-const compileBootstrap = (plan) => {
-	if (plan.scripts.length === 0 && plan.permissions.length === 0) return void 0;
-	const bundle = plan.scripts.length === 0 ? void 0 : plan.scripts.map((script) => guarded(script.content, script.origins)).join("\n");
-	const readiness = plan.scripts.flatMap((script) => script.readiness === void 0 ? [] : [{
-		step: script.id,
-		expression: script.readiness.expression,
-		timeoutMillis: script.readiness.timeoutMillis,
-		...script.origins === void 0 ? {} : { origins: script.origins }
-	}]);
-	const existingDocuments = plan.scripts.some((script) => script.readiness?.existingDocuments === "RequireFreshNavigation") ? "RequireFreshNavigation" : "AcceptAlreadyRunning";
-	return {
-		...bundle === void 0 ? {} : { bundle },
-		permissions: plan.permissions.map((grant) => ({
-			origin: grant.origin,
-			permissions: [...grant.permissions]
-		})),
-		readiness,
-		existingDocuments
-	};
-};
-/** Duplicate step identity would make registration order and readiness reports ambiguous. */
-const duplicateStep = (plan) => new Set(plan.scripts.map((script) => script.id)).size !== plan.scripts.length || new Set(plan.permissions.map((grant) => grant.origin)).size !== plan.permissions.length || new Set((plan.bindings ?? []).map((registration) => registration.name)).size !== (plan.bindings?.length ?? 0);
-//#endregion
-//#region src/internal/browser/Bindings.ts
-const invalidPlan = () => BrowserError.make({
-	operation: "configure",
-	reason: "configuration",
-	outcome: "undispatched"
-});
-const AdmissionPlan = Schema.Struct({
-	...Plan.fields,
-	bindings: Schema.optionalKey(Schema.Array(Schema.Unknown).check(Schema.isMaxLength(16)))
-});
-/** Validate before allocation and retain an immutable snapshot, including authenticated callbacks. */
-const preparePlan = Effect.fnUntraced(function* (plan) {
-	const source = yield* Effect.try({
-		try: () => ({ ...plan }),
-		catch: invalidPlan
-	});
-	const data = yield* Schema.decodeEffect(AdmissionPlan, { onExcessProperty: "error" })(source).pipe(Effect.mapError(invalidPlan));
-	if (duplicateStep({
-		scripts: data.scripts,
-		permissions: data.permissions
-	})) return yield* invalidPlan();
-	const candidates = source.bindings === void 0 ? [] : source.bindings;
-	const bindings = yield* Effect.forEach([...candidates], (registration) => snapshot(registration));
-	if (new Set(bindings.map((registration) => registration.name)).size !== bindings.length) return yield* invalidPlan();
-	return Object.freeze({
-		scripts: Object.freeze(data.scripts.map((script) => Object.freeze({
-			...script,
-			...script.origins === void 0 ? {} : { origins: Object.freeze([...script.origins]) },
-			...script.readiness === void 0 ? {} : { readiness: Object.freeze({ ...script.readiness }) }
-		}))),
-		permissions: Object.freeze(data.permissions.map((grant) => Object.freeze({
-			...grant,
-			permissions: Object.freeze([...grant.permissions])
-		}))),
-		...bindings.length === 0 ? {} : { bindings: Object.freeze(bindings) }
-	});
-});
-const rejected = () => {
-	const error = /* @__PURE__ */ new Error("Browser binding call rejected");
-	error.name = "BrowserbaseBindingError";
-	error.stack = "";
-	const result = Promise.reject(error);
-	result.catch(() => {});
-	return result;
-};
-const increment = (value) => Math.min(Number.MAX_SAFE_INTEGER, value + 1);
-/** The caller must pass preparePlan's snapshot; dependencies are captured at acquisition. */
-const makeBindings = Effect.fnUntraced(function* (plan) {
-	const consumer = yield* Effect.context();
-	const ownerScope = yield* Scope.fork(yield* Scope.Scope, "sequential");
-	const failure = yield* Deferred.make();
-	const connections = /* @__PURE__ */ new Set();
-	const failures = [];
-	let droppedFailures = 0;
-	let faulted = false;
-	let ownerClosed = false;
-	const entries = (plan.bindings ?? []).map((registration) => ({
-		registration,
-		state: {
-			name: registration.name,
-			inFlight: 0,
-			pendingNative: 0,
-			retired: 0,
-			accepted: 0,
-			succeeded: 0,
-			rejected: 0
-		}
-	}));
-	yield* Scope.addFinalizer(ownerScope, Effect.suspend(() => {
-		ownerClosed = true;
-		const owned = [...connections];
-		for (const connection of owned) connection.close();
-		return Effect.forEach(owned, (connection) => connection.dispose, { discard: true });
-	}));
-	const connect = Effect.fnUntraced(function* (onFault, isActive, isCurrent = isActive) {
-		const connectionScope = yield* Scope.fork(yield* Scope.Scope, "sequential");
-		let closed = ownerClosed || faulted;
-		const fences = [];
-		const current = () => !closed && !ownerClosed && !faulted && isCurrent();
-		const active = () => current() && isActive();
-		const close = () => {
-			closed = true;
-			for (const fence of fences) fence();
-		};
-		const record = (registration, cause) => {
-			if (failures.length === 32) {
-				failures.shift();
-				droppedFailures = increment(droppedFailures);
-			}
-			failures.push(Object.freeze({
-				name: registration.name,
-				mode: registration.failureMode,
-				cause
-			}));
-			if (registration.failureMode === "fail-session" && current()) {
-				faulted = true;
-				Deferred.doneUnsafe(failure, Effect.failCause(cause));
-				for (const connection of connections) connection.close();
-				onFault();
-			}
-		};
-		const bindings = yield* Effect.forEach(entries, ({ registration, state }) => Effect.gen(function* () {
-			const error = (reason, operation = "callback") => InitializationError.make({
-				operation,
-				step: registration.name,
-				reason
-			});
-			const release = (work) => {
-				if (!work.finished || work.pending !== 0 || work.released) return;
-				work.released = true;
-				state.inFlight--;
-				state.retired--;
-			};
-			const track = (work, promise) => {
-				work.pending++;
-				state.pendingNative++;
-				const settled = () => {
-					work.pending--;
-					state.pendingNative--;
-					release(work);
-				};
-				promise.then(settled, settled);
-				return promise;
-			};
-			const finish = (work) => {
-				if (work.finished) return;
-				work.finished = true;
-				state.retired++;
-				const disposing = Promise.resolve().then(() => work.call.dispose()).catch(() => {
-					record(registration, Cause.fail(error("native", "dispose")));
-				});
-				track(work, disposing);
-			};
-			const native = (work, action) => Effect.tryPromise({
-				try: (signal) => track(work, action(signal)),
-				catch: (cause) => Schema.is(InitializationError)(cause) ? error(cause.reason) : error("native")
-			});
-			const execute = Effect.fnUntraced(function* (work) {
-				const check = Effect.suspend(() => active() ? native(work, work.call.check) : Effect.fail(error("closed")));
-				if (!active()) return yield* error("closed");
-				const text = yield* native(work, work.call.read);
-				const result = yield* invoke(registration, text, check);
-				yield* check;
-				return result;
-			});
-			const runner = yield* makeBindingRunner(registration.maxConcurrent, (work) => Effect.scoped(execute(work)).pipe(Effect.timeoutOrElse({
-				duration: registration.timeoutMillis,
-				orElse: () => Effect.fail(error("timeout"))
-			}), Effect.provideContext(consumer)), () => {}).pipe(Scope.provide(connectionScope));
-			fences.push(runner.close);
-			const invoke$1 = (call) => {
-				if (!active()) {
-					state.rejected = increment(state.rejected);
-					return rejected();
-				}
-				if (state.inFlight >= registration.maxConcurrent) {
-					state.rejected = increment(state.rejected);
-					record(registration, Cause.fail(error("busy")));
-					return rejected();
-				}
-				state.inFlight++;
-				state.accepted = increment(state.accepted);
-				const work = {
-					call,
-					pending: 0,
-					finished: false,
-					released: false
-				};
-				const admission = runner.submit(work, "reject-call");
-				if (admission._tag === "Rejected") {
-					state.rejected = increment(state.rejected);
-					finish(work);
-					return rejected();
-				}
-				const result = admission.result.then((exit) => {
-					if (Exit.isFailure(exit)) {
-						state.rejected = increment(state.rejected);
-						record(registration, exit.cause);
-						return rejected();
-					}
-					if (!active()) {
-						state.rejected = increment(state.rejected);
-						return rejected();
-					}
-					state.succeeded = increment(state.succeeded);
-					return exit.value;
-				}, () => {
-					state.rejected = increment(state.rejected);
-					if (active()) record(registration, Cause.fail(error("native")));
-					return rejected();
-				}).finally(() => finish(work));
-				result.catch(() => {});
-				return result;
-			};
-			return Object.freeze({
-				name: registration.name,
-				origins: registration.origins,
-				maxConcurrent: registration.maxConcurrent,
-				maxInputBytes: registration.maxInputBytes,
-				timeoutMillis: registration.timeoutMillis,
-				invoke: invoke$1
-			});
-		}));
-		const connection = {
-			bindings: Object.freeze(bindings),
-			close,
-			reportFailure: (error) => {
-				if (!current()) return;
-				record({
-					name: error.step,
-					failureMode: "fail-session"
-				}, Cause.fail(error));
-			},
-			dispose: Effect.sync(close).pipe(Effect.andThen(Scope.close(connectionScope, Exit.void)))
-		};
-		connections.add(connection);
-		yield* Scope.addFinalizer(connectionScope, Effect.sync(() => {
-			close();
-			connections.delete(connection);
-		}));
-		return connection;
-	}, Effect.uninterruptible);
-	return {
-		failure: Deferred.await(failure),
-		diagnostics: Effect.sync(() => Object.freeze({
-			faulted,
-			bindings: Object.freeze(entries.map(({ state }) => Object.freeze({ ...state }))),
-			failures: Object.freeze([...failures]),
-			droppedFailures
-		})),
-		connect
-	};
-});
-//#endregion
-//#region src/internal/browser/PublicSession.ts
-const checked = (schema, value, operation) => Schema.decodeUnknownEffect(schema)(value, { onExcessProperty: "error" }).pipe(Effect.mapError(() => BrowserError.make({
-	operation,
-	reason: "configuration",
-	outcome: "undispatched"
-})));
-const decoded = (schema, operation) => (value) => Schema.decodeUnknownEffect(schema)(value).pipe(Effect.mapError(() => BrowserError.make({
-	operation,
-	reason: "malformed"
-})));
-const action = decoded(ActionResult, "action-result");
-const pointerMoved = decoded(InputReceipt, "pointer-move");
-const hovered = decoded(InputReceipt, "hover");
-const wheeled = decoded(InputReceipt, "wheel");
-const pressed = decoded(InputReceipt, "press");
-const typed = decoded(InputReceipt, "type");
-const makeTarget = (bound) => ({
-	navigate: (request) => checked(NavigateRequest, request, "navigate").pipe(Effect.flatMap((value) => bound.navigate(value.url)), Effect.flatMap((url) => decoded(NavigationResult, "navigate")({ url }))),
-	startNavigation: (request) => checked(StartNavigationRequest, request, "navigate").pipe(Effect.flatMap((value) => bound.startNavigation(value.url, value.timeoutMillis)), Effect.map((operation) => ({
-		target: operation.target,
-		completed: operation.completed.pipe(Effect.flatMap((url) => decoded(NavigationResult, "navigate")({ url }))),
-		stop: operation.stop
-	}))),
-	readText: (request) => checked(ReadTextRequest, request, "read-text").pipe(Effect.flatMap((value) => bound.readText(value.selector)), Effect.flatMap((text) => decoded(TextResult, "read-text")({ text }))),
-	click: (request) => checked(ClickRequest, request, "click").pipe(Effect.flatMap((value) => bound.click(value.selector)), Effect.flatMap((url) => action({ url }))),
-	fill: (request) => checked(FillRequest, request, "fill").pipe(Effect.flatMap((value) => bound.fill(value.selector, value.value)), Effect.flatMap((url) => action({ url }))),
-	scroll: (request) => checked(ScrollRequest, request, "scroll").pipe(Effect.flatMap((value) => bound.scroll(value.deltaX, value.deltaY)), Effect.flatMap((url) => action({ url }))),
-	pointerMove: (request) => checked(PointerMoveRequest, request, "pointer-move").pipe(Effect.flatMap((value) => bound.pointerMove(value.to)), Effect.flatMap((input) => pointerMoved({
-		...input,
-		kind: "pointer-move"
-	}))),
-	hover: (request) => checked(HoverRequest, request, "hover").pipe(Effect.flatMap((value) => bound.hover(value.selector)), Effect.flatMap((input) => hovered({
-		...input,
-		kind: "hover"
-	}))),
-	wheel: (request) => checked(WheelRequest, request, "wheel").pipe(Effect.flatMap((value) => bound.wheel(value.deltaX, value.deltaY, value.at).pipe(Effect.flatMap((input) => wheeled({
-		...input,
-		kind: "wheel",
-		delta: {
-			x: value.deltaX,
-			y: value.deltaY
-		}
-	}))))),
-	press: (request) => checked(PressRequest, request, "press").pipe(Effect.flatMap((value) => bound.press(value.key, value.modifiers ?? [], value.into)), Effect.flatMap((input) => pressed({
-		...input,
-		kind: "press"
-	}))),
-	type: (request) => checked(TypeRequest, request, "type").pipe(Effect.flatMap((value) => bound.type(value.text, value.into)), Effect.flatMap((input) => typed({
-		...input,
-		kind: "type"
-	}))),
-	screenshot: (request) => checked(ScreenshotRequest, request, "screenshot").pipe(Effect.flatMap((value) => bound.screenshot(value.fullPage)), Effect.flatMap((bytes) => decoded(ScreenshotResult, "screenshot")({
-		mediaType: "image/png",
-		bytes: new Uint8Array(bytes)
-	})))
-});
-/** A browser-operation failure keeps its meaning when it is reported as an initialization one. */
-const initialization = (reason) => reason === "busy" ? "busy" : reason === "closed" || reason === "disconnected" ? "closed" : reason === "timeout" ? "timeout" : reason === "stale" ? "stale" : reason === "unsupported" ? "unsupported" : reason === "configuration" ? "configuration" : "native";
-const makeSession = (controls, bindings) => {
-	const currentTarget = controls.currentTarget.pipe(Effect.map(() => makeTarget(controls.bind())));
-	const Wait = Schema.Struct({
-		selector: ClickRequest.fields.selector,
-		state: Schema.Literals([
-			"visible",
-			"hidden",
-			"attached",
-			"detached"
-		])
-	});
-	const navigate = (url) => action({ url });
-	const session = {
-		failure: bindings.failure,
-		bindingDiagnostics: bindings.diagnostics,
-		bind: () => makeTarget(controls.bind()),
-		currentTarget,
-		target: controls.currentTarget,
-		observe: (options = {}) => checked(ObservationOptions, options, "observe").pipe(Effect.flatMap((value) => controls.observe({
-			...value,
-			scope: value.scope ?? "document"
-		}))),
-		checkpoint: (options = {}) => checked(CheckpointOptions, options, "checkpoint").pipe(Effect.flatMap((value) => controls.checkpoint({
-			...value,
-			picture: value.picture ?? false
-		})), Effect.flatMap(({ picture, ...sampled }) => decoded(Checkpoint, "checkpoint")({
-			...sampled,
-			...picture === void 0 ? {} : { picture: {
-				mediaType: "image/png",
-				bytes: new Uint8Array(picture)
-			} }
-		}))),
-		controlFacts: (reference) => checked(ObservedElement, reference, "control-facts").pipe(Effect.flatMap(controls.controlFacts)),
-		revalidateElement: (reference) => checked(ObservedElement, reference, "revalidate").pipe(Effect.flatMap((value) => controls.revalidate(value).pipe(Effect.as(value)))),
-		clickElement: (reference, admission) => checked(ObservedElement, reference, "click").pipe(Effect.flatMap((value) => controls.bind().click(value, admission?.admit)), Effect.flatMap(navigate)),
-		fillElement: (reference, value, admission) => checked(ObservedElement, reference, "fill").pipe(Effect.flatMap((element) => checked(FillRequest.fields.value, value, "fill").pipe(Effect.flatMap((text) => controls.bind().fill(element, text, admission?.admit)))), Effect.flatMap(navigate)),
-		hoverElement: (reference, admission) => checked(ObservedElement, reference, "hover").pipe(Effect.flatMap((value) => controls.bind().hover(value, admission?.admit)), Effect.flatMap((input) => hovered({
-			...input,
-			kind: "hover"
-		}))),
-		pressElement: (reference, stroke, admission) => checked(ObservedElement, reference, "press").pipe(Effect.flatMap((element) => checked(KeyStroke, stroke, "press").pipe(Effect.flatMap((value) => controls.bind().press(value.key, value.modifiers ?? [], element, admission?.admit)))), Effect.flatMap((input) => pressed({
-			...input,
-			kind: "press"
-		}))),
-		typeElement: (reference, text, admission) => checked(ObservedElement, reference, "type").pipe(Effect.flatMap((element) => checked(TypeRequest.fields.text, text, "type").pipe(Effect.flatMap((value) => controls.bind().type(value, element, admission?.admit)))), Effect.flatMap((input) => typed({
-			...input,
-			kind: "type"
-		}))),
-		pages: controls.pages,
-		frames: controls.frames,
-		selectPage: (id) => checked(Identifier, id, "select-page").pipe(Effect.flatMap(controls.selectPage), Effect.andThen(currentTarget)),
-		selectFrame: (id) => checked(Identifier, id, "select-frame").pipe(Effect.flatMap(controls.selectFrame), Effect.andThen(currentTarget)),
-		createPage: controls.createPage(),
-		closePage: (id) => checked(Identifier, id, "close-page").pipe(Effect.flatMap(controls.closePage)),
-		resizeViewport: (viewport) => checked(Viewport, viewport, "resize").pipe(Effect.flatMap(controls.resize)),
-		waitFor: (request) => checked(Wait, request, "wait").pipe(Effect.flatMap((value) => controls.waitFor(value.selector, value.state))),
-		clickAndWait: (request) => checked(ClickRequest, request, "click-and-wait").pipe(Effect.flatMap((value) => controls.clickAndWait(value.selector)), Effect.flatMap((url) => action({ url }))),
-		ready: controls.readiness.pipe(Effect.mapError((error) => InitializationError.make({
-			operation: "ready",
-			step: "session",
-			reason: initialization(error.reason)
-		})), Effect.flatMap((state) => state._tag === "NotReady" ? Effect.fail(InitializationError.make({
-			operation: "ready",
-			step: state.step,
-			reason: state.reason === "failed" ? "output" : state.reason
-		})) : Effect.succeed({ _tag: state._tag })))
-	};
-	associate(session, controls.capture);
-	associatePageControl(session, controls.pageControl);
-	return session;
-};
-//#endregion
-//#region src/internal/session/Attachment.ts
-const failure = (reason) => SessionError.make({
-	operation: "session-attach",
-	reason,
-	outcome: "undispatched"
-});
-/**
-* Borrowing an already running session. This scope owns its local connection and nothing
-* else: no allocation attempt is made, no release is requested, and no Context-writer
-* authority is claimed. Whoever allocated the session keeps all three.
-*/
-const attachRemote = Effect.fnUntraced(function* (options, local = noLocalConnection, limits) {
-	const client = yield* BrowserbaseClient;
-	const sessions = yield* BrowserbaseSessions;
-	const parent = yield* Scope.Scope;
-	const pendingWaitMillis = options.pendingWaitMillis ?? 0;
-	if (!Number.isSafeInteger(pendingWaitMillis) || pendingWaitMillis < 0 || pendingWaitMillis > 6e5) return yield* failure("configuration");
-	const observed = yield* sessions.retrieve(options.reference);
-	if (isTerminalSessionStatus(observed.status)) return yield* failure("expired");
-	if (observed.status !== "RUNNING") {
-		if (pendingWaitMillis === 0) return yield* failure("active");
-		yield* sessions.waitUntilRunning(observed.reference, { timeoutMillis: pendingWaitMillis });
-	}
-	const reference = observed.reference;
-	return yield* Effect.uninterruptible(Effect.gen(function* () {
-		const resourceScope = yield* Scope.make();
-		let closing = false;
-		let cleanup;
-		const terminate = yield* Effect.cached(Effect.uninterruptible(Effect.gen(function* () {
-			closing = true;
-			yield* (yield* makeCleanup(reference, "borrowed", sessions, local, (result) => {
-				cleanup = result;
-			}, limits)).close;
-			if (cleanup !== void 0) yield* reportCleanup(cleanup);
-			if (cleanup !== void 0 && options.onCleanup !== void 0) yield* reported(options.onCleanup(cleanup));
-		})));
-		const closeScope = yield* Effect.cached(Scope.close(resourceScope, Exit.void));
-		yield* Scope.addFinalizer(resourceScope, terminate);
-		yield* Scope.addFinalizer(parent, closeScope);
-		return {
-			reference,
-			status: observed,
-			connection: (timeoutMillis) => Effect.suspend(() => closing ? Effect.fail(SessionError.make({
-				operation: "session-connect",
-				reason: "expired",
-				outcome: "undispatched"
-			})) : connectionAddress(client, sessions, reference, timeoutMillis)),
-			release: closeScope.pipe(Effect.andThen(Effect.suspend(() => cleanup === void 0 ? Effect.die(/* @__PURE__ */ new Error("Borrowed session closed without cleanup evidence")) : Effect.succeed(cleanup)))),
-			cleanupResult: Effect.sync(() => Option.fromNullishOr(cleanup))
-		};
-	}));
-});
-//#endregion
-//#region src/internal/browser/Owner.ts
-/** The browser domain's bounded step: one deadline, one declared BrowserError timeout. */
-const within = (effect, deadline, operation, onTimeout) => until(effect, deadline, () => {
-	onTimeout?.();
-	return BrowserError.make({
-		operation,
-		reason: "timeout"
-	});
-});
-const makeOwner = Effect.fnUntraced(function* (limits) {
-	const semaphore = yield* Semaphore.make(1);
-	const clock = yield* Clock.Clock;
-	const lifetimeDeadline = yield* deadlineAfter(limits.maxElapsedMillis);
-	const hooks = /* @__PURE__ */ new Set();
-	const state = {
-		phase: "acquiring",
-		generation: 0,
-		revision: 0,
-		selection: 0,
-		actions: 0
-	};
-	let active;
-	const reservations = /* @__PURE__ */ new Map();
-	const invalidate = (reason) => {
-		state.revision++;
-		for (const hook of hooks) hook(reason);
-	};
-	const fence = (phase, reason) => {
-		if (state.phase === "closed" || state.phase === "closing" && phase !== "closed" && phase !== "closing") return;
-		state.phase = phase;
-		state.generation++;
-		active?.abort();
-		for (const reservation of reservations.values()) reservation.abort();
-		reservations.clear();
-		invalidate(reason);
-	};
-	/** Taken under the permit that dispatched the work, so nothing can interleave before it. */
-	const reserve = (key) => {
-		const controller = new AbortController();
-		reservations.set(key, controller);
-		return {
-			signal: controller.signal,
-			settle: (outcome) => {
-				if (reservations.get(key) !== controller) return;
-				reservations.delete(key);
-				if (outcome === "unknown") fence("uncertain", "uncertain");
-			}
-		};
-	};
-	const guard = (operation, body, options = {}) => semaphore.withPermitsIfAvailable(1)(Effect.gen(function* () {
-		if (!(options.phases ?? ["open"]).includes(state.phase)) return yield* BrowserError.make({
-			operation,
-			reason: state.phase === "paused" ? "busy" : "closed",
-			outcome: "undispatched"
-		});
-		yield* options.preflight ?? Effect.void;
-		const now = yield* nowMillis;
-		if (now >= lifetimeDeadline) {
-			fence("uncertain", "uncertain");
-			return yield* BrowserError.make({
-				operation,
-				reason: "timeout",
-				outcome: "undispatched"
-			});
-		}
-		if (options.charge !== false) {
-			if (state.actions >= limits.maxActions) return yield* BrowserError.make({
-				operation,
-				reason: "limit",
-				outcome: "undispatched"
-			});
-			state.actions++;
-		}
-		const controller = new AbortController();
-		active = controller;
-		let dispatched = false;
-		const generation = state.generation;
-		const allowed = options.phases ?? ["open"];
-		const check = () => {
-			if (controller.signal.aborted || state.generation !== generation || !allowed.includes(state.phase)) throw BrowserError.make({
-				operation,
-				reason: "stale",
-				outcome: dispatched ? "unknown" : "undispatched"
-			});
-		};
-		const ticket = {
-			signal: controller.signal,
-			deadline: Math.min(now + limits.actionTimeoutMillis, lifetimeDeadline),
-			generation,
-			remainingMillis: () => Math.max(1, Math.min(now + limits.actionTimeoutMillis, lifetimeDeadline) - Number(clock.monotonicTimeNanosUnsafe()) / 1e6),
-			get dispatched() {
-				return dispatched;
-			},
-			check,
-			dispatch() {
-				check();
-				if (!dispatched && options.mutation) invalidate("observation");
-				dispatched = true;
-			}
-		};
-		const uncertain = () => {
-			controller.abort();
-			if (dispatched && state.phase !== "closing" && state.phase !== "closed") fence("uncertain", "uncertain");
-		};
-		return yield* within(body(ticket), ticket.deadline, operation, uncertain).pipe(Effect.tap((_) => options.verifyAfter === false ? Effect.void : Effect.try({
-			try: check,
-			catch: () => BrowserError.make({
-				operation,
-				reason: "stale",
-				outcome: dispatched ? "unknown" : "undispatched"
-			})
-		})), Effect.catch((error) => {
-			if (dispatched) uncertain();
-			if (!Schema.is(BrowserError)(error)) return Effect.fail(error);
-			return Effect.fail(BrowserError.make({
-				operation,
-				reason: error.reason,
-				outcome: error.outcome ?? (dispatched ? "unknown" : "undispatched"),
-				...error.status === void 0 ? {} : { status: error.status },
-				...error.retryAfterMillis === void 0 ? {} : { retryAfterMillis: error.retryAfterMillis }
-			}));
-		}), Effect.onInterrupt(() => Effect.sync(uncertain)), Effect.ensuring(Effect.sync(() => {
-			controller.abort();
-			if (active === controller) active = void 0;
-		})));
-	})).pipe(Effect.flatMap(Effect.fromOption(() => BrowserError.make({
-		operation,
-		reason: "busy",
-		outcome: "undispatched"
-	}))));
-	/** Lifecycle transitions are performed while holding guard's permit; close alone preempts it. */
-	return {
-		state,
-		lifetimeDeadline,
-		guard,
-		reserve,
-		reserved: (key) => reservations.has(key),
-		invalidate,
-		fence,
-		onInvalidate(hook) {
-			hooks.add(hook);
-			return () => {
-				hooks.delete(hook);
-			};
-		}
-	};
-});
-/** Without a native answer, whether the step was sent is all the owner knows about it. */
-const unsettled = (ticket) => ({
-	reason: "provider",
-	outcome: ticket.dispatched ? "unknown" : "undispatched"
-});
-/**
-* The one place a native step becomes a public error: whatever the driver raised, the caller
-* sees the operation it asked for.
-*/
-const native = (operation, ticket, body) => Effect.callback((resume) => {
-	let done = false;
-	const cleanup = () => {
-		done = true;
-		ticket.signal.removeEventListener("abort", abort);
-	};
-	const abort = () => {
-		if (done) return;
-		cleanup();
-		resume(Effect.fail(BrowserError.make({
-			operation,
-			reason: "stale",
-			outcome: ticket.dispatched ? "unknown" : "undispatched"
-		})));
-	};
-	ticket.signal.addEventListener("abort", abort, { once: true });
-	try {
-		ticket.check();
-		body().then((value) => {
-			if (!done) {
-				cleanup();
-				resume(Effect.succeed(value));
-			}
-		}, (error) => {
-			if (!done) {
-				cleanup();
-				resume(Effect.fail(publicError(error, operation, unsettled(ticket))));
-			}
-		});
-	} catch (error) {
-		cleanup();
-		resume(Effect.fail(publicError(error, operation, unsettled(ticket))));
-	}
-	return Effect.sync(cleanup);
-});
-//#endregion
-//#region src/internal/browser/Session.ts
-/** Allocates the session, and therefore owns releasing it. */
-const providerControls = (client, sessions, reference) => ({
-	liveView: (ttl) => issueLiveView(client, reference, ttl),
-	verifyReconnect: sessions.retrieve(reference).pipe(Effect.mapError((error) => BrowserError.make({
-		operation: "reconnect",
-		reason: error.reason
-	})), Effect.flatMap((status) => status.status === "RUNNING" ? Effect.void : Effect.fail(BrowserError.make({
-		operation: "reconnect",
-		reason: "expired"
-	}))))
-});
-const ownedRemote = (options) => (local, lifetimeDeadline) => Effect.gen(function* () {
-	const client = yield* BrowserbaseClient;
-	const sessions = yield* BrowserbaseSessions;
-	const acquired = yield* acquireRemote({
-		launch: options.launch,
-		...options.contextWriter === void 0 ? {} : { contextWriter: options.contextWriter },
-		allocationDeadline: lifetimeDeadline,
-		...options.onCleanup === void 0 ? {} : { onCleanup: options.onCleanup },
-		...options.onAllocationUncertain === void 0 ? {} : { onAllocationUncertain: options.onAllocationUncertain }
-	}, local);
-	return {
-		...acquired,
-		...providerControls(client, sessions, acquired.reference)
-	};
-});
-/** Borrows a running session: local connection only, and never a release request. */
-const borrowedRemote = (options) => (local) => Effect.gen(function* () {
-	const client = yield* BrowserbaseClient;
-	const sessions = yield* BrowserbaseSessions;
-	const acquired = yield* attachRemote(options, local);
-	return {
-		...acquired,
-		...providerControls(client, sessions, acquired.reference)
-	};
-});
-/**
-* The one owned browser. Remote allocation, release and terminal observation belong to the
-* canonical control plane; this owner supplies only the local connection's cleanup evidence.
-*/
-const acquireSession = Effect.fnUntraced(function* (limits, options) {
-	const engine = options.engine ?? bindingImplementation(yield* BrowserbaseBrowserBinding);
-	if (engine === void 0) return yield* BrowserError.make({
-		operation: "connect",
-		reason: "configuration",
-		outcome: "undispatched"
-	});
-	const parentScope = yield* Scope.Scope;
-	const bindingLifetime = yield* Scope.fork(parentScope, "sequential");
-	const ended = yield* Deferred.make();
-	const owner = yield* makeOwner(limits);
-	const clock = yield* Clock.Clock;
-	let driver;
-	let connectPending = false;
-	let activeConnection;
-	let handoffToken;
-	let reconnectTarget;
-	let activeBindings;
-	const fenceBindings = () => {
-		activeBindings?.close();
-		driver?.fenceInitialization?.();
-	};
-	const disposeBindings = Effect.gen(function* () {
-		const connection = activeBindings;
-		activeBindings = void 0;
-		const callbacks = yield* Effect.exit(connection?.dispose ?? Effect.void);
-		const registrations = yield* Effect.tryPromise({
-			try: () => driver?.disposeInitialization?.() ?? Promise.resolve(),
-			catch: () => BrowserError.make({
-				operation: "close",
-				reason: "provider"
-			})
-		}).pipe(Effect.exit);
-		if (Exit.isFailure(callbacks)) return yield* Effect.failCause(callbacks.cause);
-		if (Exit.isFailure(registrations)) return yield* Effect.failCause(registrations.cause);
-	});
-	const capture = {
-		owner,
-		target: () => {
-			if (driver === void 0) throw BrowserError.make({
-				operation: "target",
-				reason: "closed"
-			});
-			return Target.make({
-				generation: owner.state.generation,
-				...driver.selected()
-			});
-		},
-		resolve: (ticket, requested) => native("capture-start", ticket, async () => {
-			if (driver === void 0) throw BrowserError.make({
-				operation: "capture",
-				reason: "closed"
-			});
-			const binding = await driver.capture(requested);
-			return {
-				key: binding.targetId,
-				target: Target.make({
-					generation: owner.state.generation,
-					pageId: binding.pageId,
-					frameId: binding.frameId
-				}),
-				source: binding.source
-			};
-		}),
-		captureLeases: /* @__PURE__ */ new Map(),
-		captureReservedBytes: 0
-	};
-	owner.onInvalidate((reason) => {
-		driver?.invalidateObservation();
-		if ([
-			"disconnected",
-			"uncertain",
-			"closed"
-		].includes(reason)) fenceBindings();
-		if ([
-			"paused",
-			"disconnected",
-			"uncertain",
-			"closed"
-		].includes(reason)) for (const lease of capture.captureLeases.values()) lease.invalidate(reason);
-	});
-	/**
-	* The local half of cleanup. Each step is an independent fact for the canonical
-	* coordinator, which owns the release request and the terminal status observation.
-	*/
-	const local = {
-		fence: Effect.sync(() => {
-			owner.fence("closing", "closed");
-			handoffToken = void 0;
-			activeConnection = void 0;
-			Deferred.doneUnsafe(ended, Effect.void);
-		}),
-		capture: Effect.suspend(() => Effect.forEach([...capture.captureLeases.values()], (lease) => lease.stop, { discard: true })),
-		initialization: disposeBindings,
-		disconnect: Effect.suspend(() => {
-			const acquired = driver;
-			driver = void 0;
-			if (acquired === void 0) return Effect.succeed(connectPending ? "pending" : "not-connected");
-			return Effect.tryPromise({
-				try: () => acquired.disconnect(),
-				catch: () => BrowserError.make({
-					operation: "disconnect",
-					reason: "provider"
-				})
-			}).pipe(Effect.as("closed"));
-		}).pipe(Effect.ensuring(Effect.sync(() => {
-			owner.state.phase = "closed";
-		})))
-	};
-	const acquired = yield* options.remote(local, owner.lifetimeDeadline);
-	const ref = acquired.reference;
-	const release = acquired.release;
-	const cleanupResult = acquired.cleanupResult;
-	const closeScope = acquired.release.pipe(Effect.ensuring(Deferred.succeed(ended, void 0)), Effect.asVoid);
-	const connectionEvents = (connectionLease) => ({
-		invalidate: (reason) => {
-			if (activeConnection === connectionLease) owner.invalidate(reason);
-		},
-		disconnected: () => {
-			if (activeConnection !== connectionLease) return;
-			if (owner.state.phase !== "closing" && owner.state.phase !== "closed" && owner.state.phase !== "detached") owner.fence("uncertain", "disconnected");
-		},
-		pause: () => {
-			if (activeConnection !== connectionLease) return;
-			if (owner.state.phase === "open") owner.fence("paused", "paused");
-			else if (owner.state.phase === "acquiring") owner.fence("uncertain", "uncertain");
-		},
-		fault: () => {
-			if (activeConnection !== connectionLease) return;
-			if (owner.state.phase !== "closing" && owner.state.phase !== "closed") owner.fence("uncertain", "uncertain");
-		}
-	});
-	const connectNative = (url, nativeOptions) => Effect.uninterruptibleMask((restore) => Effect.gen(function* () {
-		const connectionLease = {};
-		activeConnection = connectionLease;
-		connectPending = true;
-		const events = connectionEvents(connectionLease);
-		const bindings = options.connectBindings === void 0 ? void 0 : yield* options.connectBindings(events.fault, () => activeConnection === connectionLease && (owner.state.phase === "acquiring" || owner.state.phase === "open"), () => activeConnection === connectionLease && [
-			"acquiring",
-			"open",
-			"paused"
-		].includes(owner.state.phase)).pipe(Scope.provide(bindingLifetime));
-		activeBindings = bindings;
-		const retired = () => activeConnection !== connectionLease || [
-			"closing",
-			"closed",
-			"uncertain"
-		].includes(owner.state.phase);
-		if (retired()) {
-			bindings?.close();
-			yield* bindings?.dispose ?? Effect.void;
-			return yield* BrowserError.make({
-				operation: "connect",
-				reason: "closed"
-			});
-		}
-		const acquired = yield* restore(engine.connect({
-			connection: Redacted.value(url),
-			options: {
-				...nativeOptions,
-				...bindings === void 0 ? {} : {
-					bindings: bindings.bindings,
-					onBindingFault: bindings.reportFailure
-				}
-			},
-			events,
-			onAbandoned: () => bindings?.close(),
-			onSettled: () => {
-				if (activeConnection === connectionLease) connectPending = false;
-			}
-		}));
-		driver = acquired;
-		if (activeConnection !== connectionLease || owner.state.phase === "closed" || owner.state.phase === "closing" || owner.state.phase === "uncertain") {
-			yield* Effect.tryPromise({
-				try: () => acquired.disconnect(),
-				catch: () => BrowserError.make({
-					operation: "connect",
-					reason: "provider"
-				})
-			}).pipe(Effect.ignore);
-			driver = void 0;
-			return yield* BrowserError.make({
-				operation: "connect",
-				reason: "closed"
-			});
-		}
-		return acquired;
-	}));
-	const getDriver = () => {
-		if (driver === void 0) throw BrowserError.make({
-			operation: "target",
-			reason: "closed",
-			outcome: "undispatched"
-		});
-		return driver;
-	};
-	/**
-	* Work that depends on an initialized document waits for the current document's readiness.
-	* Navigation, selection and page management deliberately do not: initialization must never
-	* deadlock the navigation that produces the document it is waiting for.
-	*/
-	const dependent = [
-		"read-text",
-		"checkpoint",
-		"control-facts",
-		"revalidate",
-		"click",
-		"fill",
-		"scroll",
-		"pointer-move",
-		"hover",
-		"wheel",
-		"press",
-		"type",
-		"screenshot",
-		"observe",
-		"wait",
-		"click-and-wait",
-		"download-action",
-		"select-files",
-		"file-chooser"
-	];
-	const requireReady = async (operation, ticket) => {
-		if (!dependent.includes(operation)) return;
-		const state = await getDriver().documentReadiness(ticket);
-		if (state._tag === "Ready" || state._tag === "NotApplicable") return;
-		throw BrowserError.make({
-			operation,
-			reason: state._tag === "RequiresNavigation" || state.reason === "stale" ? "stale" : state.reason === "timeout" ? "timeout" : "failed",
-			outcome: "undispatched"
-		});
-	};
-	/**
-	* `dependent` is false for lifecycle observations, which report what is actually on the
-	* reattached page. Readiness governs work that depends on initialization, not the reading
-	* that tells a caller whether this document was initialized at all.
-	*/
-	const observeInside = (ticket, maximumBytes = Math.min(options.maxReturnedBytes, 16384), controls = 32, dependent = true, scope = "document") => Effect.suspend(() => {
-		const revision = owner.state.revision;
-		return native("observe", ticket, async () => {
-			await getDriver().pageControl?.checkSelected(ticket);
-			if (dependent) await requireReady("observe", ticket);
-			return getDriver().observe(scope, maximumBytes, controls, ticket);
-		}).pipe(Effect.flatMap((raw) => Effect.gen(function* () {
-			if (owner.state.revision !== revision) return yield* BrowserError.make({
-				operation: "observe",
-				reason: "stale"
-			});
-			const result = yield* Effect.try({
-				try: () => Observation.make({
-					...raw,
-					target: capture.target(),
-					revision
-				}),
-				catch: (error) => publicError(error, "observe", { reason: "malformed" })
-			});
-			const encoded = yield* Schema.encodeEffect(Schema.fromJsonString(Observation))(result).pipe(Effect.mapError(() => BrowserError.make({
-				operation: "observe",
-				reason: "malformed"
-			})));
-			if (new TextEncoder().encode(encoded).length > options.maxReturnedBytes) return yield* BrowserError.make({
-				operation: "observe",
-				reason: "limit"
-			});
-			return result;
-		})));
-	});
-	/** A requested text bound may narrow the policy's bound, never widen it. */
-	const textBudget = (operation, requested) => {
-		const bytes = requested ?? Math.min(options.maxReturnedBytes, 16384);
-		return bytes > options.maxReturnedBytes ? Effect.fail(BrowserError.make({
-			operation,
-			reason: "configuration",
-			outcome: "undispatched"
-		})) : Effect.succeed(bytes);
-	};
-	const readSelected = owner.guard("target", () => Effect.try({
-		try: capture.target,
-		catch: () => BrowserError.make({
-			operation: "target",
-			reason: "closed",
-			outcome: "undispatched"
-		})
-	}), { charge: false });
-	/**
-	* While a navigation is in flight on the selected page, nothing else may change that page.
-	* Reads, checkpoints, holds and every other page proceed.
-	*/
-	const unreserved = (operation) => Effect.suspend(() => {
-		let pageId;
-		try {
-			pageId = driver?.selected().pageId;
-		} catch {}
-		return pageId !== void 0 && owner.reserved(pageId) ? Effect.fail(BrowserError.make({
-			operation,
-			reason: "busy",
-			outcome: "undispatched"
-		})) : Effect.void;
-	});
-	const nativeOperation = (operation, action, options = {}) => owner.guard(operation, (ticket) => native(operation, ticket, async () => {
-		if ([
-			"resize",
-			"wait",
-			"click-and-wait",
-			"download-action",
-			"select-files",
-			"file-chooser",
-			"checkpoint",
-			"control-facts",
-			"revalidate"
-		].includes(operation)) await getDriver().pageControl?.checkSelected(ticket);
-		await requireReady(operation, ticket);
-		return action(getDriver(), ticket);
-	}), {
-		...options,
-		...options.mutation === true && options.anyPage !== true ? { preflight: unreserved(operation) } : {}
-	});
-	/** A bound handle captures the page selection and connection generation, never the current DOM. */
-	const bind = () => {
-		const generation = owner.state.generation, selection = owner.state.selection;
-		const check = () => {
-			if (owner.state.generation !== generation || owner.state.selection !== selection) return Effect.fail(BrowserError.make({
-				operation: "handle",
-				reason: "stale",
-				outcome: "undispatched"
-			}));
-			return Effect.void;
-		};
-		const run = (operation, action, mutation = false) => owner.guard(operation, (ticket) => native(operation, ticket, async () => {
-			await getDriver().pageControl?.checkSelected(ticket);
-			await requireReady(operation, ticket);
-			return action(getDriver(), ticket);
-		}), {
-			mutation,
-			preflight: mutation ? Effect.suspend(check).pipe(Effect.andThen(unreserved(operation))) : Effect.suspend(check)
-		});
-		/**
-		* Native input, stamped on the host monotonic clock that stamps captured frames, around
-		* the native command alone: admission and readiness are over before the clock is read.
-		*/
-		const input = (operation, action) => run(operation, async (driver, ticket) => {
-			const target = capture.target();
-			const startedMonotonicNanos = clock.monotonicTimeNanosUnsafe();
-			return {
-				...await action(driver, ticket),
-				target,
-				startedMonotonicNanos,
-				completedMonotonicNanos: clock.monotonicTimeNanosUnsafe()
-			};
-		}, true);
-		/**
-		* Dispatches under a short permit and leaves the browser loading outside it. The reservation
-		* is taken under that same permit, so no other mutation can reach the page in between, and
-		* it is released only on a known outcome: an unsettled operation whose scope closes, or a
-		* navigation that fails after dispatch, fences the owner exactly as an interrupted mutation
-		* always has. Interrupting a waiter on `completed` stops nothing; `stop` is the one way to.
-		*/
-		const startNavigation = Effect.fnUntraced(function* (url, timeoutMillis = limits.actionTimeoutMillis) {
-			const begun = yield* run("navigate", async (driver, ticket) => {
-				const target = capture.target();
-				const navigation = await driver.beginNavigation(url, timeoutMillis, ticket);
-				return {
-					target,
-					navigation,
-					reservation: owner.reserve(navigation.pageId)
-				};
-			}, true);
-			const { navigation, reservation } = begun;
-			const outcome = yield* Deferred.make();
-			const failed = (reason) => Effect.fail(BrowserError.make({
-				operation: "navigate",
-				reason,
-				outcome: "unknown"
-			}));
-			/**
-			* A navigation has exactly one outcome, and whoever decides it first settles the
-			* reservation. It is released before anyone waiting is told, so the operation a waiter
-			* runs next is admitted rather than finding its own page still reserved.
-			*/
-			const decide = (result, known) => {
-				if (Deferred.isDoneUnsafe(outcome)) return;
-				reservation.settle(known ? "known" : "unknown");
-				Deferred.doneUnsafe(outcome, result);
-			};
-			navigation.settled.then((url) => decide(Effect.succeed(url), true), (error) => decide(Effect.fail(publicError(error, "navigate", {
-				reason: "provider",
-				outcome: "unknown"
-			})), false));
-			reservation.signal.addEventListener("abort", () => decide(failed("stale"), true), { once: true });
-			yield* Effect.addFinalizer(() => Effect.sync(() => decide(failed("stale"), false)));
-			return {
-				target: begun.target,
-				completed: Deferred.await(outcome),
-				/**
-				* The browser's acknowledgement is the known outcome. Playwright's own promise is not
-				* waited for: an aborted parse fires no DOMContentLoaded, so it only ever times out.
-				*/
-				stop: Effect.tryPromise({
-					try: () => navigation.stop(),
-					catch: (error) => publicError(error, "navigate-stop", {
-						reason: "provider",
-						outcome: "unknown"
-					})
-				}).pipe(Effect.timeoutOrElse({
-					duration: 3e3,
-					orElse: () => Effect.fail(BrowserError.make({
-						operation: "navigate-stop",
-						reason: "timeout",
-						outcome: "unknown"
-					}))
-				}), Effect.tap(() => Effect.sync(() => decide(failed("interrupted"), true))))
-			};
-		});
-		return {
-			startNavigation,
-			navigate: (url) => Effect.scoped(startNavigation(url).pipe(Effect.flatMap((operation) => operation.completed))),
-			readText: (selector) => run("read-text", (driver, ticket) => driver.readText(selector, options.maxReturnedBytes, ticket)),
-			click: (target, policy) => run("click", (driver, ticket) => driver.click(target, ticket, policy), true),
-			fill: (target, value, policy) => run("fill", (driver, ticket) => driver.fill(target, value, ticket, policy), true),
-			scroll: (x, y) => run("scroll", (driver, ticket) => driver.scroll(x, y, ticket), true),
-			pointerMove: (to) => input("pointer-move", (driver, ticket) => driver.pointerMove(to, ticket)),
-			hover: (target, policy) => input("hover", (driver, ticket) => driver.hover(target, ticket, policy)),
-			wheel: (deltaX, deltaY, at) => input("wheel", (driver, ticket) => driver.wheel(deltaX, deltaY, at, ticket)),
-			press: (key, modifiers, into, policy) => input("press", (driver, ticket) => driver.press(key, modifiers, into, ticket, policy)),
-			type: (text, into, policy) => input("type", (driver, ticket) => driver.type(text, into, ticket, policy)),
-			screenshot: (full) => run("screenshot", (driver, ticket) => driver.screenshot(full, options.maxReturnedBytes, ticket))
-		};
-	};
-	/**
-	* The remaining execution lifetime bounds waiting for a RUNNING session and its endpoint,
-	* within the resource service's own maximum wait. A long business budget does not become
-	* an invalid provider-wait configuration.
-	*/
-	const remainingMillis = () => Math.min(6e5, Math.max(1, Math.ceil(owner.lifetimeDeadline - Number(clock.monotonicTimeNanosUnsafe()) / 1e6)));
-	const connectionUrl = (operation) => Effect.suspend(() => acquired.connection(remainingMillis())).pipe(Effect.mapError((error) => BrowserError.make({
-		operation,
-		reason: error.reason
-	})));
-	const connected = yield* Effect.cached(owner.guard("connect", (ticket) => connectionUrl("connect").pipe(Effect.flatMap((url) => connectNative(url, options.driver)), Effect.andThen(native("connect", ticket, async () => {
-		getDriver().selected();
-	})), Effect.tap(() => Effect.sync(() => {
-		owner.state.phase = "open";
-	}))), {
-		phases: ["acquiring"],
-		charge: false,
-		verifyAfter: false
-	}).pipe(Effect.onError(() => closeScope), Effect.onInterrupt(() => closeScope)));
-	const execution = () => {
-		const port = getDriver().pageControl;
-		if (port === void 0) throw BrowserError.make({
-			operation: "page-control",
-			reason: "unsupported",
-			outcome: "undispatched"
-		});
-		return port;
-	};
-	const controls = {
-		pageControl: {
-			state: (page) => nativeOperation("page-state", (_driver, ticket) => execution().state(page, ticket), { charge: false }),
-			suspend: (page) => nativeOperation("page-suspend", (_driver, ticket) => execution().suspend(page, ticket), { charge: false }),
-			resume: (receipt) => nativeOperation("page-resume", (_driver, ticket) => execution().resume(receipt, ticket), { charge: false })
-		},
-		reference: ref,
-		capture,
-		bind,
-		currentTarget: readSelected,
-		cleanupResult,
-		close: release,
-		observe: (reading = { scope: "document" }) => textBudget("observe", reading.maxTextBytes).pipe(Effect.flatMap((bytes) => owner.guard("observe", (ticket) => observeInside(ticket, bytes, reading.maxControls ?? 32, true, reading.scope)))),
-		/**
-		* Passive: not a mutation, so the action observation and the selection are left exactly as
-		* they were. A held page is refused rather than woken to be read.
-		*/
-		checkpoint: (reading) => textBudget("checkpoint", reading.maxTextBytes).pipe(Effect.flatMap((bytes) => nativeOperation("checkpoint", async (driver, ticket) => {
-			const target = capture.target();
-			const revision = owner.state.revision;
-			const startedMonotonicNanos = clock.monotonicTimeNanosUnsafe();
-			return {
-				...await driver.checkpoint(bytes, reading.maxControls ?? 32, reading.picture ? options.maxReturnedBytes : void 0, ticket),
-				target,
-				revision,
-				startedMonotonicNanos,
-				completedMonotonicNanos: clock.monotonicTimeNanosUnsafe()
-			};
-		}))),
-		controlFacts: (reference) => nativeOperation("control-facts", (driver, ticket) => driver.controlFacts(reference, ticket)),
-		/** Not charged: it sends no input and reads one node the caller was already given. */
-		revalidate: (reference) => nativeOperation("revalidate", (driver, ticket) => driver.revalidate(reference, ticket), { charge: false }),
-		readiness: owner.guard("ready", (ticket) => native("ready", ticket, () => getDriver().documentReadiness(ticket)), { charge: false }),
-		pages: nativeOperation("list-pages", (driver, ticket) => driver.listPages(ticket), { charge: false }),
-		frames: nativeOperation("list-frames", (driver, ticket) => driver.listFrames(ticket), { charge: false }),
-		selectPage: (id) => nativeOperation("select-page", async (driver, ticket) => {
-			await driver.selectPage(id, ticket);
-			owner.state.selection++;
-		}, { charge: false }),
-		selectFrame: (id) => nativeOperation("select-frame", async (driver, ticket) => {
-			await driver.selectFrame(id, ticket);
-			owner.state.selection++;
-		}, { charge: false }),
-		createPage: () => nativeOperation("new-page", (driver, ticket) => driver.newPage(ticket), {
-			mutation: true,
-			charge: false,
-			anyPage: true
-		}),
-		closePage: (id) => nativeOperation("close-page", (driver, ticket) => driver.closePage(id, ticket), {
-			mutation: true,
-			charge: false,
-			anyPage: true
-		}),
-		resize: (viewport) => nativeOperation("resize", (driver, ticket) => driver.resize(viewport, ticket), {
-			mutation: true,
-			charge: false
-		}),
-		waitFor: (selector, state) => nativeOperation("wait", (driver, ticket) => driver.waitFor(selector, state, ticket)),
-		clickAndWait: (target) => nativeOperation("click-and-wait", (driver, ticket) => driver.clickAndWait(target, ticket), { mutation: true }),
-		clickForDownload: (target) => nativeOperation("download-action", (driver, ticket) => driver.clickForDownload(target, ticket), { mutation: true }),
-		selectFiles: (target, files) => nativeOperation("select-files", (driver, ticket) => driver.selectFiles(target, files, ticket), { mutation: true }),
-		clickForFileSelection: (target, files) => nativeOperation("file-chooser", (driver, ticket) => driver.clickForFileSelection(target, files, ticket), { mutation: true }),
-		liveView: (ttl) => owner.guard("live-view", () => acquired.liveView === void 0 ? Effect.fail(BrowserError.make({
-			operation: "live-view",
-			reason: "unsupported",
-			outcome: "undispatched"
-		})) : acquired.liveView(ttl), {
-			charge: false,
-			phases: ["open", "paused"]
-		}),
-		beginHandoff: (ttl) => owner.guard("handoff", () => Effect.gen(function* () {
-			if (options.driver.pageControl || acquired.liveView === void 0) return yield* BrowserError.make({
-				operation: "handoff",
-				reason: "unsupported",
-				outcome: "undispatched"
-			});
-			if (owner.state.phase === "open") owner.fence("paused", "paused");
-			handoffToken ??= globalThis.crypto.randomUUID();
-			const view = yield* acquired.liveView(ttl);
-			return {
-				token: Redacted.make(handoffToken),
-				view
-			};
-		}), {
-			charge: false,
-			phases: ["open", "paused"],
-			verifyAfter: false
-		}),
-		resume: (token, operatorReleasedControl) => owner.guard("resume", (ticket) => Effect.gen(function* () {
-			if (!operatorReleasedControl || handoffToken === void 0 || Redacted.value(token) !== handoffToken) return yield* BrowserError.make({
-				operation: "resume",
-				reason: "authorization",
-				outcome: "undispatched"
-			});
-			yield* native("resume", ticket, () => getDriver().dismissDialogs(ticket));
-			const observation = yield* observeInside(ticket, void 0, void 0, false);
-			owner.state.phase = "open";
-			handoffToken = void 0;
-			return observation;
-		}), {
-			charge: false,
-			phases: ["paused"],
-			verifyAfter: false
-		}),
-		detach: owner.guard("detach", (ticket) => Effect.gen(function* () {
-			if (!options.keepAlive) return yield* BrowserError.make({
-				operation: "detach",
-				reason: "unsupported",
-				outcome: "undispatched"
-			});
-			reconnectTarget = yield* native("detach", ticket, () => getDriver().selectedTargetId());
-			const attached = getDriver();
-			activeConnection = void 0;
-			owner.fence("detached", "disconnected");
-			const initialization = yield* Effect.exit(disposeBindings);
-			const disconnected = yield* Effect.tryPromise({
-				try: () => attached.disconnect(),
-				catch: () => BrowserError.make({
-					operation: "detach",
-					reason: "disconnected"
-				})
-			}).pipe(Effect.exit);
-			driver = void 0;
-			if (Exit.isFailure(initialization)) return yield* Effect.failCause(initialization.cause);
-			if (Exit.isFailure(disconnected)) return yield* Effect.failCause(disconnected.cause);
-			return {
-				reference: ref,
-				targetId: reconnectTarget
-			};
-		}), {
-			charge: false,
-			verifyAfter: false
-		}).pipe(Effect.onError(() => Effect.sync(() => owner.fence("uncertain", "uncertain")))),
-		reconnect: (operatorReleasedControl) => owner.guard("reconnect", (ticket) => Effect.gen(function* () {
-			if (!options.keepAlive || reconnectTarget === void 0 || !operatorReleasedControl || acquired.verifyReconnect === void 0) return yield* BrowserError.make({
-				operation: "reconnect",
-				reason: "unsupported",
-				outcome: "undispatched"
-			});
-			yield* acquired.verifyReconnect;
-			owner.state.phase = "acquiring";
-			const endpoint = yield* connectionUrl("reconnect");
-			yield* connectNative(endpoint, {
-				...options.driver,
-				initialTargetId: reconnectTarget,
-				newPage: false,
-				preserveViewport: true
-			});
-			const observation = yield* observeInside(ticket, void 0, void 0, false);
-			owner.state.phase = "open";
-			return observation;
-		}), {
-			charge: false,
-			phases: ["detached", "acquiring"],
-			verifyAfter: false
-		}).pipe(Effect.onError(() => closeScope), Effect.onInterrupt(() => closeScope))
-	};
-	const remaining = Math.max(0, owner.lifetimeDeadline - Number(clock.monotonicTimeNanosUnsafe()) / 1e6);
-	yield* Effect.raceFirst(Effect.sleep(remaining).pipe(Effect.as(true)), Deferred.await(ended).pipe(Effect.as(false))).pipe(Effect.flatMap((expired) => expired ? closeScope : Effect.void), Effect.forkIn(parentScope));
-	return {
-		reference: ref,
-		/** The caller keeps its own lease type, including whether an allocation attempt exists. */
-		lease: acquired,
-		close: controls.close,
-		connect: Effect.suspend(() => owner.state.phase === "closed" || owner.state.phase === "closing" ? Effect.fail(BrowserError.make({
-			operation: "connect",
-			reason: "closed",
-			outcome: "undispatched"
-		})) : connected.pipe(Effect.as(controls)))
-	};
-});
-//#endregion
-export { decoded as a, preparePlan as c, checked as i, compileBootstrap as l, borrowedRemote as n, makeSession as o, ownedRemote as r, makeBindings as s, acquireSession as t };
-
-//# sourceMappingURL=Session-D4nT9hOO.mjs.map