effect-browserbase 0.2.0-beta.8 → 0.3.0-beta.5

package/dist/Browserbase-FDltiz36.mjs

@@ -0,0 +1,542 @@
+import { t as __exportAll } from "./rolldown-runtime-D7D4PA-g.mjs";
+import { BrowserbaseError, Decode, InvalidRequest, isTransient } from "./BrowserbaseError.mjs";
+import { BrowserbaseClient } from "./BrowserbaseClient.mjs";
+import { ContextHeld, ContextLease } from "./ContextLease.mjs";
+import { DateTime, Duration, Effect, Exit, Layer, Option, Random, Redacted, Schedule, Schema, Scope, Semaphore } from "effect";
+import * as Browser from "effect-browser/Browser";
+import { BrowserError, Closed, Failed } from "effect-browser/BrowserError";
+import * as Cdp from "effect-browser/Cdp";
+import * as Supervisor from "effect-browser/Supervisor";
+//#region src/internal/captureConnection.ts
+/**
+* The capture connection: a second DevTools connection to a session, for its pages' screencasts
+* alone. A frame and its acknowledgement then never wait behind a large message on the
+* connection Playwright drives the pages over, such as an upload or a read's answer: Browserbase
+* refuses compression, and on air those waits stopped the picture for as long as the message took
+* to cross.
+*
+* Raw CDP over the global WebSocket, with no Playwright. A page's session on it sends only the
+* capture's commands, and receives that page's events. The connection opens as the first capture
+* starts and stays until the scope closes, which closes it and waits, bounded, for it to close;
+* one that fails ends every page's session on it, and the next capture opens another.
+*/
+const Message = Schema.fromJsonString(Schema.Struct({
+	id: Schema.optionalKey(Schema.Int),
+	sessionId: Schema.optionalKey(Schema.String),
+	method: Schema.optionalKey(Schema.String),
+	params: Schema.optionalKey(Schema.Unknown),
+	result: Schema.optionalKey(Schema.Unknown),
+	error: Schema.optionalKey(Schema.Struct({ message: Schema.String }))
+}));
+const Session = Schema.Struct({ sessionId: Schema.String });
+const failure = (detail) => new BrowserError({
+	operation: "screencast",
+	reason: new Failed({ detail }),
+	dispatched: false
+});
+const closing = Duration.seconds(2);
+/** The capture connection to the DevTools address `url`, for the scope. */
+const make = Effect.fnUntraced(function* (url) {
+	let state = { _tag: "Idle" };
+	let ids = 0;
+	const opening = yield* Semaphore.make(1);
+	const lose = (open, error) => {
+		if (state._tag !== "Open" || state.open !== open) return;
+		state = { _tag: "Idle" };
+		for (const reply of open.replies.values()) reply.reject(error);
+		for (const listener of open.sessions.values()) listener.lost(error);
+		open.replies.clear();
+		open.sessions.clear();
+	};
+	const receive = (open, data) => {
+		const decoded = typeof data === "string" ? Schema.decodeOption(Message)(data) : Option.none();
+		if (Option.isNone(decoded)) return lose(open, failure("the capture connection sent a message it could not read"));
+		const { id, sessionId, method, params, result, error } = decoded.value;
+		if (id !== void 0) {
+			const reply = open.replies.get(id);
+			open.replies.delete(id);
+			if (error === void 0) reply?.resolve(result);
+			else reply?.reject(failure(error.message));
+		} else if (method === void 0) return;
+		else if (sessionId !== void 0) open.sessions.get(sessionId)?.event(method, params);
+		else if (method === "Target.detachedFromTarget") {
+			const detached = Schema.decodeUnknownOption(Session)(params);
+			const ended = Option.isSome(detached) ? detached.value.sessionId : "";
+			const listener = open.sessions.get(ended);
+			open.sessions.delete(ended);
+			listener?.event(method, params);
+		}
+	};
+	const send = (open, method, params, sessionId) => {
+		if (state._tag !== "Open" || state.open !== open) return Promise.reject(failure("the capture connection was lost"));
+		const id = ++ids;
+		const { promise, resolve, reject } = Promise.withResolvers();
+		open.replies.set(id, {
+			resolve,
+			reject
+		});
+		try {
+			open.socket.send(JSON.stringify({
+				id,
+				method,
+				params,
+				sessionId
+			}));
+		} catch {
+			open.replies.delete(id);
+			reject(failure("the capture connection could not send"));
+		}
+		return promise;
+	};
+	const connect = Effect.callback((resume) => {
+		const socket = new WebSocket(Redacted.value(url));
+		const open = {
+			socket,
+			replies: /* @__PURE__ */ new Map(),
+			sessions: /* @__PURE__ */ new Map()
+		};
+		const unopened = () => resume(Effect.fail(failure("the capture connection did not open")));
+		socket.addEventListener("close", unopened, { once: true });
+		socket.addEventListener("open", () => {
+			socket.removeEventListener("close", unopened);
+			if (state._tag === "Closed") {
+				socket.close(1e3);
+				return resume(Effect.fail(failure("the capture connection is closed")));
+			}
+			state = {
+				_tag: "Open",
+				open
+			};
+			socket.addEventListener("close", () => lose(open, failure("the capture connection was lost")));
+			resume(Effect.succeed(open));
+		}, { once: true });
+		socket.addEventListener("message", ({ data }) => receive(open, data));
+		return Effect.sync(() => socket.close(1e3));
+	});
+	const current = opening.withPermits(1)(Effect.suspend(() => state._tag === "Open" ? Effect.succeed(state.open) : state._tag === "Closed" ? Effect.fail(failure("the capture connection is closed")) : connect));
+	const replied = (reply) => Effect.tryPromise({
+		try: reply,
+		catch: (cause) => Schema.is(BrowserError)(cause) ? cause : failure("the capture connection failed")
+	});
+	const attach = (target, listener) => Effect.gen(function* () {
+		const open = yield* current;
+		const { sessionId } = yield* replied(() => send(open, "Target.attachToTarget", {
+			targetId: target,
+			flatten: true
+		})).pipe(Effect.flatMap((result) => Schema.decodeUnknownEffect(Session)(result).pipe(Effect.mapError(() => failure("the capture connection's attach had no session")))));
+		open.sessions.set(sessionId, listener);
+		yield* Effect.addFinalizer(() => Effect.sync(() => {
+			if (open.sessions.delete(sessionId)) send(open, "Target.detachFromTarget", { sessionId }, void 0).catch(() => void 0);
+		}));
+		return (method, params) => send(open, method, params, sessionId);
+	});
+	yield* Effect.addFinalizer(() => Effect.suspend(() => {
+		const previous = state;
+		state = { _tag: "Closed" };
+		if (previous._tag !== "Open") return Effect.void;
+		const { socket, replies, sessions } = previous.open;
+		for (const reply of replies.values()) reply.reject(failure("the capture connection closed"));
+		replies.clear();
+		sessions.clear();
+		return Effect.callback((resume) => {
+			if (socket.readyState === WebSocket.CLOSED) return resume(Effect.void);
+			socket.addEventListener("close", () => resume(Effect.void), { once: true });
+			socket.close(1e3);
+		}).pipe(Effect.timeoutOrElse({
+			duration: closing,
+			orElse: () => Effect.void
+		}));
+	}));
+	return { attach };
+});
+//#endregion
+//#region src/Browserbase.ts
+/**
+* A `Browser` running on Browserbase.
+*
+* `open` creates a session and connects to it over CDP. When its scope closes it disconnects,
+* releases the session and confirms that Browserbase reports it ended, so billing stops then
+* rather than at the session's timeout. `release` does the same sooner and says how it went:
+* `Settled`, or `Unconfirmed` when Browserbase still reported the session running, or could not
+* be asked, at the deadline. Each create carries a nonce of its own in its user metadata, so a
+* session made by a create whose answer was lost is found and ended too, rather than billing
+* unseen until its timeout.
+*
+* A session that persists to a stored context saves to it when the session ends, so two at once
+* can lose one's changes. `open` holds the context through the `ContextLease` the application
+* provides, from before it creates such a session until Browserbase reports the session ended and
+* `contextSettle` has passed, since the save lands later and nothing acknowledges it. A writer that
+* leaves a session that saves to the context possibly running, its release `Unconfirmed`, its
+* create's answer lost or its session kept, leaves the context unsettled: the next writer first ends
+* the context's sessions, which `open` labels in their user metadata, and fails with `ContextHeld`
+* while they can't be confirmed ended. `reconcile` ends them without opening, and `verifyContext`
+* reads a context back under the same hold, from a session that saves nothing.
+*
+* `attach` connects to a session that already runs, as from another process: its pages keep their
+* ids, so a page stored before is found again. `supervise` keeps a session open across losses and
+* session ends, as `Supervisor` generations, and with `keep`, past its own scope, for the next
+* `supervise` to adopt.
+*
+* @since 0.3.0
+*/
+var Browserbase_exports = /* @__PURE__ */ __exportAll({
+	attach: () => attach,
+	layer: () => layer,
+	open: () => open,
+	reconcile: () => reconcile,
+	supervise: () => supervise,
+	verifyContext: () => verifyContext
+});
+/** The user metadata key naming the stored context a persisting session writes to. */
+const contextLabel = "persistsContext";
+/** The user metadata key holding each create's own nonce, which finds a session made unseen. */
+const createLabel = "createNonce";
+/** The user metadata key naming what a supervisor keeps its sessions under, past its scope. */
+const keepLabel = "keptAs";
+/**
+* How long a create whose answer was lost has its session looked for: Browserbase can list a new
+* session late, or still be making it when the client stops waiting.
+*/
+const orphanSearch = Duration.seconds(30);
+/** How long a release waits for Browserbase to report the session ended. */
+const releaseDeadline = Duration.minutes(1);
+const ended = (session) => session.status !== "PENDING" && session.status !== "RUNNING";
+/**
+* End the session and confirm Browserbase reports it ended. The release request and the status
+* reads are each tried again a second apart until the deadline; a session still running then, or
+* one Browserbase could not be asked about, is `Unconfirmed`. Once it has ended, wait `settle`
+* longer, for its context's save to land. It runs to the end once started.
+*/
+const confirm = (client, id, settle) => Effect.gen(function* () {
+	let last = "Browserbase did not answer";
+	const heard = (error) => Effect.sync(() => last = error.message);
+	const read = client.getSession(id).pipe(Effect.tapError(heard), Effect.tap((session) => Effect.sync(() => last = `the session was ${session.status}`)), Effect.retry(Schedule.spaced("1 second")), Effect.repeat({
+		until: ended,
+		schedule: Schedule.spaced("1 second")
+	}));
+	if (!(yield* client.releaseSession(id).pipe(Effect.tapError(heard), Effect.retry({
+		while: isTransient,
+		schedule: Schedule.spaced("1 second")
+	}), Effect.exit, Effect.andThen(read), Effect.as(true), Effect.timeoutOrElse({
+		duration: releaseDeadline,
+		orElse: () => Effect.succeed(false)
+	}), Effect.orElseSucceed(() => false)))) return new Supervisor.Unconfirmed({ detail: `${last} ${Duration.format(releaseDeadline)} after its release` });
+	if (settle !== void 0) yield* Effect.sleep(settle);
+	return new Supervisor.Settled();
+}).pipe(Effect.tap((released) => Effect.annotateCurrentSpan({ released: released._tag })), Effect.withSpan("Browserbase.release", { attributes: {
+	session: id,
+	settle: settle !== void 0
+} }, { captureStackTrace: false }), Effect.uninterruptible);
+/** A search for the sessions with `value` under the user metadata key `label`. */
+const labelled = (label, value) => `user_metadata['${label}']:'${value}'`;
+/**
+* The sessions a search finds that have not ended. Pending ones are listed first, since one listed
+* as pending may be running by the second query.
+*/
+const unended = (client, query) => Effect.forEach(["PENDING", "RUNNING"], (status) => client.listSessions({
+	status,
+	query
+})).pipe(Effect.map((found) => [...new Map(found.flat().map((session) => [session.id, session])).values()]));
+/**
+* End the sessions and confirm they ended; then wait `settle`, if given, for the last save to land.
+* One still running at its release's deadline makes the outcome `Unconfirmed`.
+*/
+const endAll = (client, sessions, settle) => Effect.forEach(sessions, (session) => confirm(client, session, void 0), { concurrency: 4 }).pipe(Effect.flatMap((outcomes) => {
+	const unconfirmed = outcomes.find((outcome) => outcome._tag === "Unconfirmed");
+	return unconfirmed === void 0 ? Effect.sleep(settle ?? Duration.zero).pipe(Effect.as(new Supervisor.Settled())) : Effect.succeed(unconfirmed);
+}));
+/**
+* End the session a create may have made though its answer was lost, found in any state by the
+* create's own label, and then wait `settle`, if given, for its save. Browserbase can list a new
+* session late, so it is looked for again, more and more seldom, until it is found or
+* `orphanSearch` has passed. A search Browserbase never answered is `Unconfirmed`, as is a session
+* still running at its release's deadline.
+*/
+const endOrphan = (client, nonce, settle) => Effect.gen(function* () {
+	let answered = false;
+	const found = yield* client.listSessions({ query: labelled(createLabel, nonce) }).pipe(Effect.tap(() => Effect.sync(() => {
+		answered = true;
+	})), Effect.retry(Schedule.exponential("1 second")), Effect.repeat({
+		schedule: Schedule.exponential("1 second"),
+		until: (sessions) => sessions.length > 0
+	}), Effect.timeoutOption(orphanSearch));
+	if (Option.isNone(found) && !answered) return new Supervisor.Unconfirmed({ detail: `Browserbase did not answer a search for it within ${Duration.format(orphanSearch)}` });
+	const running = Option.getOrElse(found, () => []).filter((session) => !ended(session));
+	return yield* endAll(client, running.map((session) => session.id), settle);
+});
+/**
+* Hold the stored context through the lease, as its only writer, until the scope closes or the
+* session's end is known; the hold goes once, saying how this writer leaves the context.
+*/
+const holdContext = Effect.fnUntraced(function* (client, lease, id, settle) {
+	const scope = yield* Scope.fork(yield* Effect.scope);
+	const hold = yield* lease.hold(id).pipe(Scope.provide(scope), Effect.withSpan("Browserbase.holdContext", {}, { captureStackTrace: false }));
+	let unsettled = hold.unsettled;
+	const set = (now) => Effect.sync(() => {
+		unsettled = now;
+	});
+	yield* Scope.addFinalizer(scope, Effect.suspend(() => hold.leave(unsettled)));
+	const letGo = (now) => set(now).pipe(Effect.andThen(Scope.close(scope, Exit.void)));
+	/** End the context's sessions but `except`, found by the label `open` gives them. */
+	const end = (except) => unended(client, labelled(contextLabel, id)).pipe(Effect.flatMap((found) => endAll(client, found.map((session) => session.id).filter((session) => !except.includes(session)), settle)), Effect.onExit((exit) => set(!(Exit.isSuccess(exit) && exit.value._tag === "Settled"))));
+	const refuse = (outcome) => outcome._tag === "Settled" ? Effect.void : Effect.fail(new ContextHeld({
+		context: id,
+		detail: outcome.detail
+	}));
+	return {
+		end,
+		/**
+		* End the sessions, but `except`, that a writer before may have left saving to the context,
+		* failing with `ContextHeld` while they can't be confirmed ended.
+		*/
+		clear: (except) => Effect.suspend(() => unsettled ? Effect.flatMap(end(except), refuse) : Effect.void),
+		/** A session that saves to the context runs from now. */
+		writing: set(true),
+		/** How the writer's session ended: unconfirmed, it may still save to the context. */
+		released: (outcome) => letGo(outcome._tag === "Unconfirmed"),
+		/** How ending the session a lost create may have made went: unconfirmed, the open fails. */
+		lost: (outcome) => letGo(outcome._tag === "Unconfirmed").pipe(Effect.andThen(refuse(outcome))),
+		/** The writer's session runs on past its scope, saving to the context when it ends. */
+		kept: letGo(true)
+	};
+});
+/** A create that failed so may still have made its session: its answer is lost or unreadable. */
+const mayHaveCreated = (error) => error.reason._tag === "Transport" || error.reason._tag === "Decode" || error.reason._tag === "Status" && (error.reason.status >= 500 || error.reason.status === 408);
+/** A create's own nonce: two random draws, which no other create draws in practice. */
+const nonce = Effect.map(Effect.all([Random.nextInt, Random.nextInt]), (draws) => draws.map((draw) => Math.abs(draw).toString(36)).join("-"));
+/**
+* The create request, labelled with its own nonce, a persisting session with its context too, so
+* either can be found, and a kept one with what it is kept under, kept alive past disconnecting.
+*/
+const withLabels = (session, own, context, keep) => ({
+	...session,
+	...keep === void 0 ? {} : { keepAlive: true },
+	userMetadata: {
+		...session?.userMetadata,
+		[createLabel]: own,
+		...context === void 0 ? {} : { [contextLabel]: context },
+		...keep === void 0 ? {} : { [keepLabel]: keep }
+	}
+});
+/**
+* A release by the browser's owner: it closes the browser first, so that whatever fails then, a
+* capture's reader or a call in flight, says the session was released, and not that the
+* connection Browserbase cuts as the session ends was lost.
+*/
+const releasing = (browser, end) => Scope.close(browser, Exit.void).pipe(Effect.andThen(end));
+/**
+* A browser over the session's DevTools address, its pages' screencasts on a capture connection of
+* their own. A DevTools server's HTTP address, as a local Chromium gives in tests, keeps them on
+* each page's own session: there the connection is loopback, and fast. A session that has ended
+* fails `Closed` by the session, with no connect.
+*/
+const connect = Effect.fnUntraced(function* (operation, session, options) {
+	const endpoint = session.connectUrl;
+	if (ended(session)) return yield* new BrowserError({
+		operation,
+		reason: new Closed({ cause: "session" }),
+		dispatched: false
+	});
+	if (endpoint === void 0) return yield* new BrowserbaseError({
+		operation,
+		reason: new Decode({ detail: `session ${session.id} has no connectUrl` })
+	});
+	const apart = options.captureConnection !== false && /^wss?:/i.test(Redacted.value(endpoint));
+	return yield* Cdp.open({
+		...options,
+		endpoint,
+		id: session.id,
+		provider: "browserbase",
+		expiresAt: Option.getOrUndefined(DateTime.make(session.expiresAt)),
+		capture: apart ? yield* make(endpoint) : void 0
+	});
+});
+const keepName = /^[\w.:-]{1,64}$/;
+const newestFirst = (sessions) => {
+	const created = (session) => Option.getOrElse(Option.map(DateTime.make(session.createdAt), DateTime.toEpochMillis), () => 0);
+	return sessions.toSorted((a, b) => created(b) - created(a));
+};
+/**
+* The newest session kept under `name` that saves where this open would, to adopt. Every other
+* session kept under it is to end, since nothing else adopts it: those that save to this open's
+* context are its writers, for the context's hold to end, as `writers` says, and the rest end here.
+*/
+const adoptable = Effect.fnUntraced(function* (client, name, persisting) {
+	const [newest, ...older] = newestFirst(yield* unended(client, labelled(keepLabel, name)));
+	const fits = newest !== void 0 && newest.userMetadata?.[contextLabel] === persisting;
+	const others = [...fits || newest === void 0 ? [] : [newest], ...older];
+	const writes = (session) => persisting !== void 0 && session.userMetadata?.[contextLabel] === persisting;
+	const rest = others.filter((session) => !writes(session));
+	if (rest.length > 0) {
+		const outcome = yield* endAll(client, rest.map((session) => session.id), void 0);
+		yield* Effect.annotateCurrentSpan({
+			endedKept: rest.length,
+			endedKeptAs: outcome._tag
+		});
+	}
+	return {
+		adoptee: fits ? newest : void 0,
+		writers: others.some(writes)
+	};
+});
+/**
+* Open a browser on a new session, or, when keeping, adopt one a supervisor kept before. A kept
+* session's scope only disconnects, unless it closes on a failure: `release` ends it.
+*/
+const start = Effect.fnUntraced(function* (options, keeping) {
+	const client = yield* BrowserbaseClient;
+	const lease = yield* ContextLease;
+	const context = options.session?.browserSettings?.context;
+	const persisting = context?.persist === true ? context.id : void 0;
+	const local = yield* Scope.fork(yield* Effect.scope);
+	const settle = Duration.fromInputUnsafe(options.contextSettle ?? Duration.seconds(10));
+	return yield* Effect.gen(function* () {
+		if (keeping !== void 0 && !keepName.test(keeping.name)) return yield* new BrowserbaseError({
+			operation: "supervise",
+			reason: new InvalidRequest({ detail: `keep must be 1 to 64 letters, digits, "_", ".", ":" or "-"` })
+		});
+		const writing = persisting === void 0 ? void 0 : yield* holdContext(client, lease, persisting, settle);
+		const adoption = keeping?.adopt ? yield* adoptable(client, keeping.name, persisting) : void 0;
+		const adopted = adoption?.adoptee;
+		if (adoption?.writers === true) yield* writing?.writing ?? Effect.void;
+		yield* writing?.clear(adopted === void 0 ? [] : [adopted.id]) ?? Effect.void;
+		const connected = yield* Scope.fork(local);
+		const own = yield* nonce;
+		const ending = (session) => Effect.gen(function* () {
+			let asked = false;
+			return {
+				session,
+				release: yield* Effect.cached(Effect.suspend(() => {
+					asked = true;
+					return releasing(connected, confirm(client, session.id, writing && settle)).pipe(Effect.tap((outcome) => writing?.released(outcome) ?? Effect.void));
+				})),
+				leave: Effect.suspend(() => asked ? Effect.void : Scope.close(connected, Exit.void).pipe(Effect.andThen(writing?.kept ?? Effect.void)))
+			};
+		});
+		const { session, release } = yield* Effect.acquireRelease(Effect.gen(function* () {
+			const session = adopted === void 0 ? yield* client.createSession(withLabels(options.session, own, persisting, keeping?.name)) : yield* client.getSession(adopted.id);
+			yield* writing?.writing ?? Effect.void;
+			return yield* ending(session);
+		}), ({ release, leave }, exit) => keeping !== void 0 && Exit.isSuccess(exit) ? leave : Effect.asVoid(release)).pipe(Effect.tapError((error) => adopted === void 0 && mayHaveCreated(error) ? endOrphan(client, own, writing && settle).pipe(Effect.flatMap((outcome) => writing?.lost(outcome) ?? Effect.void)) : Effect.void));
+		yield* Effect.annotateCurrentSpan({
+			session: session.id,
+			region: session.region,
+			adopted: adopted !== void 0
+		});
+		return {
+			browser: yield* connect(adopted === void 0 ? "open" : "attach", session, options).pipe(Scope.provide(connected)),
+			session,
+			release
+		};
+	}).pipe(Scope.provide(local), Effect.onError((cause) => Scope.close(local, Exit.failCause(cause))));
+});
+/**
+* Create a session and open a `Browser` on it, for as long as the scope is open. If opening
+* fails, the session and context are released then, so a retry in the same scope can take them.
+* A persisting open holds its context through the `ContextLease`; a session that may still save
+* to it, as one whose release was left `Unconfirmed` or whose create's answer was lost, is ended
+* first, and the open fails with `ContextHeld` while that can't be confirmed. A lost create's own
+* open looks for its session by the create's nonce, within `orphanSearch`, ends it, then fails with
+* the create's error. `release` disconnects the browser before it asks Browserbase to end the
+* session, so what fails meanwhile says it was released.
+*/
+const open = Effect.fn("Browserbase.open")(function* (options = {}) {
+	return yield* start(options, void 0);
+});
+/**
+* Open a `Browser` on a session that already runs, such as a `keepAlive` session another process
+* opened. This is resume: its pages keep their ids, their CDP target ids, so `browser.page(id)`
+* finds a page stored before. Closing the scope disconnects and leaves the session running;
+* `release` ends it. A session that has ended fails `Closed` by the session. It holds no context.
+*/
+const attach = Effect.fn("Browserbase.attach")(function* (sessionId, options = {}) {
+	const client = yield* BrowserbaseClient;
+	const session = yield* client.getSession(sessionId);
+	yield* Effect.annotateCurrentSpan({
+		session: session.id,
+		region: session.region
+	});
+	const connected = yield* Scope.fork(yield* Effect.scope);
+	return {
+		browser: yield* connect("attach", session, options).pipe(Scope.provide(connected)),
+		session,
+		release: yield* Effect.cached(releasing(connected, confirm(client, session.id, void 0)))
+	};
+});
+/**
+* End a stored context's sessions, the ones `open` labelled as writing to it, and let the context
+* go once they are confirmed ended and its save has settled. `open` does this itself when a writer
+* before it may still run; `reconcile` does it without opening, as for sessions another process
+* left running. It holds the context through the `ContextLease`, so it waits for a writer. A
+* session still running at the deadline makes it `Unconfirmed`, and leaves the context unsettled,
+* as a failure does.
+*/
+const reconcile = Effect.fn("Browserbase.reconcile")(function* (contextId, options = {}) {
+	const client = yield* BrowserbaseClient;
+	const lease = yield* ContextLease;
+	const settle = Duration.fromInputUnsafe(options.contextSettle ?? Duration.seconds(10));
+	yield* client.getContext(contextId);
+	return yield* (yield* holdContext(client, lease, contextId, settle)).end([]);
+}, Effect.scoped);
+/**
+* Read a stored context back, as a login: a session that loads it and saves nothing runs `check`
+* on its browser, and is released. The context is held through the `ContextLease` meanwhile, so
+* the read never runs beside a writer, which a site could sign out, and it reads what the last
+* writer saved, once that save settled. A session a writer before may have left saving to it is
+* ended first, as for `open`.
+*/
+const verifyContext = Effect.fn("Browserbase.verifyContext")(function* (contextId, check, options = {}) {
+	const client = yield* BrowserbaseClient;
+	const lease = yield* ContextLease;
+	const settle = Duration.fromInputUnsafe(options.contextSettle ?? Duration.seconds(10));
+	yield* (yield* holdContext(client, lease, contextId, settle)).clear([]);
+	const { browser } = yield* start({
+		...options,
+		session: {
+			...options.session,
+			browserSettings: {
+				...options.session?.browserSettings,
+				context: {
+					id: contextId,
+					persist: false
+				}
+			}
+		}
+	}, void 0);
+	return yield* check(browser);
+}, Effect.scoped);
+/**
+* Browserbase refused the request: no new try mends a refused key, request or id. A context held
+* is not among them, since each try ends its sessions again.
+*/
+const refused = (error) => error._tag === "BrowserbaseError" && !isTransient(error) && error.reason._tag !== "Decode";
+/**
+* Keep Browserbase sessions open as `Supervisor` generations, each a new session made from
+* `session`. Sessions that persist to a stored context are exclusive: a rotation releases the
+* current one, and its context's save settles, before the next one opens. An open Browserbase
+* refused, as for a bad key or an invalid request, is `Down` at once. With `keep`, closing the
+* scope leaves the current session running for the next `supervise` under that name to adopt.
+*/
+const supervise = (options = {}) => Effect.suspend(() => {
+	const { keep } = options;
+	let opened = false;
+	return Supervisor.make({
+		open: Effect.suspend(() => start(options, keep === void 0 ? void 0 : {
+			name: keep,
+			adopt: !opened
+		})).pipe(Effect.tap(() => Effect.sync(() => {
+			opened = true;
+		})), Effect.withSpan("Browserbase.open", {}, { captureStackTrace: false })),
+		exclusive: options.session?.browserSettings?.context?.persist === true,
+		keep: keep !== void 0,
+		reopen: options.reopen,
+		definite: refused,
+		rotateBefore: options.rotateBefore,
+		waitTimeout: options.waitTimeout
+	});
+});
+const layer = (options = {}) => Layer.effect(Browser.Browser, Effect.map(open(options), ({ browser }) => browser));
+//#endregion
+export { reconcile as a, open as i, attach as n, supervise as o, layer as r, verifyContext as s, Browserbase_exports as t };
+
+//# sourceMappingURL=Browserbase-FDltiz36.mjs.map