effect-browser 0.2.0-beta.9 → 0.3.0-beta.11

package/dist/Browser-B4qncxe7.mjs

@@ -0,0 +1,628 @@
+import { t as __exportAll } from "./rolldown-runtime-D7D4PA-g.mjs";
+import { DialogShown, Disconnected, PageClosed, PageOpened, PageUntracked, RecordedEvent, SessionEnding } from "./BrowserEvent.mjs";
+import { BrowserError, Busy, Closed, EventHistoryExpired, Failed, InvalidRequest, Limit, Suspended } from "./BrowserError.mjs";
+import { i as failWith, s as undispatched, t as call } from "./context-B6xr8nVi.mjs";
+import { c as FailFast, i as redact } from "./url-Cd04Okid.mjs";
+import { n as make$5, o as mapping } from "./page-BAf__WKX.mjs";
+import { Cause, Clock, Context, Crypto, DateTime, Deferred, Duration, Effect, Exit, Option, PlatformError, Queue, Schema, Scope, Semaphore, Stream } from "effect";
+//#region src/internal/input/gate.ts
+/**
+* A browser's input authority: stop admitting writes, drain admitted operations through their
+* records and native replies, then retain the stop for its scopes. Reads never enter this gate.
+*/
+const without = (set, id) => new Set([...set].filter((each) => each !== id));
+const step = (state, input, stopped) => {
+	switch (input._tag) {
+		case "Enter": return state._tag === "Open" ? {
+			...state,
+			inputs: /* @__PURE__ */ new Set([...state.inputs, input.id])
+		} : state;
+		case "End": {
+			if (state._tag === "Held") return state;
+			const inputs = without(state.inputs, input.id);
+			return state._tag === "Draining" && inputs.size === 0 ? {
+				_tag: "Held",
+				claims: state.claims,
+				stopped
+			} : {
+				...state,
+				inputs
+			};
+		}
+		case "Suspend":
+			if (state._tag !== "Open") return {
+				...state,
+				claims: /* @__PURE__ */ new Set([...state.claims, input.id])
+			};
+			return state.inputs.size === 0 ? {
+				_tag: "Held",
+				claims: /* @__PURE__ */ new Set([input.id]),
+				stopped
+			} : {
+				_tag: "Draining",
+				inputs: state.inputs,
+				claims: /* @__PURE__ */ new Set([input.id]),
+				startedAt: stopped.at,
+				deadline: stopped.at + input.drain
+			};
+		case "Leave": {
+			if (state._tag === "Open" || !state.claims.has(input.id)) return state;
+			const claims = without(state.claims, input.id);
+			return claims.size > 0 ? {
+				...state,
+				claims
+			} : {
+				_tag: "Open",
+				inputs: state._tag === "Draining" ? state.inputs : /* @__PURE__ */ new Set()
+			};
+		}
+		case "Expire": return state._tag === "Draining" && stopped.at >= state.deadline ? {
+			_tag: "Open",
+			inputs: state.inputs
+		} : state;
+	}
+};
+const make$4 = (options) => {
+	let state = {
+		_tag: "Open",
+		inputs: /* @__PURE__ */ new Set()
+	};
+	let next = 0;
+	let refused = Deferred.makeUnsafe();
+	let ready = Deferred.makeUnsafe();
+	const error = (operation) => new BrowserError({
+		operation,
+		reason: options.closedBy() === void 0 ? new Suspended() : new Closed({ cause: options.closedBy() ?? "connection" }),
+		dispatched: false
+	});
+	const stopped = () => ({
+		since: options.sequence(),
+		at: options.now()
+	});
+	const apply = (input) => {
+		if (input._tag !== "Expire" && state._tag === "Draining" && options.now() >= state.deadline) apply({ _tag: "Expire" });
+		const before = state;
+		state = step(state, input, stopped());
+		if (input._tag === "Expire" && before._tag === "Draining" && state._tag === "Open") Deferred.doneUnsafe(ready, Exit.fail(new BrowserError({
+			operation: "suspend",
+			reason: new Busy({
+				waitedMillis: Math.round(options.now() - before.startedAt),
+				ahead: before.inputs.size
+			}),
+			dispatched: false
+		})));
+		if (before._tag === "Open" && state._tag !== "Open") Deferred.doneUnsafe(refused, Exit.void);
+		if (before._tag === "Draining" && state._tag === "Held") Deferred.doneUnsafe(ready, Exit.succeed(state.stopped));
+		if (before._tag !== "Open" && state._tag === "Open") {
+			refused = Deferred.makeUnsafe();
+			ready = Deferred.makeUnsafe();
+		}
+		return state;
+	};
+	const check = (operation) => Effect.suspend(() => state._tag === "Open" && options.closedBy() === void 0 ? Effect.void : Effect.fail(error(operation)));
+	const suspend = (drain = options.drain) => Effect.suspend(() => {
+		const duration = Duration.fromInput(drain);
+		if (Option.isNone(duration) || !Duration.isFinite(duration.value) || Duration.toMillis(duration.value) < 0) return Effect.fail(new BrowserError({
+			operation: "suspend",
+			reason: new InvalidRequest({ detail: "drain must be a finite nonnegative duration" }),
+			dispatched: false
+		}));
+		const id = ++next;
+		const leave = Effect.sync(() => apply({
+			_tag: "Leave",
+			id
+		}));
+		return Effect.acquireRelease(Effect.gen(function* () {
+			if (options.closedBy() !== void 0) return yield* error("suspend");
+			const current = apply({
+				_tag: "Suspend",
+				id,
+				drain: Duration.toMillis(duration.value)
+			});
+			if (current._tag === "Held") return current.stopped;
+			if (current._tag !== "Draining") return yield* Effect.die("suspension did not retain authority");
+			const pending = ready;
+			const expire = Effect.suspend(() => {
+				const left = current.deadline - options.now();
+				return left > 0 ? Effect.sleep(Duration.millis(left)).pipe(Effect.andThen(expire)) : Effect.sync(() => apply({ _tag: "Expire" })).pipe(Effect.andThen(Deferred.await(pending)));
+			});
+			const wait = Effect.raceFirst(Deferred.await(pending), expire);
+			return yield* Effect.raceFirst(wait, options.lost.pipe(Effect.flatMap(() => Effect.fail(error("suspend"))))).pipe(Effect.interruptible, Effect.filterOrFail(() => options.closedBy() === void 0, () => error("suspend")), Effect.onError(() => leave));
+		}), () => leave);
+	}).pipe(Effect.provideService(Clock.Clock, options.clock));
+	return {
+		check,
+		suspend,
+		refused: (operation) => Effect.suspend(() => state._tag === "Open" ? Deferred.await(refused).pipe(Effect.andThen(Effect.fail(error(operation)))) : Effect.fail(error(operation))),
+		enter: (operation) => Effect.suspend(() => {
+			if (state._tag !== "Open" || options.closedBy() !== void 0) return Effect.fail(error(operation));
+			const id = ++next;
+			apply({
+				_tag: "Enter",
+				id
+			});
+			return Effect.succeed(() => {
+				apply({
+					_tag: "End",
+					id
+				});
+			});
+		})
+	};
+};
+//#endregion
+//#region src/internal/page/identity.ts
+/** Connection identity uses the supplied Crypto service, or the host's Web Crypto on Node/Bun. */
+const native = () => Crypto.make({
+	randomBytes: (size) => globalThis.crypto.getRandomValues(new Uint8Array(size)),
+	digest: (algorithm, data) => Effect.tryPromise({
+		try: () => globalThis.crypto.subtle.digest(algorithm, new Uint8Array(data)),
+		catch: (cause) => PlatformError.systemError({
+			module: "Crypto",
+			method: "digest",
+			_tag: "Unknown",
+			description: "Could not compute digest",
+			cause
+		})
+	}).pipe(Effect.map((bytes) => new Uint8Array(bytes)))
+});
+const make$3 = Effect.gen(function* () {
+	const supplied = yield* Effect.serviceOption(Crypto.Crypto);
+	return yield* Option.getOrElse(supplied, native).randomUUIDv4.pipe(Effect.mapError(() => undispatched("make", new Failed({ detail: "Could not name connection" }))));
+});
+//#endregion
+//#region src/internal/page/openings.ts
+/** A page's input waits for the actual tabs it opened to finish the browser's registration. */
+const make$2 = Effect.fnUntraced(function* (playwright, cdp, registrations, closedBy) {
+	const failed = (reason) => Exit.fail(new BrowserError({
+		operation: "newPage",
+		reason,
+		dispatched: false
+	}));
+	let active;
+	const gone = Deferred.makeUnsafe();
+	const windowOpened = () => {
+		if (active !== void 0) active.windows += 1;
+	};
+	const popup = (opened) => {
+		if (active === void 0) return;
+		const registered = registrations.get(opened);
+		active.registrations.push(registered === void 0 ? failed(new Failed({ detail: "the popup has no registration" })) : Deferred.await(registered));
+		Deferred.doneUnsafe(active.changed, Exit.void);
+		active.changed = Deferred.makeUnsafe();
+	};
+	const clear = Effect.sync(() => {
+		active = void 0;
+	});
+	yield* Effect.acquireRelease(Effect.sync(() => {
+		cdp.on("Page.windowOpen", windowOpened);
+		playwright.on("popup", popup);
+	}), () => Effect.sync(() => {
+		active = void 0;
+		cdp.off("Page.windowOpen", windowOpened);
+		playwright.off("popup", popup);
+		Deferred.doneUnsafe(gone, failed(new Closed({ cause: closedBy() })));
+	}));
+	return {
+		mark: () => {
+			const mark = {
+				windows: 0,
+				registrations: [],
+				changed: Deferred.makeUnsafe()
+			};
+			active = mark;
+			return mark;
+		},
+		clear,
+		settle: (mark) => Effect.gen(function* () {
+			while (mark.registrations.length < mark.windows) yield* Deferred.await(mark.changed);
+			yield* Effect.forEach(mark.registrations, (registration) => registration);
+		}).pipe(Effect.raceFirst(Deferred.await(gone)), Effect.ensuring(clear))
+	};
+});
+//#endregion
+//#region src/internal/timeline/events.ts
+/**
+* The browser's bounded event history and replay cursors. Readers share the same records and
+* wakeup generation, so a delayed reader cannot block input or retain an unbounded private queue.
+*/
+/** The owning Browser validates capacity and closes this timeline with its scope. */
+const make$1 = (capacity) => {
+	let records = [];
+	let sequence = 0;
+	let closed = false;
+	let changed = Deferred.makeUnsafe();
+	const wake = () => {
+		const previous = changed;
+		changed = Deferred.makeUnsafe();
+		Deferred.doneUnsafe(previous, Effect.void);
+	};
+	const publish = (event) => {
+		if (closed) return sequence;
+		sequence += 1;
+		const recorded = new RecordedEvent({
+			sequence,
+			event
+		});
+		records = records.length < capacity ? [...records, recorded] : [...records.slice(1), recorded];
+		wake();
+		return sequence;
+	};
+	const stream = (after) => Stream.unwrap(Effect.sync(() => {
+		let cursor = after ?? sequence;
+		if (!Number.isSafeInteger(cursor) || cursor < 0 || cursor > sequence) return Stream.fail(undispatched("events", new InvalidRequest({ detail: "the event cursor must be a nonnegative integer no greater than the latest sequence" })));
+		return Stream.fromEffectRepeat(Effect.gen(function* () {
+			while (true) {
+				const oldest = records[0]?.sequence ?? sequence + 1;
+				if (cursor < oldest - 1) return yield* undispatched("events", new EventHistoryExpired({
+					after: cursor,
+					oldest,
+					latest: sequence
+				}));
+				const next = records[cursor - oldest + 1];
+				if (next !== void 0) {
+					cursor = next.sequence;
+					return next;
+				}
+				if (closed) return yield* Cause.done();
+				const waiting = changed;
+				yield* Deferred.await(waiting);
+			}
+		}));
+	}));
+	return {
+		publish,
+		sequence: () => sequence,
+		recent: Effect.sync(() => records),
+		stream,
+		close: Effect.sync(() => {
+			if (closed) return;
+			closed = true;
+			wake();
+		})
+	};
+};
+//#endregion
+//#region src/Browser.ts
+/**
+* A live browser: its pages and what happens in it.
+*
+* `Browser` is a service with one implementation, built by a provider over a Playwright browser
+* context: `Chromium` launches one locally, `Cdp` connects to any DevTools endpoint and
+* `effect-browserbase` allocates a hosted one. Code written against `Browser` runs on all three.
+* A page is named by its CDP target id, so a new connection to the same browser finds it again.
+*
+* @since 0.3.0
+*/
+var Browser_exports = /* @__PURE__ */ __exportAll({
+	Browser: () => Browser,
+	Suspension: () => Suspension,
+	make: () => make
+});
+/** When admitted input finished; events after `since` describe the handoff interval. */
+var Suspension = class extends Schema.Class("effect-browser/Suspension")({
+	since: Schema.Int.check(Schema.isGreaterThanOrEqualTo(0)),
+	at: Schema.Finite
+}) {};
+var Browser = class extends Context.Service()("effect-browser/Browser") {};
+/** The settings every page shares, and how many events the browser keeps, from its options. */
+const settingsOf = Effect.fnUntraced(function* (options) {
+	const invalid = (detail) => undispatched("make", new InvalidRequest({ detail }));
+	const bound = (name, input, fallback) => {
+		const decoded = Duration.fromInput(input ?? fallback);
+		return Option.isSome(decoded) && Number.isFinite(Duration.toMillis(decoded.value)) && Duration.isPositive(decoded.value) ? Effect.succeed(decoded.value) : Effect.fail(invalid(`${name} must be finite and greater than zero`));
+	};
+	const settings = {
+		actionTimeout: yield* bound("actionTimeout", options.actionTimeout, Duration.seconds(10)),
+		navigationTimeout: yield* bound("navigationTimeout", options.navigationTimeout, Duration.seconds(30)),
+		frameHistory: yield* bound("frameHistory", options.frameHistory, Duration.seconds(5)),
+		guard: options.guard,
+		policyTimeout: yield* bound("policyTimeout", options.policyTimeout, Duration.minutes(5))
+	};
+	const eventHistory = options.eventHistory ?? 4096;
+	const { maxPages } = options;
+	if (!Number.isSafeInteger(eventHistory) || eventHistory < 1) return yield* invalid("eventHistory must be a positive safe integer");
+	if (maxPages !== void 0 && (!Number.isSafeInteger(maxPages) || maxPages < 1)) return yield* invalid("maxPages must be a positive safe integer");
+	return {
+		settings,
+		eventHistory,
+		maxPages
+	};
+});
+/**
+* A provider that ends a session at `expiresAt` by its own clock can cut the connection a little
+* before this host's clock gets there.
+*/
+const endMargin = Duration.seconds(5);
+/**
+* The browser's loss, once: its context closing from the other side, at or after the session's
+* end or before it, or `lose`, as the owner's scope releases it. Playwright leaves the calls in
+* flight on the library's own sessions unanswered when the connection drops, so `untilLost` fails
+* each with the browser, as a closed page's call fails.
+*/
+const watchLoss = Effect.fnUntraced(function* (context, expiresAt, clock, disconnected) {
+	let lostBy;
+	const lost = yield* Deferred.make();
+	const inFlight = /* @__PURE__ */ new Set();
+	const gone = () => /* @__PURE__ */ new Error("Target page, context or browser has been closed");
+	const lose = (cause) => {
+		if (lostBy !== void 0) return;
+		lostBy = cause;
+		for (const reject of inFlight) reject(gone());
+		disconnected(cause);
+		Deferred.doneUnsafe(lost, Exit.succeed(cause));
+	};
+	const untilLost = (reply) => {
+		if (lostBy !== void 0) {
+			reply.catch(() => void 0);
+			return Promise.reject(gone());
+		}
+		return new Promise((resolve, reject) => {
+			inFlight.add(reject);
+			reply.then(resolve, reject).finally(() => inFlight.delete(reject));
+		});
+	};
+	const ended = () => expiresAt !== void 0 && clock.currentTimeMillisUnsafe() >= DateTime.toEpochMillis(expiresAt) - Duration.toMillis(endMargin);
+	const onClose = () => lose(ended() ? "session" : "connection");
+	context.on("close", onClose);
+	yield* Effect.addFinalizer(() => Effect.sync(() => context.off("close", onClose)));
+	if (context.browser()?.isConnected() === false) onClose();
+	const native = (operation, run) => call(operation, run, () => lostBy ?? "page");
+	return {
+		lostBy: () => lostBy,
+		lost: Deferred.await(lost),
+		lose,
+		untilLost,
+		native
+	};
+});
+/**
+* What a page's own Playwright events publish, its close and crash aside, while its scope is
+* open. Dialogs are answered: alerts accepted, others dismissed. The page's own session tells its
+* documents' commits and loads.
+*/
+const listen = (playwright, page, publish, now, on) => {
+	const dialog = (shown) => {
+		const kind = shown.type();
+		const answer = kind === "alert" || kind === "beforeunload" ? "accepted" : "dismissed";
+		const message = shown.message().slice(0, 500);
+		publish(new DialogShown({
+			at: now(),
+			page,
+			kind,
+			message,
+			answer
+		}));
+		(answer === "accepted" ? shown.accept() : shown.dismiss()).catch(() => void 0);
+	};
+	return Effect.acquireRelease(Effect.sync(() => {
+		playwright.on("close", on.close);
+		playwright.on("crash", on.crash);
+		playwright.on("dialog", dialog);
+	}), () => Effect.sync(() => {
+		playwright.off("close", on.close);
+		playwright.off("crash", on.crash);
+		playwright.off("dialog", dialog);
+	}));
+};
+/**
+* Register each page the site opens, such as a popup, as Playwright reports it, for as long as the
+* scope is open. One that could not be tracked is published, unless it closed as it opened.
+*/
+const followOpened = Effect.fnUntraced(function* (context, register, publish, now, registrations) {
+	const opened = yield* Queue.unbounded();
+	const onPage = (playwright) => {
+		registrations.set(playwright, Deferred.makeUnsafe());
+		Queue.offerUnsafe(opened, playwright);
+	};
+	const untracked = (playwright) => (error) => Effect.sync(() => {
+		const url = redact(playwright.url());
+		if (!playwright.isClosed()) publish(new PageUntracked({
+			at: now(),
+			url,
+			detail: error.message
+		}));
+	});
+	context.on("page", onPage);
+	yield* Effect.addFinalizer(() => Effect.sync(() => context.off("page", onPage)));
+	yield* Queue.take(opened).pipe(Effect.flatMap((playwright) => register(playwright).pipe(Effect.asVoid, Effect.onExit((exit) => Effect.sync(() => {
+		const done = registrations.get(playwright);
+		if (done !== void 0) Deferred.doneUnsafe(done, exit);
+	})), Effect.catch(untracked(playwright)))), Effect.forever, Effect.forkScoped);
+});
+/** Release something native, on the owner's clock, giving up after a second: cleanup only. */
+const releaseNative = (clock) => (run) => Effect.tryPromise(run).pipe(Effect.interruptible, Effect.timeoutOrElse({
+	duration: Duration.seconds(1),
+	orElse: () => Effect.void
+}), Effect.provideService(Clock.Clock, clock), Effect.ignore);
+/** A page's own events among the browser's retained ones, and the openings of tabs it opened. */
+const eventsOf = (recent, page) => Effect.map(recent, (records) => records.flatMap(({ event }) => "page" in event && event.page === page || event._tag === "PageOpened" && event.opener === page ? [event] : []));
+/** A script as its documents run it: everywhere, or as a block where its `match` allows. */
+const scoped = ({ match, source }) => match === void 0 ? source : `if (${String(match)}.test(location.href)) {\n${source}\n}`;
+/**
+* At most `maxPages` open pages, those a site opened included, which are never refused: an open
+* past it waits for one to close, within `wait` on the owner's clock, then fails `Limit`, or fails
+* at once under `FailFast`. An open counts until its page is tracked.
+*/
+const pageBudget = (maxPages, tracked, wait, clock) => {
+	let opening = 0;
+	let roomMade = Deferred.makeUnsafe();
+	const makeRoom = () => {
+		Deferred.doneUnsafe(roomMade, Exit.void);
+		roomMade = Deferred.makeUnsafe();
+	};
+	const full = (limit) => tracked() + opening >= limit;
+	const room = (limit) => Effect.gen(function* () {
+		const refused = undispatched("newPage", new Limit({ maxPages: limit }));
+		if ((yield* FailFast) && full(limit)) return yield* refused;
+		yield* Effect.gen(function* () {
+			while (full(limit)) yield* Deferred.await(roomMade);
+			opening += 1;
+		}).pipe(Effect.timeoutOrElse({
+			duration: wait,
+			orElse: () => Effect.fail(refused)
+		}), Effect.provideService(Clock.Clock, clock));
+	});
+	const open = (opened) => maxPages === void 0 ? opened : Effect.uninterruptibleMask((restore) => restore(room(maxPages)).pipe(Effect.andThen(restore(opened).pipe(Effect.ensuring(Effect.sync(() => {
+		opening -= 1;
+		makeRoom();
+	}))))));
+	return {
+		makeRoom,
+		open
+	};
+};
+/** A call sent now and awaited later, by whatever needs its answer. */
+const sentNow = (sent) => {
+	sent.catch(() => void 0);
+	return sent;
+};
+/** Close tab resources after publishing their close; a browser loss speaks for all its tabs. */
+const closures = (lostBy, publish, now) => Effect.gen(function* () {
+	const closing = yield* Queue.unbounded();
+	yield* Queue.take(closing).pipe(Effect.tap(({ page, cause }) => Effect.sync(() => {
+		if (lostBy() === void 0) publish(new PageClosed({
+			at: now(),
+			page,
+			cause
+		}));
+	})), Effect.flatMap(({ scope }) => Scope.close(scope, Exit.void)), Effect.forever, Effect.forkScoped);
+	return closing;
+});
+/**
+* Build the service over a context the provider owns. The provider closes the context; this only
+* tracks its pages and events, for as long as the surrounding scope is open. Each page's protocol
+* session, capture and listeners end when that page closes or when the scope does, so a closed
+* tab retains nothing and the context keeps none of them afterwards.
+*/
+const make = Effect.fn("Browser.make")(function* (context, info, options = {}) {
+	const clock = yield* Clock.Clock;
+	const connection = yield* make$3;
+	const now = () => Number(clock.monotonicTimeNanosUnsafe()) / 1e6;
+	const { settings, eventHistory, maxPages } = yield* settingsOf(options);
+	const mapping$1 = mapping(now);
+	const timeline = make$1(eventHistory);
+	yield* Effect.addFinalizer(() => timeline.close);
+	const publish = timeline.publish;
+	if (info.expiresAt !== void 0) publish(new SessionEnding({
+		at: now(),
+		expiresAt: info.expiresAt
+	}));
+	const { lostBy, lost, lose, untilLost, native } = yield* watchLoss(context, info.expiresAt, clock, (cause) => publish(new Disconnected({
+		at: now(),
+		cause
+	})));
+	const inputGate = make$4({
+		now,
+		sequence: timeline.sequence,
+		closedBy: lostBy,
+		lost,
+		clock,
+		drain: settings.navigationTimeout
+	});
+	const registry = /* @__PURE__ */ new Map();
+	const registrations = /* @__PURE__ */ new WeakMap();
+	const registering = yield* Semaphore.make(1);
+	const pagesScope = yield* Scope.fork(yield* Scope.Scope);
+	const release = releaseNative(clock);
+	const budget = pageBudget(maxPages, () => registry.size, settings.actionTimeout, clock);
+	const closing = yield* closures(lostBy, publish, now);
+	const register = (playwright) => registering.withPermits(1)(Effect.gen(function* () {
+		const known = registry.get(playwright);
+		if (known !== void 0) return known;
+		if (playwright.isClosed()) return yield* failWith("newPage", new Failed({ detail: "the page closed as it opened" }));
+		const scope = yield* Scope.fork(pagesScope);
+		return yield* Effect.gen(function* () {
+			let crashed = false;
+			const closedBy = () => lostBy() ?? (crashed ? "crashed" : "page");
+			const cdp = yield* native("newPage", () => context.newCDPSession(playwright));
+			yield* Effect.addFinalizer(() => release(() => cdp.detach()));
+			const send = (method, params) => untilLost(cdp.send(method, params));
+			const focusing = sentNow(send("Emulation.setFocusEmulationEnabled", { enabled: true }));
+			const paging = sentNow(send("Page.enable"));
+			const { targetInfo } = yield* native("newPage", () => send("Target.getTargetInfo"));
+			const id = targetInfo.targetId;
+			const page = yield* make$5({
+				id,
+				session: info.id,
+				connection,
+				url: targetInfo.url,
+				playwright,
+				cdp,
+				untilLost,
+				settings,
+				inputGate,
+				clock,
+				mapping: mapping$1,
+				publish,
+				recentEvents: eventsOf(timeline.recent, id),
+				openings: yield* make$2(playwright, cdp, registrations, closedBy),
+				focused: call("focus", () => focusing, closedBy).pipe(Effect.asVoid),
+				paging: (operation) => call(operation, () => paging, closedBy).pipe(Effect.asVoid),
+				closedBy,
+				capture: info.capture
+			});
+			const close = () => {
+				if (registry.get(playwright) !== page) return;
+				registry.delete(playwright);
+				budget.makeRoom();
+				Queue.offerUnsafe(closing, {
+					scope,
+					page: id,
+					cause: crashed ? "crashed" : "page"
+				});
+			};
+			const crash = () => {
+				crashed = true;
+				playwright.close().catch(() => void 0);
+			};
+			registry.set(playwright, page);
+			publish(new PageOpened({
+				at: now(),
+				page: id,
+				url: redact(targetInfo.url),
+				opener: targetInfo.openerId
+			}));
+			yield* listen(playwright, id, publish, now, {
+				close,
+				crash
+			});
+			if (playwright.isClosed()) close();
+			return page;
+		}).pipe(Scope.provide(scope), Effect.onError(() => Scope.close(scope, Exit.void)));
+	}));
+	for (const script of options.initScripts ?? []) yield* native("initScripts", () => context.addInitScript({ content: scoped(script) }));
+	yield* followOpened(context, register, publish, now, registrations);
+	for (const existing of context.pages()) yield* register(existing);
+	const pages = Effect.sync(() => [...registry.values()]);
+	const newPage = Effect.fn("Browser.newPage")(function* (url) {
+		const page = yield* budget.open(native("newPage", () => context.newPage()).pipe(Effect.flatMap((playwright) => register(playwright).pipe(Effect.onError(() => release(() => playwright.close()))))));
+		if (url !== void 0) yield* page.goto(url).pipe(Effect.onError(() => page.close.pipe(Effect.ignore)));
+		return page;
+	});
+	yield* Effect.addFinalizer(() => Effect.sync(() => lose("released")));
+	const service = {
+		id: info.id,
+		connection,
+		provider: info.provider,
+		expiresAt: info.expiresAt,
+		now: Effect.sync(now),
+		suspend: (options = {}) => Effect.map(inputGate.suspend(options.drain), (held) => new Suspension(held)),
+		context,
+		pages,
+		page: (id) => Effect.map(pages, (open) => Option.fromNullishOr(open.find((page) => page.id === id))),
+		firstPage: pages.pipe(Effect.map((open) => Option.fromNullishOr(open[0])), Effect.flatMap(Option.match({
+			onNone: () => newPage(),
+			onSome: Effect.succeed
+		}))),
+		newPage,
+		disconnected: lost,
+		events: (eventOptions = {}) => timeline.stream(eventOptions.after),
+		recentEvents: timeline.recent.pipe(Effect.map((records) => records.map((record) => record.event)))
+	};
+	return Browser.of(service);
+});
+//#endregion
+export { make as i, Browser_exports as n, Suspension as r, Browser as t };
+
+//# sourceMappingURL=Browser-B4qncxe7.mjs.map