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

package/dist/Change-iMlcuzVD.d.mts

@@ -0,0 +1,71 @@
+import { b as Subject } from "./BrowserEvent-BRu2juEz.mjs";
+import { Schema } from "effect";
+declare namespace Change_d_exports {
+  export { Change, Changes, Kind, describe };
+}
+/**
+ * `text` changed; `appeared` and `disappeared`, whether added or removed or shown or hidden;
+ * `brief`, appeared and gone again by the window's end; `value`, a field's; `title`, the document's.
+ */
+declare const Kind: Schema.Literals<readonly ["text", "appeared", "disappeared", "brief", "value", "title"]>;
+type Kind = typeof Kind.Type;
+declare const Change_base: Schema.Class<Change, Schema.Struct<{
+  readonly kind: Schema.Literals<readonly ["text", "appeared", "disappeared", "brief", "value", "title"]>;
+  /**
+   * What changed, as the page names it now, or where it was for what went. Its own words are what
+   * changed, so its name is empty unless something else names it, as a field's label does.
+   */
+  readonly subject: typeof Subject;
+  /** When it first changed in the window, in host monotonic milliseconds on the browser's clock. */
+  readonly startedAt: Schema.Finite;
+  /** When it last changed in the window. */
+  readonly at: Schema.Finite;
+  /**
+   * What it showed at the window's start; absent for what appeared and where the record let that go.
+   * What disappeared says what it showed as it went. A field's value reads `••••` unless unmasked.
+   */
+  readonly before: Schema.optional<Schema.String>;
+  /** What it showed at the window's end; absent for what disappeared. What came and went says what it showed. */
+  readonly after: Schema.optional<Schema.String>;
+  /** How many times what it showed changed in the window. */
+  readonly count: Schema.Int;
+  /** For a number that changed more than once, its lowest and highest, as shown. */
+  readonly lowest: Schema.optional<Schema.String>;
+  readonly highest: Schema.optional<Schema.String>;
+  /** When it last changed before the window, as far back as the record keeps: in flux, not news. */
+  readonly earlier: Schema.optional<Schema.Finite>;
+  /**
+   * When the trusted input it followed reached the page, where it was that input's doing. It was not
+   * in flux: in the 10 s before the input it had not changed, and nothing had come into or left what
+   * it sits in, so a ticker's tick or a feed's line is not. Then it changed within 3 s inside what
+   * the input acted on or its row, form, dialog or controlled element; or, elsewhere, within 500 ms
+   * of an input on a page where nothing had changed in the 2 s before, as a menu a portal puts at
+   * the end of the page does. What holds the input's target, as a menu holds its item, does not
+   * count against it. The page's `Action` that sent it holds that time.
+   */
+  readonly cause: Schema.optional<Schema.Finite>;
+}>, {}>;
+declare class Change extends Change_base {}
+declare const Changes_base: Schema.Class<Changes, Schema.Struct<{
+  /** The page's document these changes belong to, as `Navigated` counts them. */
+  readonly document: Schema.Int;
+  /** Where the record is whole: before it, changes may be missing. */
+  readonly from: Schema.Finite;
+  /** Where the window ends: its `until`, or when the page was read. */
+  readonly until: Schema.Finite;
+  /**
+   * Where the window ends on the page's own clock. Give these changes as the next read's `since` and
+   * the two windows meet exactly, whatever the clock mapping does meanwhile.
+   */
+  readonly cursor: Schema.Finite;
+  /** Changes in the window the record let go, at least; 0 when it kept them all. */
+  readonly dropped: Schema.Int;
+  /** Oldest first, by when each began to change. */
+  readonly changes: Schema.$Array<typeof Change>;
+}>, {}>;
+declare class Changes extends Changes_base {}
+/** A change in words for a model, such as `"$61,240" became "$62,010" (row "Bitcoin", column "Price")`. */
+declare const describe: (change: Change) => string;
+//#endregion
+export { describe as a, Kind as i, Change_d_exports as n, Changes as r, Change as t };
+//# sourceMappingURL=Change-iMlcuzVD.d.mts.map

package/dist/Change.d.mts

@@ -0,0 +1,2 @@
+import { a as describe, i as Kind, r as Changes, t as Change } from "./Change-iMlcuzVD.mjs";
+export { Change, Changes, Kind, describe };

package/dist/Change.mjs

@@ -0,0 +1,2 @@
+import { a as describe, i as Kind, r as Changes, t as Change } from "./Change-DNvztNLu.mjs";
+export { Change, Changes, Kind, describe };

package/dist/Chromium.d.mts

