effect-browser 0.2.0-beta.5 → 0.2.0-beta.7

package/dist/{BrowserRuntime-DImn_Oe_.mjs → BrowserRuntime-Cr76CN4I.mjs}

@@ -1,7 +1,7 @@
 import { BrowserError, InitializationError, Reasons } from "./Errors.mjs";
 import { ActionResult, AutomationOptions, BrowserDiagnostic, BrowserDiagnostics, BrowserPolicy, Checkpoint, CheckpointOptions, ClickRequest, ControlFacts, FillFormOptions, FillFormRequest, FillFormResult, FillRequest, FrameInfo, HoverRequest, Identifier, InlineFiles, InputReceipt, KeyStroke, NavigateRequest, NavigationResult, Observation, ObservationOptions, ObservedControl, ObservedElement, PageExecutionState, PageInfo, PageSuspension, PointerMoveRequest, PressRequest, ReadTextRequest, SafeFilename, ScreenshotRequest, ScreenshotResult, ScrollRequest, SelectOptions, Selector, SessionStatus, StartNavigationRequest, Target, TextResult as TextResult$1, TypeRequest, Viewport, WaitForElementRequest, WheelRequest } from "./BrowserData.mjs";
 import { m as snapshot, o as Plan, p as invoke, u as empty } from "./Bootstrap-CeQOWBy6.mjs";
-import { a as NativeFailure, c as publicError, d as timeout, i as pngGeometry, l as safeDecode, o as closeWithin, s as failure, t as associate, u as sanitize } from "./Association-BsSfBYVx.mjs";
+import { a as NativeFailure, c as providerReason, d as sanitize, f as timeout, i as pngGeometry, l as publicError, o as closeWithin, s as failure, t as associate, u as safeDecode } from "./Association-CH3kPHXE.mjs";
 import { t as associatePageControl } from "./PageControlAssociation-DabEg5AR.mjs";
 import { Cause, Clock, Crypto, Deferred, Duration, Effect, Exit, FiberSet, Option, Redacted, Schema, Scope, Semaphore } from "effect";
 //#region src/internal/browser/Binding.ts
@@ -24,7 +24,7 @@ const fromNativeAttempt = (attempt) => ({ connect: (request) => Effect.tryPromis
 		return pending;
 	},
 	catch: (error) => Schema.is(InitializationError)(error) ? error : publicError(error, "connect", {
-		reason: Reasons.Provider.make({}),
+		reason: providerReason(error),
 		outcome: "unknown"
 	})
 }) });
