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

package/dist/Launch-C8CfaYxb.d.mts

@@ -1,132 +0,0 @@
-import { n as ContextReference, r as ExtensionReference } from "./References-URDAtapt.mjs";
-import { Schema } from "effect";
-declare namespace Launch_d_exports {
-  export { LaunchRecipe, ProviderLaunchOptions, ProxyRule, recipe };
-}
-declare const ProxyRule: Schema.Union<readonly [Schema.Struct<{
-  readonly type: Schema.Literal<"browserbase">;
-  readonly domainPattern: Schema.optionalKey<Schema.NonEmptyString>;
-  readonly geolocation: Schema.optionalKey<Schema.Struct<{
-    readonly country: Schema.String;
-    readonly state: Schema.optionalKey<Schema.String>;
-    readonly city: Schema.optionalKey<Schema.NonEmptyString>;
-  }>>;
-}>, Schema.Struct<{
-  readonly type: Schema.Literal<"external">;
-  readonly server: Schema.NonEmptyString;
-  readonly domainPattern: Schema.optionalKey<Schema.NonEmptyString>;
-  readonly username: Schema.optionalKey<Schema.Redacted<Schema.String>>;
-  readonly password: Schema.optionalKey<Schema.Redacted<Schema.String>>;
-}>, Schema.Struct<{
-  readonly type: Schema.Literal<"none">;
-  readonly domainPattern: Schema.optionalKey<Schema.NonEmptyString>;
-}>]>;
-type ProxyRule = typeof ProxyRule.Type;
-/** SDK 2.20 browser subset. Names follow Browserbase; ownership-managed fields are excluded. */
-declare const ProviderLaunchOptions: Schema.Struct<{
-  readonly region: Schema.optionalKey<Schema.Literals<readonly ["us-west-2", "us-east-1", "eu-central-1", "ap-southeast-1"]>>;
-  readonly proxies: Schema.optionalKey<Schema.Union<readonly [Schema.Boolean, Schema.$Array<Schema.Union<readonly [Schema.Struct<{
-    readonly type: Schema.Literal<"browserbase">;
-    readonly domainPattern: Schema.optionalKey<Schema.NonEmptyString>;
-    readonly geolocation: Schema.optionalKey<Schema.Struct<{
-      readonly country: Schema.String;
-      readonly state: Schema.optionalKey<Schema.String>;
-      readonly city: Schema.optionalKey<Schema.NonEmptyString>;
-    }>>;
-  }>, Schema.Struct<{
-    readonly type: Schema.Literal<"external">;
-    readonly server: Schema.NonEmptyString;
-    readonly domainPattern: Schema.optionalKey<Schema.NonEmptyString>;
-    readonly username: Schema.optionalKey<Schema.Redacted<Schema.String>>;
-    readonly password: Schema.optionalKey<Schema.Redacted<Schema.String>>;
-  }>, Schema.Struct<{
-    readonly type: Schema.Literal<"none">;
-    readonly domainPattern: Schema.optionalKey<Schema.NonEmptyString>;
-  }>]>>]>>;
-  readonly proxySettings: Schema.optionalKey<Schema.Struct<{
-    readonly caCertificates: Schema.optionalKey<Schema.$Array<Schema.NonEmptyString>>;
-  }>>;
-  readonly browserSettings: Schema.optionalKey<Schema.Struct<{
-    readonly verified: Schema.optionalKey<Schema.Boolean>;
-    readonly os: Schema.optionalKey<Schema.Literals<readonly ["windows", "mac", "linux", "mobile", "tablet"]>>;
-    readonly allowedDomains: Schema.optionalKey<Schema.$Array<Schema.NonEmptyString>>;
-    readonly blockAds: Schema.optionalKey<Schema.Boolean>;
-    readonly captchaImageSelector: Schema.optionalKey<Schema.NonEmptyString>;
-    readonly captchaInputSelector: Schema.optionalKey<Schema.NonEmptyString>;
-    readonly ignoreCertificateErrors: Schema.optionalKey<Schema.Boolean>;
-    readonly logSession: Schema.optionalKey<Schema.Boolean>;
-    readonly recordSession: Schema.optionalKey<Schema.Boolean>;
-    readonly solveCaptchas: Schema.optionalKey<Schema.Boolean>;
-  }>>;
-  readonly userMetadata: Schema.optionalKey<Schema.$Record<Schema.String, Schema.Codec<Schema.Json, Schema.Json, never, never>>>;
-}>;
-type ProviderLaunchOptions = typeof ProviderLaunchOptions.Type;
-/** Connection behavior and business budgets are not provider session lifetime. */
-declare const LaunchRecipe: Schema.Struct<{
-  readonly remoteTimeoutSeconds: Schema.Int;
-  readonly keepAlive: Schema.optionalKey<Schema.Boolean>;
-  readonly context: Schema.optionalKey<Schema.Struct<{
-    readonly reference: typeof ContextReference;
-    readonly persist: Schema.Boolean;
-  }>>;
-  /**
-   * Project-qualified selection of an already provisioned extension, never an upload. It is
-   * the only spelling: the compiler alone projects it to the provider's `extensionId`, so an
-   * unqualified identifier cannot reach the provider unchecked.
-   */
-  readonly extension: Schema.optionalKey<typeof ExtensionReference>;
-  readonly viewport: Schema.Union<readonly [Schema.Struct<{
-    readonly _tag: Schema.Literal<"ProviderManaged">;
-  }>, Schema.Struct<{
-    readonly _tag: Schema.Literal<"Fixed">;
-    readonly width: Schema.Int;
-    readonly height: Schema.Int;
-  }>]>;
-  readonly provider: Schema.Struct<{
-    readonly region: Schema.optionalKey<Schema.Literals<readonly ["us-west-2", "us-east-1", "eu-central-1", "ap-southeast-1"]>>;
-    readonly proxies: Schema.optionalKey<Schema.Union<readonly [Schema.Boolean, Schema.$Array<Schema.Union<readonly [Schema.Struct<{
-      readonly type: Schema.Literal<"browserbase">;
-      readonly domainPattern: Schema.optionalKey<Schema.NonEmptyString>;
-      readonly geolocation: Schema.optionalKey<Schema.Struct<{
-        readonly country: Schema.String;
-        readonly state: Schema.optionalKey<Schema.String>;
-        readonly city: Schema.optionalKey<Schema.NonEmptyString>;
-      }>>;
-    }>, Schema.Struct<{
-      readonly type: Schema.Literal<"external">;
-      readonly server: Schema.NonEmptyString;
-      readonly domainPattern: Schema.optionalKey<Schema.NonEmptyString>;
-      readonly username: Schema.optionalKey<Schema.Redacted<Schema.String>>;
-      readonly password: Schema.optionalKey<Schema.Redacted<Schema.String>>;
-    }>, Schema.Struct<{
-      readonly type: Schema.Literal<"none">;
-      readonly domainPattern: Schema.optionalKey<Schema.NonEmptyString>;
-    }>]>>]>>;
-    readonly proxySettings: Schema.optionalKey<Schema.Struct<{
-      readonly caCertificates: Schema.optionalKey<Schema.$Array<Schema.NonEmptyString>>;
-    }>>;
-    readonly browserSettings: Schema.optionalKey<Schema.Struct<{
-      readonly verified: Schema.optionalKey<Schema.Boolean>;
-      readonly os: Schema.optionalKey<Schema.Literals<readonly ["windows", "mac", "linux", "mobile", "tablet"]>>;
-      readonly allowedDomains: Schema.optionalKey<Schema.$Array<Schema.NonEmptyString>>;
-      readonly blockAds: Schema.optionalKey<Schema.Boolean>;
-      readonly captchaImageSelector: Schema.optionalKey<Schema.NonEmptyString>;
-      readonly captchaInputSelector: Schema.optionalKey<Schema.NonEmptyString>;
-      readonly ignoreCertificateErrors: Schema.optionalKey<Schema.Boolean>;
-      readonly logSession: Schema.optionalKey<Schema.Boolean>;
-      readonly recordSession: Schema.optionalKey<Schema.Boolean>;
-      readonly solveCaptchas: Schema.optionalKey<Schema.Boolean>;
-    }>>;
-    readonly userMetadata: Schema.optionalKey<Schema.$Record<Schema.String, Schema.Codec<Schema.Json, Schema.Json, never, never>>>;
-  }>;
-}>;
-type LaunchRecipe = typeof LaunchRecipe.Type;
-/**
- * A recipe with the smallest reasonable choices filled in: a five-minute provider lifetime,
- * a provider-managed viewport (which Verified requires) and no provider options. Privacy
- * defaults are unchanged: recording, logging and captcha solving stay off unless requested.
- */
-declare const recipe: (options?: Partial<LaunchRecipe>) => LaunchRecipe;
-//#endregion
-export { recipe as a, ProxyRule as i, Launch_d_exports as n, ProviderLaunchOptions as r, LaunchRecipe as t };
-//# sourceMappingURL=Launch-C8CfaYxb.d.mts.map