@@ -1,85 +1,33 @@
-import { BrowserError, InitializationError } from "./Errors.mjs";
-import { it as Viewport, o as BrowserPolicy, r as AutomationOptions } from "./BrowserData-CPIIIHol.mjs";
-import { c as OpenOptions, i as BrowserSession } from "./Browser-BF9_sORP.mjs";
-import { Context, Crypto, Effect, Layer, Option, Redacted, Schema, Scope } from "effect";
-//#region src/internal/chromium/Data.d.ts
-declare const ChromiumReference_base: Schema.Class<ChromiumReference, Schema.Struct<{
-  readonly provider: Schema.Literal<"chromium">;
-  readonly id: Schema.NonEmptyString;
-}>, {}>;
-/** Identifies this Chromium ownership lifetime, not a reusable endpoint. */
-export declare class ChromiumReference extends ChromiumReference_base {}
-declare const ChromiumCleanupIssue_base: Schema.Class<ChromiumCleanupIssue, Schema.Struct<{
-  readonly step: Schema.Literals<readonly ["fence", "capture", "initialization", "disconnect", "terminate", "profile"]>;
-  readonly reason: Schema.Literals<readonly ["timeout", "failed", "interrupted"]>;
-}>, {}>;
-export declare class ChromiumCleanupIssue extends ChromiumCleanupIssue_base {}
-declare const ChromiumCleanupResult_base: Schema.Class<ChromiumCleanupResult, Schema.Struct<{
-  readonly reference: typeof ChromiumReference;
-  readonly ownership: Schema.Literals<readonly ["owned", "borrowed"]>;
-  readonly connection: Schema.Literals<readonly ["closed", "failed", "not-connected", "pending"]>;
-  readonly process: Schema.Literals<readonly ["terminated", "unknown", "not-owned"]>;
-  readonly issues: Schema.$Array<typeof ChromiumCleanupIssue>;
-}>, {}>;
-/** Connection teardown and observed process exit are separate facts; no provider status exists. */
-export declare class ChromiumCleanupResult extends ChromiumCleanupResult_base {}
-export declare const ChromiumLaunch: Schema.Struct<{
-  readonly executablePath: Schema.optionalKey<Schema.NonEmptyString>;
-  readonly headless: Schema.optionalKey<Schema.Boolean>;
-  /** Enabled by default; a trusted host must explicitly choose a sandbox exception. */
-  readonly chromiumSandbox: Schema.optionalKey<Schema.Boolean>;
-  readonly args: Schema.optionalKey<Schema.$Array<Schema.NonEmptyString>>;
-  readonly proxy: Schema.optionalKey<Schema.Struct<{
-    readonly server: Schema.NonEmptyString;
-    readonly bypass: Schema.optionalKey<Schema.NonEmptyString>;
-  }>>;
-  readonly startupTimeoutMillis: Schema.optionalKey<Schema.Int>;
-}>;
-export type ChromiumLaunch = typeof ChromiumLaunch.Type;
-//#endregion
-//#region src/Chromium.d.ts
-/** Host-only process configuration. Building this layer neither loads Playwright nor starts Chromium. */
-export interface ChromiumOptions extends AutomationOptions {
-  readonly launch?: ChromiumLaunch;
-  readonly viewport?: Viewport;
-  readonly onCleanup?: (result: ChromiumCleanupResult) => Effect.Effect<void>;
-}
-/** An owned or borrowed Chromium lifetime with one modeled browser connection. */
-export interface ChromiumSession<E = never> extends BrowserSession<E> {
-  readonly reference: ChromiumReference;
-  readonly closeChecked: Effect.Effect<ChromiumCleanupResult, BrowserError>;
-  readonly close: Effect.Effect<ChromiumCleanupResult>;
-  readonly cleanupResult: Effect.Effect<Option.Option<ChromiumCleanupResult>>;
-}
-export interface ChromiumAcquisition<E = never> {
-  readonly reference: ChromiumReference;
-  readonly failure: Effect.Effect<never, E | InitializationError>;
-  readonly connect: Effect.Effect<ChromiumSession<E>, BrowserError | InitializationError | E>;
-  readonly close: Effect.Effect<ChromiumCleanupResult>;
-}
-export interface ChromiumAttachRequest<E = never, R = never> extends OpenOptions<E, R> {
-  readonly policy: BrowserPolicy;
-  /** Resolve this exact target; without it, multiple open pages are an ambiguity error. */
-  readonly target?: {
-    readonly targetId: string;
-  };
+import { t as BrowserError } from "./BrowserError-Coy7EW1N.mjs";
+import { Browser, Options as Options$1, Service, t as Browser_d_exports } from "./Browser.mjs";
+import { Effect, Layer } from "effect";
+declare namespace Chromium_d_exports {
+  export { Options, layer, open };
 }
-declare const Chromium_base: Context.ServiceClass<Chromium, "effect-browser/Chromium", {
-  readonly acquire: <E = never, R = never>(policy: BrowserPolicy, request?: OpenOptions<E, R>) => Effect.Effect<ChromiumAcquisition<E>, BrowserError, Scope.Scope | Exclude<R, Scope.Scope>>;
-  readonly launch: <E = never, R = never>(policy: BrowserPolicy, request?: OpenOptions<E, R>) => Effect.Effect<ChromiumSession<E>, BrowserError | InitializationError | E, Scope.Scope | Exclude<R, Scope.Scope>>;
-  /** A concrete loopback ws://.../devtools/browser/... endpoint; this scope owns only its connection. */
-  readonly attach: <E = never, R = never>(endpoint: Redacted.Redacted<string>, request: ChromiumAttachRequest<E, R>) => Effect.Effect<ChromiumSession<E>, BrowserError | InitializationError | E, Scope.Scope | Exclude<R, Scope.Scope>>;
-}>;
-export declare class Chromium extends Chromium_base {
-  /** Launch through the configured service; compose with Browser.scoped for supervised ownership. */
-  static launch<E = never, R = never>(policy: BrowserPolicy, request?: OpenOptions<E, R>): Effect.Effect<ChromiumSession<E>, E | BrowserError | InitializationError, Chromium | Scope.Scope | Exclude<R, Scope.Scope>>;
-  /** Acquire the process lifetime before connecting, using the caller's scope. */
-  static acquire<E = never, R = never>(policy: BrowserPolicy, request?: OpenOptions<E, R>): Effect.Effect<ChromiumAcquisition<E>, BrowserError, Chromium | Scope.Scope | Exclude<R, Scope.Scope>>;
-  /** Borrow a concrete loopback endpoint; cleanup never terminates its external process. */
-  static attach<E = never, R = never>(endpoint: Redacted.Redacted<string>, request: ChromiumAttachRequest<E, R>): Effect.Effect<ChromiumSession<E>, E | BrowserError | InitializationError, Chromium | Scope.Scope | Exclude<R, Scope.Scope>>;
-  /** Chromium references, connection ids and handoff tokens come from the required `Crypto`. */
-  static layer(options?: ChromiumOptions): Layer.Layer<Chromium, BrowserError, Crypto.Crypto>;
+export interface Options extends Options$1 {
+  /** Defaults to true. */
+  readonly headless?: boolean | undefined;
+  /**
+   * Run Chromium's sandbox. Defaults to false, as in Playwright, so an exploit in a page's renderer
+   * runs with this process's privileges. Hosts that don't allow unprivileged user namespaces, such
+   * as many containers and Ubuntu 23.10 or later by default, can't start the sandbox; opening then
+   * fails and says so.
+   */
+  readonly sandbox?: boolean | undefined;
+  /** Defaults to 1280x720 CSS pixels at a device scale factor of 1. */
+  readonly viewport?: {
+    readonly width: number;
+    readonly height: number;
+  } | undefined;
+  readonly executablePath?: string | undefined;
+  readonly args?: ReadonlyArray<string> | undefined;
+  readonly userAgent?: string | undefined;
+  readonly locale?: string | undefined;
 }
+/** Launch Chromium and open a `Browser` over a fresh context. */
+export declare const open: (options?: Options | undefined) => Effect.Effect<Service, BrowserError, import("effect/Scope").Scope>;
+/** A `Browser` Layer that launches Chromium when built and closes it when released. */
+export declare const layer: (options?: Options) => Layer.Layer<Browser, BrowserError>;
 //#endregion
-export {};
+export { Chromium_d_exports as t };
 //# sourceMappingURL=Chromium.d.mts.map

package/dist/Chromium.mjs

@@ -1,399 +1,64 @@
-import { BrowserError, Reasons } from "./Errors.mjs";
-import { Identifier } from "./BrowserData.mjs";
-import { n as make } from "./BrowserRuntime-C1r2aSRK.mjs";
-import { O as span, T as annotate, l as reported, o as randomUuid, s as cleanupStep, t as checked } from "./PublicSession-DCSMMqOj.mjs";
-import { Clock, Context, Crypto, Duration, Effect, Exit, Layer, Option, Path, Redacted, Schema } from "effect";
-import { spawn } from "node:child_process";
-import { mkdtemp, readFile, rm } from "node:fs/promises";
-import { tmpdir } from "node:os";
-//#region src/internal/chromium/Data.ts
-/** Identifies this Chromium ownership lifetime, not a reusable endpoint. */
-var ChromiumReference = class extends Schema.Class("ChromiumReference")({
-	provider: Schema.Literal("chromium"),
-	id: Identifier
-}) {};
-var ChromiumCleanupIssue = class extends Schema.Class("ChromiumCleanupIssue")({
-	step: Schema.Literals([
-		"fence",
-		"capture",
-		"initialization",
-		"disconnect",
-		"terminate",
-		"profile"
-	]),
-	reason: Schema.Literals([
-		"timeout",
-		"failed",
-		"interrupted"
-	])
-}) {};
-/** Connection teardown and observed process exit are separate facts; no provider status exists. */
-var ChromiumCleanupResult = class extends Schema.Class("ChromiumCleanupResult")({
-	reference: ChromiumReference,
-	ownership: Schema.Literals(["owned", "borrowed"]),
-	connection: Schema.Literals([
-		"closed",
-		"failed",
-		"not-connected",
-		"pending"
-	]),
-	process: Schema.Literals([
-		"terminated",
-		"unknown",
-		"not-owned"
-	]),
-	issues: Schema.Array(ChromiumCleanupIssue).check(Schema.isMaxLength(16))
-}) {};
-const Text = Schema.NonEmptyString.check(Schema.isMaxLength(4096), Schema.isPattern(/^[^\u0000\r\n]+$/u));
-const Port = Schema.Int.check(Schema.isBetween({
-	minimum: 1,
-	maximum: 65535
-}));
-/** Only a concrete loopback WebSocket is admitted: no HTTP discovery redirects or remote DNS. */
-const ChromiumEndpoint = Text.check(Schema.makeFilter((value) => {
-	try {
-		const url = new URL(value);
-		return url.protocol === "ws:" && ["127.0.0.1", "[::1]"].includes(url.hostname) && Schema.is(Port)(Number(url.port)) && !url.username && !url.password && !url.search && !url.hash && /^\/devtools\/browser\/[A-Za-z0-9_-]+$/u.test(url.pathname);
-	} catch {
-		return false;
-	}
-}));
-const ProxyServer = Text.check(Schema.makeFilter((value) => {
-	try {
-		const url = new URL(value);
-		return [
-			"http:",
-			"https:",
-			"socks5:"
-		].includes(url.protocol) && url.hostname.length > 0 && !url.username && !url.password && !url.search && !url.hash && ["", "/"].includes(url.pathname);
-	} catch {
-		return false;
-	}
-}));
-/** These arguments belong to the launcher; silently overriding them would change ownership. */
-const Argument = Text.check(Schema.makeFilter((value) => value.startsWith("--") && !/^--(?:user-data-dir|remote-debugging[^=]*|headless|no-sandbox|disable-setuid-sandbox|single-process|proxy-server|proxy-bypass-list|no-startup-window)(?:=|$)/u.test(value)));
-const ChromiumLaunch = Schema.Struct({
-	executablePath: Schema.optionalKey(Text),
-	headless: Schema.optionalKey(Schema.Boolean),
-	/** Enabled by default; a trusted host must explicitly choose a sandbox exception. */
-	chromiumSandbox: Schema.optionalKey(Schema.Boolean),
-	args: Schema.optionalKey(Schema.Array(Argument).check(Schema.isMaxLength(64))),
-	proxy: Schema.optionalKey(Schema.Struct({
-		server: ProxyServer,
-		bypass: Schema.optionalKey(Text)
-	})),
-	startupTimeoutMillis: Schema.optionalKey(Schema.Int.check(Schema.isBetween({
-		minimum: 1,
-		maximum: 6e4
-	})))
-});
-//#endregion
-//#region src/internal/chromium/Process.ts
-/** Explicit host sandbox/proxy choices; the owned profile and debugger endpoint cannot be replaced. */
-const launchArguments = (options, directory) => [
-	"--no-first-run",
-	"--no-default-browser-check",
-	"--remote-debugging-address=127.0.0.1",
-	"--remote-debugging-port=0",
-	"--remote-debugging-pipe",
-	`--user-data-dir=${directory}`,
-	...options.headless === false ? [] : ["--headless=new"],
-	...options.chromiumSandbox === false ? ["--no-sandbox"] : [],
-	...options.proxy === void 0 ? [] : [`--proxy-server=${options.proxy.server}`, `--proxy-bypass-list=${options.proxy.bypass ?? "<-loopback>"}`],
-	...options.args ?? [],
-	"--no-startup-window"
-];
-const failure = (operation, reason) => BrowserError.make({
-	operation,
-	reason,
-	outcome: operation === "close" ? "unknown" : "undispatched"
+import { t as __exportAll } from "./rolldown-runtime-D7D4PA-g.mjs";
+import { Failed } from "./BrowserError.mjs";
+import { i as make, t as Browser } from "./Browser-B4qncxe7.mjs";
+import { o as reasonOf, s as undispatched } from "./context-B6xr8nVi.mjs";
+import { Effect, Layer } from "effect";
+import { chromium } from "playwright-core";
+//#region src/Chromium.ts
+/**
+* A local Chromium, launched for the scope and closed with it.
+*
+* It uses the Chromium build that `playwright-core` installs
+* (`npx playwright-core install chromium`), unless `executablePath` names another.
+*
+* Signals are the program's to handle: run it with `NodeRuntime.runMain`, which interrupts it on
+* SIGINT and SIGTERM, so the browser closes with its scope.
+*
+* @since 0.3.0
+*/
+var Chromium_exports = /* @__PURE__ */ __exportAll({
+	layer: () => layer,
+	open: () => open
 });
-const exited = (child) => child.exitCode !== null || child.signalCode !== null;
-/** POSIX groups keep Chromium's helpers inside the same owned termination boundary. */
-const alive = (pid) => {
-	try {
-		process.kill(-pid, 0);
-		return true;
-	} catch (error) {
-		if (error instanceof Error && "code" in error && error.code === "ESRCH") return false;
-		throw error;
-	}
-};
-const signalGroup = (pid, signal) => {
-	try {
-		process.kill(-pid, signal);
-	} catch (error) {
-		if (!(error instanceof Error && "code" in error && error.code === "ESRCH")) throw error;
-	}
-};
-/** Called once; observes parent and helper exit, rather than treating a sent signal as cleanup. */
-const terminate = Effect.fnUntraced(function* (child, pid, clock) {
-	const stopped = Effect.try({
-		try: () => exited(child) && !alive(pid),
-		catch: () => failure("close", Reasons.Failed.make({}))
-	});
-	const signal = (value) => Effect.try({
-		try: () => signalGroup(pid, value),
-		catch: () => failure("close", Reasons.Failed.make({}))
-	});
-	const pause = clock.sleep(Duration.millis(20));
-	yield* signal("SIGTERM");
-	const graceful = clock.monotonicTimeNanosUnsafe() + 1500000000n;
-	while (!(yield* stopped) && clock.monotonicTimeNanosUnsafe() < graceful) yield* pause;
-	if (yield* stopped) return;
-	yield* signal("SIGKILL");
-	const forced = clock.monotonicTimeNanosUnsafe() + 1000000000n;
-	while (!(yield* stopped) && clock.monotonicTimeNanosUnsafe() < forced) yield* pause;
-	if (!(yield* stopped)) return yield* failure("close", Reasons.Timeout.make({}));
-}, span("Chromium.terminate"));
-/** Start only Chromium's process. The shared owner later opens its sole CDP connection. */
-const launch = Effect.fnUntraced(function* (options) {
-	if (process.platform === "win32") return yield* failure("launch", Reasons.Unsupported.make({}));
-	const path = yield* Path.Path.pipe(Effect.provide(Path.layer));
-	const clock = yield* Clock.Clock;
-	const executable = options.executablePath ?? (yield* Effect.tryPromise({
-		try: () => import("playwright-core").then(({ chromium }) => chromium.executablePath()),
-		catch: () => failure("launch", Reasons.Failed.make({}))
-	}));
-	const directory = yield* Effect.tryPromise({
-		try: () => mkdtemp(path.join(tmpdir(), "effect-browser-chromium-")),
-		catch: () => failure("launch", Reasons.Failed.make({}))
-	});
-	const removeProfile = Effect.tryPromise({
-		try: () => rm(directory, {
-			recursive: true,
-			force: true,
-			maxRetries: 5,
-			retryDelay: 50
+const launchTimeoutMillis = 18e4;
+const failed = (operation, timeoutMillis) => (cause) => undispatched(operation, reasonOf(cause, timeoutMillis));
+const sandboxFailed = /Chromium sandboxing failed|No usable sandbox/;
+const launchFailed = (cause) => sandboxFailed.test(String(cause)) ? undispatched("launch", new Failed({ detail: "Chromium's sandbox could not start on this host: it needs unprivileged user namespaces, and a user other than root" })) : failed("launch", launchTimeoutMillis)(cause);
+/** Launch Chromium and open a `Browser` over a fresh context. */
+const open = Effect.fn("Chromium.open")(function* (options = {}) {
+	const launched = yield* Effect.acquireRelease(Effect.tryPromise({
+		try: () => chromium.launch({
+			headless: options.headless ?? true,
+			chromiumSandbox: options.sandbox ?? false,
+			timeout: launchTimeoutMillis,
+			handleSIGINT: false,
+			handleSIGTERM: false,
+			handleSIGHUP: false,
+			...options.executablePath === void 0 ? {} : { executablePath: options.executablePath },
+			...options.args === void 0 ? {} : { args: [...options.args] }
 		}),
-		catch: () => failure("close", Reasons.Failed.make({}))
+		catch: launchFailed
+	}).pipe(Effect.withSpan("Chromium.launch", {}, { captureStackTrace: false })), (browser) => Effect.tryPromise(() => browser.close()).pipe(Effect.ignore));
+	const context = yield* Effect.tryPromise({
+		try: () => launched.newContext({
+			viewport: options.viewport ?? {
+				width: 1280,
+				height: 720
+			},
+			deviceScaleFactor: 1,
+			...options.userAgent === void 0 ? {} : { userAgent: options.userAgent },
+			...options.locale === void 0 ? {} : { locale: options.locale }
+		}),
+		catch: failed("launch")
 	});
-	let child;
-	return yield* Effect.gen(function* () {
-		const launched = yield* Effect.callback((resume) => {
-			const failed = () => resume(Effect.fail(failure("launch", Reasons.Failed.make({}))));
-			let spawned;
-			try {
-				spawned = spawn(executable, launchArguments(options, directory), {
-					cwd: directory,
-					stdio: [
-						"ignore",
-						"ignore",
-						"ignore",
-						"pipe",
-						"pipe"
-					],
-					detached: true
-				});
-			} catch {
-				failed();
-				return;
-			}
-			child = spawned;
-			spawned.once("spawn", () => resume(Effect.succeed(spawned)));
-			spawned.once("error", failed);
-		});
-		const pid = launched.pid;
-		if (pid === void 0) return yield* failure("launch", Reasons.Failed.make({}));
-		return {
-			connection: (timeoutMillis) => Effect.gen(function* () {
-				const deadline = clock.monotonicTimeNanosUnsafe() + BigInt(Math.ceil(Math.min(timeoutMillis, options.startupTimeoutMillis ?? 15e3))) * 1000000n;
-				while (clock.monotonicTimeNanosUnsafe() < deadline) {
-					if (exited(launched)) return yield* failure("connect", Reasons.Closed.make({}));
-					const portFile = yield* Effect.tryPromise({
-						try: (signal) => readFile(path.join(directory, "DevToolsActivePort"), {
-							encoding: "utf8",
-							signal
-						}).catch((error) => {
-							if (error instanceof Error && "code" in error && error.code === "ENOENT") return void 0;
-							throw error;
-						}),
-						catch: () => failure("connect", Reasons.Transport.make({}))
-					});
-					const lines = portFile === void 0 ? [] : portFile.trim().split("\n");
-					if (lines.length >= 2) {
-						const endpoint = `ws://127.0.0.1:${lines[0]}${lines[1]}`;
-						if (!Schema.is(ChromiumEndpoint)(endpoint)) return yield* failure("connect", Reasons.Malformed.make({}));
-						return Redacted.make(endpoint);
-					}
-					yield* clock.sleep(Duration.millis(20));
-				}
-				return yield* failure("connect", Reasons.Timeout.make({}));
-			}).pipe(span("Chromium.ready")),
-			terminate: yield* Effect.cached(terminate(launched, pid, clock).pipe(Effect.uninterruptible)),
-			removeProfile
-		};
-	}).pipe(Effect.onExit((exit) => Exit.isSuccess(exit) ? Effect.void : Effect.gen(function* () {
-		if (child?.pid === void 0) {
-			yield* removeProfile.pipe(Effect.ignore);
-			return;
-		}
-		const stopped = yield* terminate(child, child.pid, clock).pipe(Effect.exit);
-		if (Exit.isSuccess(stopped)) yield* removeProfile.pipe(Effect.ignore);
-	})));
-}, span("Chromium.launch"));
-//#endregion
-//#region src/internal/chromium/Session.ts
-/** Each teardown step runs even when a preceding step fails. Only observed exit permits profile removal. */
-const makeChromiumCleanup = Effect.fnUntraced(function* (reference, local, process) {
-	let latest;
-	return {
-		close: yield* Effect.cached(Effect.uninterruptible(Effect.gen(function* () {
-			const issues = [];
-			const step = (name, action) => cleanupStep(action.pipe(span(`Chromium.cleanup.${name}`)), 3e3).pipe(Effect.tap((result) => Effect.sync(() => {
-				if (result._tag === "Failure") issues.push(ChromiumCleanupIssue.make({
-					step: name,
-					reason: result.reason
-				}));
-			})));
-			yield* step("fence", local.fence);
-			yield* step("capture", local.capture);
-			yield* step("initialization", local.initialization);
-			const disconnected = yield* step("disconnect", local.disconnect);
-			const terminated = process === void 0 ? void 0 : yield* step("terminate", process.terminate);
-			if (process !== void 0 && terminated !== void 0 && terminated._tag === "Success") yield* step("profile", process.removeProfile);
-			const result = ChromiumCleanupResult.make({
-				reference,
-				ownership: process === void 0 ? "borrowed" : "owned",
-				connection: disconnected._tag === "Success" ? disconnected.value : "failed",
-				process: terminated === void 0 ? "not-owned" : terminated._tag === "Success" ? "terminated" : "unknown",
-				issues
-			});
-			Object.freeze(result.issues);
-			latest = Object.freeze(result);
-			yield* annotate({
-				"browser.cleanup.connection": result.connection,
-				"browser.cleanup.process": result.process,
-				"browser.cleanup.issues": issues.length
-			});
-			return latest;
-		}).pipe(span("Chromium.cleanup")))),
-		result: Effect.sync(() => Option.fromNullishOr(latest))
-	};
+	return yield* make(context, {
+		id: `chromium-${launched.version()}`,
+		provider: "chromium"
+	}, options);
 });
-const acquireChromium = (endpoint, options, onCleanup) => (local) => Effect.uninterruptible(Effect.gen(function* () {
-	const id = yield* randomUuid(yield* Crypto.Crypto);
-	const process = endpoint === void 0 ? yield* launch(options) : void 0;
-	const reference = Object.freeze(ChromiumReference.make({
-		provider: "chromium",
-		id
-	}));
-	const cleanup = yield* makeChromiumCleanup(reference, local, process);
-	let closing = false;
-	const release = yield* Effect.cached(Effect.gen(function* () {
-		closing = true;
-		const result = yield* cleanup.close;
-		if (onCleanup !== void 0) yield* reported(Effect.suspend(() => onCleanup(result)));
-		return result;
-	}).pipe(span("Chromium.release"), Effect.uninterruptible));
-	yield* Effect.addFinalizer(() => release.pipe(Effect.asVoid));
-	return {
-		reference,
-		connection: (timeoutMillis) => Effect.suspend(() => {
-			if (closing) return Effect.fail(BrowserError.make({
-				operation: "connect",
-				reason: Reasons.Closed.make({}),
-				outcome: "undispatched"
-			}));
-			if (process !== void 0) return process.connection(timeoutMillis);
-			return endpoint === void 0 ? Effect.fail(BrowserError.make({
-				operation: "connect",
-				reason: Reasons.Configuration.make({}),
-				outcome: "undispatched"
-			})) : checked(ChromiumEndpoint, Redacted.value(endpoint), "connect").pipe(Effect.map(Redacted.make));
-		}),
-		release,
-		closeChecked: release.pipe(Effect.filterOrFail((result) => result.connection === "closed" && result.issues.length === 0 && (result.ownership === "borrowed" ? result.process === "not-owned" : result.process === "terminated"), () => BrowserError.make({
-			operation: "close",
-			reason: Reasons.Failed.make({}),
-			outcome: "unknown"
-		})), span("Chromium.close")),
-		cleanupResult: cleanup.result,
-		controlRetired: cleanup.result.pipe(Effect.map((result) => Option.isSome(result) && result.value.ownership === "owned" && result.value.process === "terminated"))
-	};
-}));
-const ownedChromium = (options, onCleanup) => acquireChromium(void 0, options, onCleanup);
-const borrowedChromium = (endpoint, onCleanup) => acquireChromium(endpoint, {}, onCleanup);
-//#endregion
-//#region src/Chromium.ts
-var Chromium = class Chromium extends Context.Service()("effect-browser/Chromium") {
-	/** Launch through the configured service; compose with Browser.scoped for supervised ownership. */
-	static launch(policy, request) {
-		return Effect.flatMap(Chromium, (browser) => browser.launch(policy, request));
-	}
-	/** Acquire the process lifetime before connecting, using the caller's scope. */
-	static acquire(policy, request) {
-		return Effect.flatMap(Chromium, (browser) => browser.acquire(policy, request));
-	}
-	/** Borrow a concrete loopback endpoint; cleanup never terminates its external process. */
-	static attach(endpoint, request) {
-		return Effect.flatMap(Chromium, (browser) => browser.attach(endpoint, request));
-	}
-	/** Chromium references, connection ids and handoff tokens come from the required `Crypto`. */
-	static layer(options = {}) {
-		return Layer.effect(Chromium, Effect.gen(function* () {
-			const launchInput = yield* checked(ChromiumLaunch, options.launch ?? {}, "configure");
-			const launch = Object.freeze({
-				...launchInput,
-				...launchInput.args === void 0 ? {} : { args: Object.freeze([...launchInput.args]) },
-				...launchInput.proxy === void 0 ? {} : { proxy: Object.freeze({ ...launchInput.proxy }) }
-			});
-			if (Object.prototype.hasOwnProperty.call(options, "bootstrap")) return yield* BrowserError.make({
-				operation: "configure",
-				reason: Reasons.Configuration.make({}),
-				outcome: "undispatched"
-			});
-			const runtime = yield* make({
-				implementation: "chromium-playwright-cdp",
-				...options.viewport === void 0 ? {} : { viewport: options.viewport },
-				automation: {
-					...options.timelineLimits === void 0 ? {} : { timelineLimits: options.timelineLimits },
-					...options.admissionLimits === void 0 ? {} : { admissionLimits: options.admissionLimits },
-					...options.observationLimits === void 0 ? {} : { observationLimits: options.observationLimits },
-					...options.actionTimeoutMillis === void 0 ? {} : { actionTimeoutMillis: options.actionTimeoutMillis },
-					...options.maxPages === void 0 ? {} : { maxPages: options.maxPages },
-					...options.maxHostReads === void 0 ? {} : { maxHostReads: options.maxHostReads },
-					...options.initialPage === void 0 ? {} : { initialPage: options.initialPage },
-					...options.popupPolicy === void 0 ? {} : { popupPolicy: options.popupPolicy },
-					...options.dialogPolicy === void 0 ? {} : { dialogPolicy: options.dialogPolicy },
-					...options.pageControl === void 0 ? {} : { pageControl: options.pageControl }
-				}
-			});
-			const crypto = yield* Crypto.Crypto;
-			const acquire = Effect.fnUntraced(function* (policy, request = {}, attachment) {
-				const source = attachment === void 0 ? ownedChromium(launch, options.onCleanup) : borrowedChromium(attachment.endpoint, options.onCleanup);
-				const acquired = yield* runtime.acquire(policy, (cleanup, deadline) => source(cleanup, deadline).pipe(Effect.provideService(Crypto.Crypto, crypto)), {
-					...request,
-					...attachment === void 0 ? {} : { existingTarget: attachment.targetId === void 0 ? {} : { targetId: attachment.targetId } }
-				});
-				const connected = yield* Effect.cached(acquired.connect.pipe(Effect.map(({ session }) => Object.assign(session, {
-					reference: acquired.reference,
-					closeChecked: session.closeChecked.pipe(Effect.andThen(acquired.lifetime.closeChecked)),
-					close: acquired.close,
-					cleanupResult: acquired.lifetime.cleanupResult
-				}))));
-				return {
-					reference: acquired.reference,
-					failure: acquired.failure,
-					close: acquired.close,
-					connect: acquired.connect.pipe(Effect.andThen(connected))
-				};
-			});
-			return Chromium.of({
-				acquire,
-				launch: (policy, request) => acquire(policy, request).pipe(Effect.flatMap((acquired) => acquired.connect)),
-				attach: (endpoint, request) => Effect.gen(function* () {
-					const address = yield* checked(ChromiumEndpoint, Redacted.value(endpoint), "connect");
-					return yield* (yield* acquire(request.policy, request, {
-						endpoint: Redacted.make(address),
-						...request.target === void 0 ? {} : { targetId: request.target.targetId }
-					})).connect;
-				})
-			});
-		}));
-	}
-};
+/** A `Browser` Layer that launches Chromium when built and closes it when released. */
+const layer = (options = {}) => Layer.effect(Browser, open(options));
 //#endregion
-export { Chromium, ChromiumCleanupIssue, ChromiumCleanupResult, ChromiumLaunch, ChromiumReference };
+export { layer, open, Chromium_exports as t };
 
 //# sourceMappingURL=Chromium.mjs.map