@@ -3525,7 +3525,7 @@ const clientNavigationEmitter = (frame) => {
 * The connection's pages, frames and document epochs, and the one selected target every other
 * seam acts on. A page beyond the configured bound is handed to policy recovery, never tracked.
 */
-const makeTargets = (browser, context, options, connectionNamespace, closing, hooks) => {
+const makeTargets = (browser, context, options, connectionNamespace, closing, hooks, windows) => {
 	const entries = /* @__PURE__ */ new Map();
 	const byPage = /* @__PURE__ */ new WeakMap();
 	const frameIds = /* @__PURE__ */ new WeakMap();
@@ -3534,6 +3534,7 @@ const makeTargets = (browser, context, options, connectionNamespace, closing, ho
 	const navigating = /* @__PURE__ */ new Set();
 	let serial = 0, frameSerial = 0;
 	let creatingPage = false;
+	const arrivals = /* @__PURE__ */ new Set();
 	const epochOf = (frame) => documentEpochs.get(frame) ?? 0;
 	const frameId = (frame) => {
 		let id = frameIds.get(frame);
@@ -3552,6 +3553,7 @@ const makeTargets = (browser, context, options, connectionNamespace, closing, ho
 			off: []
 		};
 		byPage.set(page, entry);
+		for (const arrived of arrivals) arrived(entry);
 		if (entries.size >= options.maxPages) {
 			hooks.overflow(entry);
 			return entry;
@@ -3657,6 +3659,63 @@ const makeTargets = (browser, context, options, connectionNamespace, closing, ho
 		}
 	};
 	const urlOf = (frame) => safeDecode(URLText, frame.url());
+	/**
+	* Opens one page: in a window of its own when the browser opens one, else as a tab. The window's
+	* page arrives through the context's page event like any other, and its target id tells it
+	* apart from a popup arriving at the same time. It is registered, and sized, when this returns.
+	*/
+	const open = async (signal) => {
+		const arrived = [];
+		let wake = () => {};
+		const arrival = (entry) => {
+			arrived.push(entry);
+			wake();
+		};
+		const next = () => new Promise((resolve, reject) => {
+			const abort = () => reject(failure(Reasons.Interrupted.make({}), "unknown"));
+			if (signal.aborted) {
+				abort();
+				return;
+			}
+			signal.addEventListener("abort", abort, { once: true });
+			wake = () => {
+				signal.removeEventListener("abort", abort);
+				resolve();
+			};
+		});
+		const adopt = async (created) => {
+			for (let index = 0;; index++) {
+				while (arrived.length <= index) await next();
+				const candidate = arrived[index];
+				const id = candidate === void 0 ? void 0 : await targetId(candidate).catch(() => {});
+				if (candidate !== void 0 && id === created) return candidate;
+			}
+		};
+		/** Every other page that arrived meanwhile is from outside, and its policy applies now. */
+		const settle = (isOurs) => {
+			for (const entry of arrived) if (!isOurs(entry) && entries.get(entry.id) === entry) hooks.external(entry);
+		};
+		arrivals.add(arrival);
+		try {
+			const opened = await windows.open();
+			if (opened === void 0) {
+				const entry = register(await context.newPage());
+				settle((candidate) => candidate === entry);
+				return entry;
+			}
+			try {
+				const [entry] = await Promise.all([adopt(opened.targetId), opened.sized]);
+				settle((candidate) => candidate === entry);
+				return entry;
+			} catch (error) {
+				await closeWithin(opened.discard).catch(() => {});
+				settle((candidate) => candidate.targetId === void 0 || candidate.targetId === opened.targetId);
+				throw error;
+			}
+		} finally {
+			arrivals.delete(arrival);
+		}
+	};
 	const selectedUrl = () => urlOf(selectedCurrent().frame);
 	const url = (target) => urlOf(current(target).frame);
 	/**
@@ -3667,7 +3726,7 @@ const makeTargets = (browser, context, options, connectionNamespace, closing, ho
 		if (options.newPage || entries.size === 0) {
 			creatingPage = true;
 			try {
-				selection.entry = register(await context.newPage());
+				selection.entry = await open(AbortSignal.timeout(15e3));
 			} finally {
 				creatingPage = false;
 			}
@@ -3708,11 +3767,10 @@ const makeTargets = (browser, context, options, connectionNamespace, closing, ho
 			selected: selection.entry === entry
 		});
 	};
+	/** Each page's title is its own round trip, so they are read together rather than in turn. */
 	const listPages = (ticket) => sanitize(async () => {
 		ticket.check();
-		const output = [];
-		for (const entry of entries.values()) output.push(await pageInfo(entry, ticket));
-		return output;
+		return Promise.all([...entries.values()].map((entry) => pageInfo(entry, ticket)));
 	});
 	const explicitPage = async (page, ticket) => {
 		ticket.check();
@@ -3723,6 +3781,7 @@ const makeTargets = (browser, context, options, connectionNamespace, closing, ho
 		if (entries.get(entry.id) !== entry || entry.page.isClosed()) throw failure(Reasons.Stale.make({}), "undispatched");
 		return entry;
 	};
+	const describePage = (page, ticket) => sanitize(async () => pageInfo(await explicitPage(page, ticket), ticket));
 	const resolvePage = (page, ticket) => sanitize(async () => {
 		const entry = await explicitPage(page, ticket);
 		return {
@@ -3748,12 +3807,11 @@ const makeTargets = (browser, context, options, connectionNamespace, closing, ho
 		creatingPage = true;
 		let entry;
 		try {
-			const page = await context.newPage();
+			entry = await open(ticket.signal);
 			if (ticket.signal.aborted) {
-				await closeWithin(() => page.close()).catch(() => {});
+				await closeWithin(() => entry.page.close()).catch(() => {});
 				ticket.check();
 			}
-			entry = register(page);
 		} finally {
 			creatingPage = false;
 		}
@@ -3765,6 +3823,12 @@ const makeTargets = (browser, context, options, connectionNamespace, closing, ho
 		await entry.page.close({ runBeforeUnload: false });
 		ticket.check();
 	});
+	const containPage = async (pageId) => {
+		const entry = entries.get(pageId);
+		if (entry === void 0) return;
+		await closeWithin(() => entry.page.close({ runBeforeUnload: false }));
+		if (!entry.page.isClosed()) throw failure(Reasons.Failed.make({}));
+	};
 	const listFrames = (ticket, page) => sanitize(async () => {
 		ticket.check();
 		const frames = (page === void 0 ? selectedCurrent().entry : await explicitPage(page, ticket)).page.frames();
@@ -3824,10 +3888,12 @@ const makeTargets = (browser, context, options, connectionNamespace, closing, ho
 		selected,
 		selectedTargetId,
 		listPages,
+		describePage,
 		resolvePage,
 		selectPage,
 		newPage,
 		closePage,
+		containPage,
 		listFrames,
 		resolveFrame,
 		selectFrame
@@ -3836,6 +3902,12 @@ const makeTargets = (browser, context, options, connectionNamespace, closing, ho
 //#endregion
 //#region src/internal/browser/Playwright.ts
 const NativeWindow = Schema.Struct({ windowId: Schema.Natural });
+const CreatedTarget = Schema.Struct({ targetId: Identifier });
+/**
+* Playwright 1.63.0 reports the browser's own error reply to a CDP command this way. A reply is
+* the browser's answer that it did not do what was asked; anything else leaves that unknown.
+*/
+const refusedBy = (method, error) => error instanceof Error && error.message.includes(`Protocol error (${method})`) && !error.message.includes("session closed");
 /**
 * Connects to an already validated or host-resolved CDP endpoint and builds the one driver. The
 * import is lazy, so constructing any Layer cannot load Playwright or allocate a browser. A
@@ -3862,7 +3934,7 @@ const connectPlaywrightEndpoint = async (endpoint, signal, identity, options, ev
 		return driver;
 	} catch (error) {
 		await closeWithin(() => browser.close()).catch(() => {});
-		throw Schema.is(BrowserError)(error) || Schema.is(InitializationError)(error) || Schema.is(NativeFailure)(error) ? error : failure(Reasons.Provider.make({}));
+		throw Schema.is(BrowserError)(error) || Schema.is(InitializationError)(error) || Schema.is(NativeFailure)(error) ? error : failure(providerReason(error));
 	}
 };
 /** Tests may supply a real already-connected browser. This is deliberately not an exported subpath. */
@@ -3882,6 +3954,7 @@ const makePlaywrightDriver = async (browser, identity, options, events) => {
 	let closing = false;
 	let initialized = false;
 	let browserCdp;
+	let windows = true;
 	let sameDocumentCapture = () => {};
 	const targets = makeTargets(browser, context, options, identity.namespace, () => closing, {
 		opened: (entry, created) => {
@@ -3895,6 +3968,11 @@ const makePlaywrightDriver = async (browser, identity, options, events) => {
 			if (initialized) initialization.attachPage(entry.page);
 			if (initialized && !created && options.popupPolicy === "pause") events.pause("popup");
 		},
+		external: (entry) => {
+			if (!initialized) return;
+			if (options.popupPolicy === "close") policyCleanup.run(entry.page, () => entry.page.close({ runBeforeUnload: false }));
+			else if (options.popupPolicy === "pause") events.pause("popup");
+		},
 		overflow: (entry) => {
 			if (options.popupPolicy === "close") policyCleanup.run(entry.page, () => entry.page.close({ runBeforeUnload: false }), { overflow: "popup-overflow" });
 			else events.fault({
@@ -3941,7 +4019,29 @@ const makePlaywrightDriver = async (browser, identity, options, events) => {
 			}
 		},
 		changed: (reason, scope) => observation.changed(reason, scope)
-	});
+	}, { open: async () => {
+		if (!windows) return void 0;
+		const cdp = browserSession();
+		let created;
+		try {
+			created = await cdp.send("Target.createTarget", {
+				url: "about:blank",
+				newWindow: true
+			});
+		} catch (error) {
+			if (!refusedBy("Target.createTarget", error)) throw error;
+			windows = false;
+			return;
+		}
+		const { targetId } = safeDecode(CreatedTarget, created);
+		return {
+			targetId,
+			sized: options.preserveViewport ? Promise.resolve() : sizeNativeWindow(targetId),
+			discard: async () => {
+				await cdp.send("Target.closeTarget", { targetId });
+			}
+		};
+	} });
 	const { current, entries, register } = targets;
 	const initialization = makeInitialization(context, options, identity.bindings, targets, callbacks, events, () => closing);
 	const observation = makeObservation(targets, identity.namespace, events);
@@ -3970,26 +4070,32 @@ const makePlaywrightDriver = async (browser, identity, options, events) => {
 	};
 	context.on("page", onPage);
 	browser.on("disconnected", onDisconnected);
-	const sizeNativeContents = async (entry) => {
+	const browserSession = () => {
 		if (browserCdp === void 0) throw failure(Reasons.Closed.make({}), "undispatched");
-		const targetId = await targets.targetId(entry);
-		const current = await browserCdp.send("Browser.getWindowForTarget", { targetId });
+		return browserCdp;
+	};
+	const sizeNativeWindow = async (targetId) => {
+		const cdp = browserSession();
+		const current = await cdp.send("Browser.getWindowForTarget", { targetId });
 		const native = safeDecode(NativeWindow, current);
-		await browserCdp.send("Browser.setContentsSize", {
+		await cdp.send("Browser.setContentsSize", {
 			windowId: native.windowId,
 			width: options.viewport.width,
 			height: options.viewport.height
 		});
 	};
+	const sizeNativeContents = async (entry) => sizeNativeWindow(await targets.targetId(entry));
 	const driver = {
 		...options.pageControl ? { pageControl: pageControl.operations } : {},
 		selected: targets.selected,
 		selectedTargetId: targets.selectedTargetId,
 		listPages: targets.listPages,
+		describePage: targets.describePage,
 		resolvePage: targets.resolvePage,
 		selectPage: targets.selectPage,
 		newPage: targets.newPage,
 		closePage: targets.closePage,
+		containPage: targets.containPage,
 		listFrames: targets.listFrames,
 		resolveFrame: targets.resolveFrame,
 		selectFrame: targets.selectFrame,
@@ -4236,6 +4342,7 @@ const makeSession = (controls, bindings) => {
 			kind: "type"
 		}))),
 		pages: controls.pages,
+		describePage: (page) => checked(PageInfo, page, "describe-page").pipe(Effect.flatMap(controls.describePage)),
 		frames: controls.frames,
 		framesOf: (page) => checked(PageInfo, page, "list-frames").pipe(Effect.flatMap(controls.framesOf)),
 		pinPage: (page) => checked(PageInfo, page, "target").pipe(Effect.flatMap(controls.pinPage), Effect.map(makePinnedTarget)),
@@ -4526,6 +4633,7 @@ const makeOwner = Effect.fnUntraced(function* (limits) {
 	};
 	const guard = (operation, body, options = {}) => Effect.suspend(() => {
 		let admitted;
+		const waitUntil = options.waitUntil ?? (options.queue === true ? Number(clock.monotonicTimeNanosUnsafe()) / 1e6 + Math.min(options.timeoutMillis ?? limits.actionTimeoutMillis, limits.actionTimeoutMillis) : void 0);
 		const work = Effect.gen(function* () {
 			holdingPermit = true;
 			if (!(options.phases ?? ["open"]).includes(state.phase) || policies.size > 0) return yield* BrowserError.make({
@@ -4543,7 +4651,7 @@ const makeOwner = Effect.fnUntraced(function* (limits) {
 					outcome: "undispatched"
 				});
 			}
-			const deadline = Math.min(options.waitUntil ?? now + limits.actionTimeoutMillis, options.timeoutMillis === void 0 ? Number.POSITIVE_INFINITY : now + options.timeoutMillis, lifetimeDeadline);
+			const deadline = Math.min(waitUntil ?? now + limits.actionTimeoutMillis, options.timeoutMillis === void 0 ? Number.POSITIVE_INFINITY : now + options.timeoutMillis, lifetimeDeadline);
 			if (now >= deadline) return yield* BrowserError.make({
 				operation,
 				reason: Reasons.Timeout.make({}),
@@ -4600,14 +4708,42 @@ const makeOwner = Effect.fnUntraced(function* (limits) {
 				}
 			};
 			admitted = ticket;
-			const uncertain = () => {
+			let abandoned = false;
+			const abandon = () => {
 				if (Number(clock.monotonicTimeNanosUnsafe()) / 1e6 >= lifetimeDeadline) expire();
 				const fenced = controller.signal.aborted;
 				controller.abort();
-				if (dispatched && !fenced && state.phase !== "closing" && state.phase !== "closed") fence("uncertain", "uncertain");
+				if (dispatched && !fenced && state.phase !== "closing" && state.phase !== "closed") abandoned = true;
 			};
+			const current = () => state.generation === generation && state.phase === "open";
+			/**
+			* Work given up after dispatch fences the owner, since nothing knows what it did or
+			* whether more of it will land. An operation confined to one page it may close instead
+			* closes that page: once the browser confirms it closed, nothing still bound for it can
+			* land anywhere, and every other page keeps working. It is still never replayed.
+			*/
+			const settle = Effect.uninterruptible(Effect.suspend(() => {
+				if (!abandoned) return Effect.void;
+				abandoned = false;
+				const page = current() ? options.contain?.() : void 0;
+				if (page === void 0) return Effect.sync(() => fence("uncertain", "uncertain"));
+				return page.close.pipe(Effect.map((closed) => {
+					if (!closed || !current()) {
+						fence("uncertain", "uncertain");
+						return;
+					}
+					unresolved.delete(controller);
+					const reservation = reservations.get(page.pageId);
+					if (reservation !== void 0) {
+						reservations.delete(page.pageId);
+						unresolved.delete(reservation);
+						reservation.abort();
+					}
+					record("page-contained", "confirmed");
+				}));
+			}));
 			return yield* within(body(ticket), ticket.deadline, () => {
-				uncertain();
+				abandon();
 				return BrowserError.make({
 					operation,
 					reason: Reasons.Timeout.make({}),
@@ -4621,21 +4757,21 @@ const makeOwner = Effect.fnUntraced(function* (limits) {
 					outcome: dispatched ? "unknown" : "undispatched"
 				})
 			})), Effect.catch((error) => {
-				if (dispatched) uncertain();
-				if (!Schema.is(BrowserError)(error)) return Effect.fail(error);
-				return Effect.fail(BrowserError.make({
+				if (dispatched) abandon();
+				const failure = Schema.is(BrowserError)(error) ? Effect.fail(BrowserError.make({
 					operation,
 					reason: error.reason,
 					outcome: error.outcome
-				}));
-			}), Effect.onInterrupt(() => Effect.sync(uncertain)), Effect.tap(() => Effect.sync(() => unresolved.delete(controller))), Effect.ensuring(Effect.sync(() => {
+				})) : Effect.fail(error);
+				return settle.pipe(Effect.andThen(failure));
+			}), Effect.onInterrupt(() => Effect.sync(abandon).pipe(Effect.andThen(settle))), Effect.tap(() => Effect.sync(() => unresolved.delete(controller))), Effect.ensuring(Effect.sync(() => {
 				controller.abort();
 				if (active === controller) active = void 0;
 			})));
 		}).pipe(Effect.ensuring(Effect.sync(() => {
 			holdingPermit = false;
 		})));
-		if (options.waitUntil !== void 0) return within(semaphore.withPermits(1)(work), Math.min(options.waitUntil, lifetimeDeadline), () => BrowserError.make({
+		if (waitUntil !== void 0) return within(semaphore.withPermits(1)(work), Math.min(waitUntil, lifetimeDeadline), () => BrowserError.make({
 			operation,
 			reason: Reasons.Timeout.make({}),
 			outcome: admitted?.dispatched === true ? "unknown" : "undispatched"
@@ -4714,8 +4850,8 @@ const makeOwner = Effect.fnUntraced(function* (limits) {
 	};
 });
 /** Without a native answer, whether the step was sent is all the owner knows about it. */
-const unsettled = (ticket) => ({
-	reason: Reasons.Provider.make({}),
+const unsettled = (ticket, error) => ({
+	reason: providerReason(error),
 	outcome: ticket.dispatched ? "unknown" : "undispatched"
 });
 /**
@@ -4748,12 +4884,12 @@ const native = (operation, ticket, body) => Effect.callback((resume) => {
 		}, (error) => {
 			if (!done) {
 				cleanup();
-				resume(Effect.fail(publicError(error, operation, unsettled(ticket))));
+				resume(Effect.fail(publicError(error, operation, unsettled(ticket, error))));
 			}
 		});
 	} catch (error) {
 		cleanup();
-		resume(Effect.fail(publicError(error, operation, unsettled(ticket))));
+		resume(Effect.fail(publicError(error, operation, unsettled(ticket, error))));
 	}
 	return Effect.sync(cleanup);
 });
@@ -5165,6 +5301,27 @@ const acquireSession = Effect.fnUntraced(function* (limits, options) {
 			outcome: "undispatched"
 		})) : Effect.void;
 	});
+	/**
+	* A page other than the selected one can take an unknown outcome of its own mutation with it:
+	* closing it ends everything still bound for it, where the selected page and every other one
+	* go on working. The selected page's own outcome still fences, since direct operations follow
+	* it and nothing could be selected in its place.
+	*/
+	const containment = (pageId) => {
+		const current = driver;
+		if (current === void 0) return void 0;
+		let selected;
+		try {
+			selected = current.selected().pageId;
+		} catch {
+			return;
+		}
+		if (selected === pageId) return void 0;
+		return {
+			pageId,
+			close: Effect.promise(() => current.containPage(pageId).then(() => true, () => false))
+		};
+	};
 	const waitFree = (operation, pageId) => Effect.suspend(() => owner.waitPending(pageId) ? Effect.fail(BrowserError.make({
 		operation,
 		reason: Reasons.Busy.make({}),
@@ -5257,7 +5414,8 @@ const acquireSession = Effect.fnUntraced(function* (limits, options) {
 		}), {
 			mutation,
 			mutationScope: () => ({ pageId: browserTarget?.pageId ?? getDriver().selected().pageId }),
-			preflight: mutation ? Effect.suspend(check).pipe(Effect.andThen(unreserved(operation, browserTarget))) : Effect.suspend(check)
+			preflight: mutation ? Effect.suspend(check).pipe(Effect.andThen(unreserved(operation, browserTarget))) : Effect.suspend(check),
+			...browserTarget === void 0 ? {} : { contain: () => containment(browserTarget.pageId) }
 		});
 		const operationTarget = () => retained?.target === void 0 ? capture.target() : Target.make({
 			generation: retained.generation,
@@ -5322,6 +5480,7 @@ const acquireSession = Effect.fnUntraced(function* (limits, options) {
 				});
 				const loadingTimeout = Math.min(timeoutMillis, remainingLifetime);
 				const navigation = await driver.beginNavigation(url, loadingTimeout, ticket, browserTarget, control);
+				ticket.check();
 				return {
 					target,
 					navigation,
@@ -5623,6 +5782,7 @@ const acquireSession = Effect.fnUntraced(function* (limits, options) {
 		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 }),
+		describePage: (page) => nativeOperation("describe-page", (driver, ticket) => driver.describePage(page, ticket), { charge: false }),
 		frames: nativeOperation("list-frames", (driver, ticket) => driver.listFrames(ticket), { charge: false }),
 		framesOf: (page) => nativeOperation("list-frames", (driver, ticket) => driver.listFrames(ticket, page), { charge: false }),
 		pinPage: (page) => pinned((driver, ticket) => driver.resolvePage(page, ticket)),
@@ -5635,11 +5795,13 @@ const acquireSession = Effect.fnUntraced(function* (limits, options) {
 			await driver.selectFrame(id, ticket);
 			owner.state.selection++;
 		}, { charge: false }),
+		/** No other page's work conflicts with opening one, so it waits its turn rather than refusing. */
 		createPage: () => nativeOperation("new-page", (driver, ticket) => driver.newPage(ticket), {
 			mutation: true,
 			mutationScope: () => "none",
 			charge: false,
-			anyPage: true
+			anyPage: true,
+			queue: true
 		}),
 		closePage: (page) => nativeOperation("close-page", (driver, ticket) => driver.closePage(page, ticket), {
 			mutation: true,
@@ -5895,4 +6057,4 @@ const make = Effect.fnUntraced(function* (options) {
 //#endregion
 export { cleanupStep as a, checked as c, randomUuid as i, fromNativeAttempt as l, make as n, noConnection as o, playwright as r, reported as s, DownloadEvent as t, issueBinding as u };
 
-//# sourceMappingURL=BrowserRuntime-DImn_Oe_.mjs.map
+//# sourceMappingURL=BrowserRuntime-Cr76CN4I.mjs.map