package/dist/LocalBrowser-BLancJ3R.d.mts

@@ -1,79 +0,0 @@
-import { BrowserError, InitializationError } from "./Errors.mjs";
-import { V as Viewport, i as BrowserPolicy, n as AutomationOptions } from "./BrowserData-LpcAuAub.mjs";
-import { BrowserSession, OpenOptions } from "./Browser.mjs";
-import { Context, Effect, Layer, Option, Redacted, Schema, Scope } from "effect";
-//#region src/internal/browser/LocalData.d.ts
-declare const LocalReference_base: Schema.Class<LocalReference, Schema.Struct<{
-  readonly provider: Schema.Literal<"local">;
-  readonly id: Schema.NonEmptyString;
-}>, {}>;
-/** Identifies this local ownership lifetime, not a Browserbase resource or a reusable endpoint. */
-declare class LocalReference extends LocalReference_base {}
-declare const LocalCleanupIssue_base: Schema.Class<LocalCleanupIssue, Schema.Struct<{
-  readonly step: Schema.Literals<readonly ["fence", "capture", "initialization", "disconnect", "terminate", "profile"]>;
-  readonly reason: Schema.Literals<readonly ["timeout", "failed", "interrupted"]>;
-}>, {}>;
-declare class LocalCleanupIssue extends LocalCleanupIssue_base {}
-declare const LocalCleanupResult_base: Schema.Class<LocalCleanupResult, Schema.Struct<{
-  readonly reference: typeof LocalReference;
-  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 LocalCleanupIssue>;
-}>, {}>;
-/** Connection teardown and observed process exit are separate facts; no provider status exists. */
-declare class LocalCleanupResult extends LocalCleanupResult_base {}
-declare const LocalLaunch: 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>;
-}>;
-type LocalLaunch = typeof LocalLaunch.Type;
-declare namespace LocalBrowser_d_exports {
-  export { LocalAcquisition, LocalAttachRequest, LocalBrowser, LocalBrowserOptions, LocalCleanupIssue, LocalCleanupResult, LocalLaunch, LocalReference, LocalSession };
-}
-/** Host-only process configuration. Building this layer neither loads Playwright nor starts Chromium. */
-interface LocalBrowserOptions extends AutomationOptions {
-  readonly launch?: LocalLaunch;
-  readonly viewport?: Viewport;
-  readonly onCleanup?: (result: LocalCleanupResult) => Effect.Effect<void>;
-}
-/** A local lifetime has modeled browser authority, never Browserbase resource or release authority. */
-interface LocalSession<E = never> extends BrowserSession<E> {
-  readonly reference: LocalReference;
-  readonly close: Effect.Effect<LocalCleanupResult>;
-  readonly cleanupResult: Effect.Effect<Option.Option<LocalCleanupResult>>;
-}
-interface LocalAcquisition<E = never> {
-  readonly reference: LocalReference;
-  readonly failure: Effect.Effect<never, E | InitializationError>;
-  readonly connect: Effect.Effect<LocalSession<E>, BrowserError | InitializationError | E>;
-  readonly close: Effect.Effect<LocalCleanupResult>;
-}
-interface LocalAttachRequest<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;
-  };
-}
-declare const LocalBrowser_base: Context.ServiceClass<LocalBrowser, "effect-browserbase/LocalBrowser", {
-  readonly acquire: <E = never, R = never>(policy: BrowserPolicy, request?: OpenOptions<E, R>) => Effect.Effect<LocalAcquisition<E>, BrowserError, Scope.Scope | Exclude<R, Scope.Scope>>;
-  readonly open: <E = never, R = never>(policy: BrowserPolicy, request?: OpenOptions<E, R>) => Effect.Effect<LocalSession<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: LocalAttachRequest<E, R>) => Effect.Effect<LocalSession<E>, BrowserError | InitializationError | E, Scope.Scope | Exclude<R, Scope.Scope>>;
-  readonly withBrowser: <E, R, A, E2, R2>(policy: BrowserPolicy, request: OpenOptions<E, R>, use: (session: LocalSession<E>) => Effect.Effect<A, E2, R2>) => Effect.Effect<A, BrowserError | InitializationError | E | E2, Exclude<R | R2, Scope.Scope>>;
-}>;
-declare class LocalBrowser extends LocalBrowser_base {
-  static layer(options?: LocalBrowserOptions): Layer.Layer<LocalBrowser, BrowserError>;
-}
-//#endregion
-export { LocalBrowser_d_exports as a, LocalCleanupResult as c, LocalBrowserOptions as i, LocalLaunch as l, LocalAttachRequest as n, LocalSession as o, LocalBrowser as r, LocalCleanupIssue as s, LocalAcquisition as t, LocalReference as u };
-//# sourceMappingURL=LocalBrowser-BLancJ3R.d.mts.map

package/dist/LocalBrowser-DsQLWNL1.mjs

@@ -1,439 +0,0 @@
-import { t as __exportAll } from "./rolldown-runtime-D7D4PA-g.mjs";
-import { Identifier } from "./References.mjs";
-import { BrowserError } from "./Errors.mjs";
-import { AutomationOptions, BrowserPolicy, Viewport } from "./BrowserData.mjs";
-import { a as reported } from "./Acquisition-WBafHwXH.mjs";
-import { d as empty } from "./Bootstrap-BXuzZojd.mjs";
-import { a as connectPlaywrightEndpoint, s as fromNativeAttempt } from "./BrowserBinding-DlJTGYZL.mjs";
-import { c as preparePlan, i as checked, l as compileBootstrap, o as makeSession, s as makeBindings, t as acquireSession } from "./Session-D4nT9hOO.mjs";
-import { Cause, Clock, Context, Duration, Effect, Exit, Layer, Option, Path, Redacted, Schema, Scope } from "effect";
-import { spawn } from "node:child_process";
-import { mkdtemp, readFile, rm } from "node:fs/promises";
-import { tmpdir } from "node:os";
-//#region src/internal/browser/LocalData.ts
-/** Identifies this local ownership lifetime, not a Browserbase resource or a reusable endpoint. */
-var LocalReference = class extends Schema.Class("LocalBrowserReference")({
-	provider: Schema.Literal("local"),
-	id: Identifier
-}) {};
-var LocalCleanupIssue = class extends Schema.Class("LocalBrowserCleanupIssue")({
-	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 LocalCleanupResult = class extends Schema.Class("LocalBrowserCleanupResult")({
-	reference: LocalReference,
-	ownership: Schema.Literals(["owned", "borrowed"]),
-	connection: Schema.Literals([
-		"closed",
-		"failed",
-		"not-connected",
-		"pending"
-	]),
-	process: Schema.Literals([
-		"terminated",
-		"unknown",
-		"not-owned"
-	]),
-	issues: Schema.Array(LocalCleanupIssue).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 LocalEndpoint = 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)(?:=|$)/u.test(value)));
-const LocalLaunch = 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/browser/LocalProcess.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",
-	`--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 ?? [],
-	"about:blank"
-];
-const failure = (operation, reason) => BrowserError.make({
-	operation,
-	reason,
-	outcome: operation === "close" ? "unknown" : "undispatched"
-});
-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", "failed")
-	});
-	const signal = (value) => Effect.try({
-		try: () => signalGroup(pid, value),
-		catch: () => failure("close", "failed")
-	});
-	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", "timeout");
-});
-/** 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", "unsupported");
-	const path = yield* Path.Path.pipe(Effect.provide(Path.layer));
-	const clock = yield* Clock.Clock;
-	const executable = options.executablePath ?? (yield* Effect.tryPromise({
-		try: async () => (await import("playwright-core")).chromium.executablePath(),
-		catch: () => failure("launch", "failed")
-	}));
-	const directory = yield* Effect.tryPromise({
-		try: () => mkdtemp(path.join(tmpdir(), "effect-local-browser-")),
-		catch: () => failure("launch", "failed")
-	});
-	const removeProfile = Effect.tryPromise({
-		try: () => rm(directory, {
-			recursive: true,
-			force: true,
-			maxRetries: 5,
-			retryDelay: 50
-		}),
-		catch: () => failure("close", "failed")
-	});
-	let child;
-	return yield* Effect.gen(function* () {
-		const launched = yield* Effect.tryPromise({
-			try: () => {
-				const spawned = spawn(executable, launchArguments(options, directory), {
-					cwd: directory,
-					stdio: [
-						"ignore",
-						"ignore",
-						"ignore"
-					],
-					detached: true
-				});
-				child = spawned;
-				return new Promise((resolve, reject) => {
-					spawned.once("spawn", () => resolve(spawned));
-					spawned.once("error", reject);
-				});
-			},
-			catch: () => failure("launch", "failed")
-		});
-		const pid = launched.pid;
-		if (pid === void 0) return yield* failure("launch", "failed");
-		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", "closed");
-					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", "transport")
-					});
-					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(LocalEndpoint)(endpoint)) return yield* failure("connect", "malformed");
-						return Redacted.make(endpoint);
-					}
-					yield* clock.sleep(Duration.millis(20));
-				}
-				return yield* failure("connect", "timeout");
-			}),
-			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);
-	})));
-});
-//#endregion
-//#region src/internal/browser/LocalSession.ts
-/** Same maintained driver, with a separately validated host endpoint and no provider identity. */
-const localEngine = fromNativeAttempt(async (request, signal) => {
-	if (!Schema.is(LocalEndpoint)(request.connection)) throw BrowserError.make({
-		operation: "connect",
-		reason: "configuration",
-		outcome: "undispatched"
-	});
-	return connectPlaywrightEndpoint(request.connection, signal, request.options, request.events);
-});
-/** Each teardown step runs even when a preceding step fails. Only observed exit permits profile removal. */
-const makeLocalCleanup = Effect.fnUntraced(function* (reference, local, process) {
-	let latest;
-	return {
-		close: yield* Effect.cached(Effect.uninterruptible(Effect.gen(function* () {
-			const issues = [];
-			const step = (name, action) => action.pipe(Effect.interruptible, Effect.timeoutOrElse({
-				duration: 3e3,
-				orElse: () => Effect.fail(LocalCleanupIssue.make({
-					step: name,
-					reason: "timeout"
-				}))
-			}), Effect.exit, Effect.tap((exit) => Effect.sync(() => {
-				if (Exit.isSuccess(exit)) return;
-				const error = Cause.findErrorOption(exit.cause);
-				issues.push(LocalCleanupIssue.make({
-					step: name,
-					reason: Option.isSome(error) && error.value instanceof LocalCleanupIssue ? error.value.reason : Cause.hasInterrupts(exit.cause) ? "interrupted" : "failed"
-				}));
-			})));
-			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 && Exit.isSuccess(terminated)) yield* step("profile", process.removeProfile);
-			const result = LocalCleanupResult.make({
-				reference,
-				ownership: process === void 0 ? "borrowed" : "owned",
-				connection: Exit.isSuccess(disconnected) ? disconnected.value : "failed",
-				process: terminated === void 0 ? "not-owned" : Exit.isSuccess(terminated) ? "terminated" : "unknown",
-				issues
-			});
-			Object.freeze(result.issues);
-			latest = Object.freeze(result);
-			return latest;
-		}))),
-		result: Effect.sync(() => Option.fromNullishOr(latest))
-	};
-});
-const acquireLocal = (endpoint, options, onCleanup) => (local) => Effect.uninterruptible(Effect.gen(function* () {
-	const process = endpoint === void 0 ? yield* launch(options) : void 0;
-	const reference = Object.freeze(LocalReference.make({
-		provider: "local",
-		id: globalThis.crypto.randomUUID()
-	}));
-	const cleanup = yield* makeLocalCleanup(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(onCleanup(result));
-		return result;
-	}).pipe(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: "closed",
-				outcome: "undispatched"
-			}));
-			if (process !== void 0) return process.connection(timeoutMillis);
-			return endpoint === void 0 ? Effect.fail(BrowserError.make({
-				operation: "connect",
-				reason: "configuration",
-				outcome: "undispatched"
-			})) : checked(LocalEndpoint, Redacted.value(endpoint), "connect").pipe(Effect.map(Redacted.make));
-		}),
-		release,
-		cleanupResult: cleanup.result
-	};
-}));
-const ownedLocal = (options, onCleanup) => acquireLocal(void 0, options, onCleanup);
-const borrowedLocal = (endpoint, onCleanup) => acquireLocal(endpoint, {}, onCleanup);
-//#endregion
-//#region src/LocalBrowser.ts
-var LocalBrowser_exports = /* @__PURE__ */ __exportAll({
-	LocalBrowser: () => LocalBrowser,
-	LocalCleanupIssue: () => LocalCleanupIssue,
-	LocalCleanupResult: () => LocalCleanupResult,
-	LocalLaunch: () => LocalLaunch,
-	LocalReference: () => LocalReference
-});
-var LocalBrowser = class LocalBrowser extends Context.Service()("effect-browserbase/LocalBrowser") {
-	static layer(options = {}) {
-		return Layer.effect(LocalBrowser, Effect.gen(function* () {
-			const automation = yield* checked(AutomationOptions, {
-				...options.actionTimeoutMillis === void 0 ? {} : { actionTimeoutMillis: options.actionTimeoutMillis },
-				...options.maxPages === void 0 ? {} : { maxPages: options.maxPages },
-				...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 }
-			}, "configure");
-			const launchInput = yield* checked(LocalLaunch, 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 }) }
-			});
-			const viewport = yield* checked(Viewport, options.viewport ?? {
-				width: 1280,
-				height: 720
-			}, "configure");
-			const pageControl = automation.pageControl ?? false;
-			const popupPolicy = automation.popupPolicy ?? "retain";
-			const dialogPolicy = automation.dialogPolicy ?? "dismiss";
-			if (pageControl && (popupPolicy === "pause" || dialogPolicy === "pause")) return yield* BrowserError.make({
-				operation: "configure",
-				reason: "unsupported",
-				outcome: "undispatched"
-			});
-			if (Object.prototype.hasOwnProperty.call(options, "bootstrap")) return yield* BrowserError.make({
-				operation: "configure",
-				reason: "configuration",
-				outcome: "undispatched"
-			});
-			const driver = {
-				viewport,
-				pageControl,
-				popupPolicy,
-				dialogPolicy,
-				maxPages: automation.maxPages ?? 10
-			};
-			const acquire = Effect.fnUntraced(function* (policy, request = {}, attachment) {
-				const fixed = yield* checked(BrowserPolicy, policy, "configure");
-				const plan = yield* preparePlan(request.bootstrap ?? empty);
-				const scope = yield* Scope.fork(yield* Scope.Scope, "sequential");
-				const bindings = yield* makeBindings(plan).pipe(Scope.provide(scope));
-				const bootstrap = compileBootstrap(plan);
-				const selection = attachment !== void 0 ? {
-					newPage: false,
-					preserveViewport: true,
-					...attachment.targetId === void 0 ? {} : { initialTargetId: attachment.targetId }
-				} : automation.initialPage === void 0 ? {} : "targetId" in automation.initialPage ? { initialTargetId: automation.initialPage.targetId } : { newPage: true };
-				const acquired = yield* acquireSession({
-					maxActions: fixed.maxActions,
-					maxElapsedMillis: fixed.maxElapsedMillis,
-					actionTimeoutMillis: automation.actionTimeoutMillis ?? 1e4
-				}, {
-					remote: attachment === void 0 ? ownedLocal(launch, options.onCleanup) : borrowedLocal(attachment.endpoint, options.onCleanup),
-					engine: localEngine,
-					keepAlive: false,
-					driver: {
-						...driver,
-						...selection,
-						...bootstrap === void 0 ? {} : { bootstrap }
-					},
-					connectBindings: bindings.connect,
-					maxReturnedBytes: fixed.maxReturnedBytes
-				}).pipe(Scope.provide(scope));
-				const connected = yield* Effect.cached(acquired.connect.pipe(Effect.map((controls) => Object.assign(makeSession(controls, bindings), {
-					reference: controls.reference,
-					close: controls.close,
-					cleanupResult: controls.cleanupResult
-				}))));
-				return {
-					reference: acquired.reference,
-					failure: bindings.failure,
-					close: acquired.close,
-					connect: Effect.raceFirst(bindings.failure, acquired.connect.pipe(Effect.andThen(connected))).pipe(Effect.onError(() => acquired.close.pipe(Effect.asVoid)))
-				};
-			});
-			return LocalBrowser.of({
-				acquire,
-				open: (policy, request) => acquire(policy, request).pipe(Effect.flatMap((acquired) => acquired.connect)),
-				attach: (endpoint, request) => Effect.gen(function* () {
-					const address = yield* checked(LocalEndpoint, Redacted.value(endpoint), "connect");
-					const targetId = request.target === void 0 ? void 0 : yield* checked(Identifier, request.target.targetId, "configure");
-					return yield* (yield* acquire(request.policy, request, {
-						endpoint: Redacted.make(address),
-						...targetId === void 0 ? {} : { targetId }
-					})).connect;
-				}),
-				withBrowser: (policy, request, use) => Effect.scoped(Effect.gen(function* () {
-					const session = yield* (yield* acquire(policy, request)).connect;
-					const result = yield* Effect.raceFirst(session.failure, Effect.suspend(() => use(session)));
-					const cleanup = yield* session.close;
-					if (cleanup.connection !== "closed" || cleanup.process !== "terminated" || cleanup.issues.length > 0) return yield* BrowserError.make({
-						operation: "close",
-						reason: "failed",
-						outcome: "unknown"
-					});
-					return result;
-				}))
-			});
-		}));
-	}
-};
-//#endregion
-export { LocalLaunch as a, LocalCleanupResult as i, LocalBrowser_exports as n, LocalReference as o, LocalCleanupIssue as r, LocalBrowser as t };
-
-//# sourceMappingURL=LocalBrowser-DsQLWNL1.mjs.map