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

package/dist/Browser.d.mts

@@ -1,17 +1,16 @@
-import { o as SessionReference, t as AllocationAttempt } from "./References-URDAtapt.mjs";
-import { AllocationError, BrowserError, ContextError, InitializationError, SessionError } from "./Errors.mjs";
-import { t as BrowserbaseClient } from "./Client-Ca0zSg1n.mjs";
-import { s as LiveView, t as BrowserbaseSessions } from "./Sessions-B8E4kMxo.mjs";
-import { r as DownloadObservation } from "./Transfers-Czv5IZzJ.mjs";
-import { n as CleanupResult } from "./Cleanup-G2YpTCuU.mjs";
-import { n as ContextWriterPermit } from "./WriterFacts-osvYAsIx.mjs";
-import { f as Plan, g as ReadinessOutcome, s as Bootstrap_d_exports, t as BindingDiagnostics } from "./Bootstrap-m7lHgj0D.mjs";
-import { A as ReadTextRequest, B as TypeRequest, E as PageInfo, G as WheelRequest, I as StartNavigationRequest, L as Target, M as ScreenshotResult, N as ScrollRequest, O as PointerMoveRequest, P as SelectFilesRequest, S as ObservationOptions, V as Viewport, _ as KeyStroke, a as Checkpoint, b as NavigationResult, c as ControlFacts, d as FrameInfo, f as HoverRequest, h as InputReceipt, i as BrowserPolicy, j as ScreenshotRequest, k as PressRequest, n as AutomationOptions, o as CheckpointOptions, s as ClickRequest, t as ActionResult, u as FillRequest, w as ObservedElement, x as Observation, y as NavigateRequest, z as TextResult } from "./BrowserData-LpcAuAub.mjs";
-import { t as LaunchRecipe } from "./Launch-C8CfaYxb.mjs";
-import { Context, Effect, Layer, Option, Redacted, Scope } from "effect";
-declare namespace Browser_d_exports {
-  export { AttachRequest, BoundTarget, BrowserAcquisition, BrowserOptions, BrowserSession, BrowserbaseBrowser, BrowserbaseSession, ElementAdmission, Handoff, LiveView, NavigationOperation, OpenOptions };
-}
+import { a as SessionReference, t as AllocationAttempt } from "./References-DOH3Wu44.mjs";
+import { AllocationError, ContextError, SessionError } from "./Errors.mjs";
+import { t as BrowserbaseClient } from "./Client-B_f6bBLT.mjs";
+import { o as LiveView, t as BrowserbaseSessions } from "./Sessions-BpZgjteE.mjs";
+import { f as SelectFilesRequest, i as FileSelection, r as DownloadObservation } from "./Transfers-GVqzrDWl.mjs";
+import { n as CleanupResult } from "./Cleanup-DMTDBir8.mjs";
+import { n as ContextWriterPermit } from "./WriterFacts-BBJRDZYY.mjs";
+import { LaunchRecipe } from "./Launch.mjs";
+import { Context, Crypto, Effect, Layer, Option, Redacted, Scope } from "effect";
+import { ActionResult, AutomationOptions, BrowserPolicy, ClickRequest, Observation } from "effect-browser/browser-data";
+import { BrowserError, InitializationError } from "effect-browser/errors";
+import { BrowserSession, OpenOptions } from "effect-browser/browser";
+//#region src/Browser.d.ts
 /** Host configuration. Credentials live in the Client; a model never selects these values. */
 export interface BrowserOptions extends AutomationOptions {
   readonly launch: LaunchRecipe;
@@ -24,124 +23,10 @@ export interface Handoff {
   readonly token: Redacted.Redacted<string>;
   readonly view: LiveView;
 }
-/**
- * A host's decision about one control, made on facts read from the exact node immediately
- * before input. Returning anything but `true`, or throwing, sends nothing and fails `denied`.
- * It is a plain synchronous function on purpose: it runs while the owner's permit is held, where
- * waiting on a model or a network call would stall every other operation. It is not an atomic
- * check-and-input transaction, because page script can still run before the native input lands.
- */
-export interface ElementAdmission {
-  readonly admit: (facts: ControlFacts) => boolean;
-}
-/**
- * A navigation the browser is still performing. The owner's permit was released when it was
- * dispatched, so while it loads a host may read, `checkpoint`, hold and resume this page, and
- * use any other page. Anything that would change this page fails `busy` until it settles.
- *
- * Leaving its scope unsettled fences the session, exactly as an interrupted mutation does,
- * because nothing then knows what the browser did. It is never replayed.
- */
-export interface NavigationOperation {
-  /** What was navigated, read before dispatch. */
-  readonly target: Target;
-  /**
-   * The document reached DOMContentLoaded. It belongs to this one navigation: a successor that
-   * reaches the same URL fails it instead. Interrupting a waiter stops nothing in the browser.
-   */
-  readonly completed: Effect.Effect<NavigationResult, BrowserError>;
-  /**
-   * Asks the browser to stop loading and waits for this navigation to settle, after which
-   * `completed` fails `interrupted`. Success is a known outcome and the session stays usable:
-   * the page holds whatever had loaded. It does not undo anything the page already did.
-   */
-  readonly stop: Effect.Effect<void, BrowserError>;
-}
-/** One selected page and frame at one connection generation, never the current DOM. */
-export interface BoundTarget {
-  readonly navigate: (request: NavigateRequest) => Effect.Effect<NavigationResult, BrowserError>;
-  /** `navigate`, left in flight: the same single dispatch, completed by the caller. */
-  readonly startNavigation: (request: StartNavigationRequest) => Effect.Effect<NavigationOperation, BrowserError, Scope.Scope>;
-  readonly readText: (request: ReadTextRequest) => Effect.Effect<TextResult, BrowserError>;
-  readonly click: (request: ClickRequest) => Effect.Effect<ActionResult, BrowserError>;
-  readonly fill: (request: FillRequest) => Effect.Effect<ActionResult, BrowserError>;
-  /** Script in the page: instantaneous, and it raises no wheel event. */
-  readonly scroll: (request: ScrollRequest) => Effect.Effect<ActionResult, BrowserError>;
-  /** One real pointer move, in main-frame viewport pixels. */
-  readonly pointerMove: (request: PointerMoveRequest) => Effect.Effect<InputReceipt, BrowserError>;
-  /** Places the pointer on one exact element where it is, or fails `not-visible` unsent. */
-  readonly hover: (request: HoverRequest) => Effect.Effect<InputReceipt, BrowserError>;
-  /** One real wheel event; the browser decides what under the pointer scrolls. */
-  readonly wheel: (request: WheelRequest) => Effect.Effect<InputReceipt, BrowserError>;
-  /** One real key stroke to whatever has focus, or fails `not-focused` unsent if `into` lacks it. */
-  readonly press: (request: PressRequest) => Effect.Effect<InputReceipt, BrowserError>;
-  /** Text as the real key strokes that produce it, under the same focus rule as `press`. */
-  readonly type: (request: TypeRequest) => Effect.Effect<InputReceipt, BrowserError>;
-  readonly screenshot: (request: ScreenshotRequest) => Effect.Effect<ScreenshotResult, BrowserError>;
-}
-/**
- * Host control over one owned browser. This is not a serializable model value: copying a
- * session object cannot copy its capture, page-control or connection authority.
- */
-export interface BrowserSession<E = never> {
-  /** First fail-session callback cause, preserving the consumer's error type on the host. */
-  readonly failure: Effect.Effect<never, E | InitializationError>;
-  /** Bounded host-only evidence; consumer causes are never projected into a page reply. */
-  readonly bindingDiagnostics: Effect.Effect<BindingDiagnostics<E>>;
-  readonly bind: () => BoundTarget;
-  /** Re-reads the live selection first, so a stale generation fails before any dispatch. */
-  readonly currentTarget: Effect.Effect<BoundTarget, BrowserError>;
-  readonly target: Effect.Effect<Target, BrowserError>;
-  /**
-   * The one observation whose nodes later actions may name. `scope: "viewport"` keeps only text
-   * and controls that are on screen and reachable; the default reads the whole document. It is
-   * safe to show a model: it carries no destination, form or field value.
-   */
-  readonly observe: (options?: ObservationOptions) => Effect.Effect<Observation, BrowserError>;
-  /**
-   * Passive evidence for a recorder, with a picture when asked. It issues no references and
-   * leaves the observation above exactly as it was. Host-only: it carries control facts.
-   */
-  readonly checkpoint: (options?: CheckpointOptions) => Effect.Effect<Checkpoint, BrowserError>;
-  /** Host-only facts about one observed control, read from that exact node just now. */
-  readonly controlFacts: (reference: ObservedElement) => Effect.Effect<ControlFacts, BrowserError>;
-  /**
-   * After a page hold, nothing observed on that page may be acted on unchecked. This checks one
-   * reference: still attached, and still the control that was inspected. It never searches by
-   * selector or label for a substitute, and it sends nothing.
-   */
-  readonly revalidateElement: (reference: ObservedElement) => Effect.Effect<ObservedElement, BrowserError>;
-  readonly clickElement: (reference: ObservedElement, admission?: ElementAdmission) => Effect.Effect<ActionResult, BrowserError>;
-  readonly fillElement: (reference: ObservedElement, value: string, admission?: ElementAdmission) => Effect.Effect<ActionResult, BrowserError>;
-  readonly hoverElement: (reference: ObservedElement, admission?: ElementAdmission) => Effect.Effect<InputReceipt, BrowserError>;
-  /** A key stroke sent only if the exact node an observation named already has focus. */
-  readonly pressElement: (reference: ObservedElement, stroke: KeyStroke, admission?: ElementAdmission) => Effect.Effect<InputReceipt, BrowserError>;
-  /** Real typing with `fillElement`'s exactness: that node must already have focus. */
-  readonly typeElement: (reference: ObservedElement, text: string, admission?: ElementAdmission) => Effect.Effect<InputReceipt, BrowserError>;
-  readonly pages: Effect.Effect<ReadonlyArray<PageInfo>, BrowserError>;
-  readonly frames: Effect.Effect<ReadonlyArray<FrameInfo>, BrowserError>;
-  readonly selectPage: (pageId: string) => Effect.Effect<BoundTarget, BrowserError>;
-  readonly selectFrame: (frameId: string) => Effect.Effect<BoundTarget, BrowserError>;
-  /** Create a tab without selecting it. */
-  readonly createPage: Effect.Effect<string, BrowserError>;
-  readonly closePage: (pageId: string) => Effect.Effect<void, BrowserError>;
-  readonly resizeViewport: (viewport: Viewport) => Effect.Effect<void, BrowserError>;
-  readonly waitFor: (request: {
-    readonly selector: string;
-    readonly state: "visible" | "hidden" | "attached" | "detached";
-  }) => Effect.Effect<void, BrowserError>;
-  /** Navigation observation is registered before the single click dispatch. */
-  readonly clickAndWait: (request: ClickRequest) => Effect.Effect<ActionResult, BrowserError>;
-  /**
-   * Readiness of the current document only. Dependent operations wait for it themselves;
-   * this reports it without charging an action, so a caller can decide what to do about a
-   * document that predates the registrations.
-   */
-  readonly ready: Effect.Effect<ReadinessOutcome, InitializationError>;
-}
 /** Browserbase identity, remote artifacts and provider cleanup remain hosted capabilities. */
 export interface BrowserbaseSession<E = never> extends BrowserSession<E> {
   readonly reference: SessionReference;
+  readonly closeChecked: Effect.Effect<CleanupResult, BrowserError>;
   readonly clickForDownload: (request: ClickRequest) => Effect.Effect<DownloadObservation, BrowserError>;
   /** Attaches to an existing file input; an uploaded branch needs a receipt for this session. */
   readonly selectFiles: (request: SelectFilesRequest) => Effect.Effect<ActionResult, BrowserError>;
@@ -155,13 +40,9 @@ export interface BrowserbaseSession<E = never> extends BrowserSession<E> {
     readonly targetId: string;
   }, BrowserError>;
   readonly reconnect: (operatorReleasedControl: boolean) => Effect.Effect<Observation, BrowserError | InitializationError>;
-  readonly close: Effect.Effect<CleanupResult, BrowserError>;
+  readonly close: Effect.Effect<CleanupResult>;
   readonly cleanupResult: Effect.Effect<Option.Option<CleanupResult>>;
 }
-/** Dependencies are captured at acquisition, not erased into an environment-free service Layer. */
-export interface OpenOptions<E = never, R = never> {
-  readonly bootstrap?: Plan<E, R>;
-}
 export interface AttachRequest<E = never, R = never> extends OpenOptions<E, R> {
   readonly policy: BrowserPolicy;
   /** The exact page to resume; without it the session must have exactly one page. */
@@ -176,23 +57,25 @@ export interface BrowserAcquisition<E = never> {
   readonly attempt: AllocationAttempt;
   readonly failure: Effect.Effect<never, E | InitializationError>;
   readonly connect: Effect.Effect<BrowserbaseSession<E>, BrowserError | E | InitializationError>;
-  readonly close: Effect.Effect<CleanupResult, BrowserError>;
+  readonly close: Effect.Effect<CleanupResult>;
 }
 declare const BrowserbaseBrowser_base: Context.ServiceClass<BrowserbaseBrowser, "effect-browserbase/Browser", {
   readonly acquire: <E = never, R = never>(policy: BrowserPolicy, request?: OpenOptions<E, R>) => Effect.Effect<BrowserAcquisition<E>, AllocationError | BrowserError | ContextError, Scope.Scope | Exclude<R, Scope.Scope>>;
   /** Borrowed control of a session this process did not allocate and will not release. */
   readonly attach: <E = never, R = never>(reference: SessionReference, request: AttachRequest<E, R>) => Effect.Effect<BrowserbaseSession<E>, BrowserError | SessionError | E | InitializationError, Scope.Scope | Exclude<R, Scope.Scope>>;
   readonly open: <E = never, R = never>(policy: BrowserPolicy, request?: OpenOptions<E, R>) => Effect.Effect<BrowserbaseSession<E>, AllocationError | BrowserError | ContextError | E | InitializationError, Scope.Scope | Exclude<R, Scope.Scope>>;
-  /** Race the consumer with typed callback failure and confirm cleanup before normal success. */
-  readonly withBrowser: <E, R, A, E2, R2>(policy: BrowserPolicy, request: OpenOptions<E, R>, use: (session: BrowserbaseSession<E>) => Effect.Effect<A, E2, R2>) => Effect.Effect<A, AllocationError | BrowserError | ContextError | InitializationError | E | E2, Exclude<R | R2, Scope.Scope>>;
 }>;
-/**
- * Credentials, budgets and connection lifetime are fixed when this Layer is built. Building it
- * allocates nothing and loads no native peer; every acquisition is scoped by its caller.
- */
 export declare class BrowserbaseBrowser extends BrowserbaseBrowser_base {
-  static layer(options: BrowserOptions): Layer.Layer<BrowserbaseBrowser, BrowserError, BrowserbaseClient | BrowserbaseSessions>;
+  /** Open through the configured account and browser service, in the caller's scope. */
+  static open<E = never, R = never>(policy: BrowserPolicy, request?: OpenOptions<E, R>): Effect.Effect<BrowserbaseSession<E>, E | AllocationError | BrowserError | ContextError | InitializationError, BrowserbaseBrowser | Scope.Scope | Exclude<R, Scope.Scope>>;
+  /** Allocate the provider lifetime before connecting, preserving its attempt and cleanup. */
+  static acquire<E = never, R = never>(policy: BrowserPolicy, request?: OpenOptions<E, R>): Effect.Effect<BrowserAcquisition<E>, AllocationError | BrowserError | ContextError, BrowserbaseBrowser | Scope.Scope | Exclude<R, Scope.Scope>>;
+  /** Borrow a provider session without acquiring release authority over it. */
+  static attach<E = never, R = never>(reference: SessionReference, request: AttachRequest<E, R>): Effect.Effect<BrowserbaseSession<E>, E | BrowserError | InitializationError | SessionError, BrowserbaseBrowser | Scope.Scope | Exclude<R, Scope.Scope>>;
+  /** Allocation attempts, connection ids and handoff tokens come from the required `Crypto`. */
+  static layer(options: BrowserOptions): Layer.Layer<BrowserbaseBrowser, BrowserError, BrowserbaseClient | BrowserbaseSessions | Crypto.Crypto>;
 }
 //#endregion
-export { type LiveView, Browser_d_exports as t };
+export type { FileSelection, LiveView, SelectFilesRequest };
+export {};
 //# sourceMappingURL=Browser.d.mts.map

package/dist/Browser.mjs

@@ -1,223 +1,3 @@
-import { t as __exportAll } from "./rolldown-runtime-D7D4PA-g.mjs";
-import { Identifier } from "./References.mjs";
-import { BrowserError } from "./Errors.mjs";
-import { DownloadObservation } from "./Transfers.mjs";
-import { t as BrowserbaseClient } from "./Client-D1_xYM9o.mjs";
-import { ActionResult, AutomationOptions, BrowserPolicy, ClickRequest, InlineFiles, Selector, Viewport } from "./BrowserData.mjs";
-import { t as BrowserbaseSessions } from "./Sessions-CtbseWEh.mjs";
-import { t as issuedUpload } from "./Issued-DejqoMYL.mjs";
-import { d as empty } from "./Bootstrap-BXuzZojd.mjs";
-import { t as BrowserbaseBrowserBinding } from "./BrowserBinding-DlJTGYZL.mjs";
-import { a as decoded, c as preparePlan, i as checked, l as compileBootstrap, n as borrowedRemote, o as makeSession$1, r as ownedRemote, s as makeBindings, t as acquireSession } from "./Session-D4nT9hOO.mjs";
-import { Context, Effect, Layer, Scope } from "effect";
-//#region src/Browser.ts
-var Browser_exports = /* @__PURE__ */ __exportAll({ BrowserbaseBrowser: () => BrowserbaseBrowser });
-/**
-* Uploaded selection is admitted by the identity of a receipt this package issued for this
-* exact session, never by a path read off the caller's value. A fabricated receipt has no
-* issuance record, so an arbitrary server pathname can never become an attached file.
-*/
-const selection = (request, reference, operation) => Effect.suspend(() => {
-	const invalid = BrowserError.make({
-		operation,
-		reason: "configuration",
-		outcome: "undispatched"
-	});
-	if (request.selection._tag === "Inline") return checked(InlineFiles, request.selection.files, operation).pipe(Effect.map((files) => files.map((file) => ({
-		_tag: "Inline",
-		name: file.name,
-		mediaType: file.mediaType,
-		bytes: new Uint8Array(file.bytes)
-	}))));
-	const uploads = request.selection.uploads;
-	if (!Array.isArray(uploads) || uploads.length < 1 || uploads.length > 8) return Effect.fail(invalid);
-	const files = [];
-	for (const receipt of uploads) {
-		const issued = issuedUpload(receipt);
-		if (issued === void 0) return Effect.fail(BrowserError.make({
-			operation,
-			reason: "authorization",
-			outcome: "undispatched"
-		}));
-		if (issued.reference.projectId !== reference.projectId || issued.reference.sessionId !== reference.sessionId) return Effect.fail(BrowserError.make({
-			operation,
-			reason: "authorization",
-			outcome: "undispatched"
-		}));
-		files.push({
-			_tag: "Remote",
-			path: issued.remotePath
-		});
-	}
-	return Effect.succeed(files);
-});
-const makeSession = (controls, bindings) => {
-	const session = makeSession$1(controls, bindings);
-	const navigate = (url) => decoded(ActionResult, "action-result")({ url });
-	return Object.assign(session, {
-		reference: controls.reference,
-		clickForDownload: (request) => checked(ClickRequest, request, "download-action").pipe(Effect.flatMap((value) => controls.clickForDownload(value.selector)), Effect.flatMap((raw) => decoded(DownloadObservation, "download-action")({
-			...raw,
-			reference: controls.reference
-		}))),
-		selectFiles: (request) => checked(Selector, request.selector, "select-files").pipe(Effect.flatMap((selector) => selection(request, controls.reference, "select-files").pipe(Effect.flatMap((files) => controls.selectFiles(selector, files)))), Effect.flatMap(navigate)),
-		clickForFileSelection: (request) => checked(Selector, request.selector, "file-chooser").pipe(Effect.flatMap((selector) => selection(request, controls.reference, "file-chooser").pipe(Effect.flatMap((files) => controls.clickForFileSelection(selector, files)))), Effect.flatMap(navigate)),
-		liveView: (ttl = 60) => controls.liveView(ttl),
-		beginHandoff: (ttl = 60) => controls.beginHandoff(ttl),
-		resume: (token, released) => controls.resume(token, released),
-		detach: controls.detach,
-		reconnect: (released) => controls.reconnect(released),
-		close: controls.close,
-		cleanupResult: controls.cleanupResult
-	});
-};
-/**
-* Credentials, budgets and connection lifetime are fixed when this Layer is built. Building it
-* allocates nothing and loads no native peer; every acquisition is scoped by its caller.
-*/
-var BrowserbaseBrowser = class BrowserbaseBrowser extends Context.Service()("effect-browserbase/Browser") {
-	static layer(options) {
-		return Layer.effect(BrowserbaseBrowser, Effect.gen(function* () {
-			const client = yield* BrowserbaseClient;
-			const sessions = yield* BrowserbaseSessions;
-			const binding = yield* BrowserbaseBrowserBinding;
-			const automation = yield* checked(AutomationOptions, projected(options), "configure");
-			const viewport = yield* checked(Viewport, options.launch.viewport._tag === "Fixed" ? {
-				width: options.launch.viewport.width,
-				height: options.launch.viewport.height
-			} : {
-				width: 1280,
-				height: 720
-			}, "configure");
-			const actionTimeoutMillis = automation.actionTimeoutMillis ?? 1e4;
-			const maxPages = automation.maxPages ?? 10;
-			const pageControl = automation.pageControl ?? false;
-			const popupPolicy = automation.popupPolicy ?? "retain";
-			const dialogPolicy = automation.dialogPolicy ?? "dismiss";
-			if (pageControl && (options.launch.keepAlive === true || popupPolicy === "pause" || dialogPolicy === "pause")) return yield* BrowserError.make({
-				operation: "configure",
-				reason: "unsupported",
-				outcome: "undispatched"
-			});
-			if (options.launch.context?.persist === true && options.contextWriter === void 0) return yield* BrowserError.make({
-				operation: "configure",
-				reason: "context-lease"
-			});
-			if (Object.prototype.hasOwnProperty.call(options, "bootstrap")) return yield* BrowserError.make({
-				operation: "configure",
-				reason: "configuration",
-				outcome: "undispatched"
-			});
-			const driver = {
-				pageControl,
-				viewport,
-				maxPages,
-				popupPolicy,
-				dialogPolicy,
-				preserveViewport: options.launch.viewport._tag !== "Fixed",
-				...automation.initialPage === void 0 ? {} : "targetId" in automation.initialPage ? { initialTargetId: automation.initialPage.targetId } : { newPage: true }
-			};
-			const acquire = Effect.fnUntraced(function* (policy, request = {}) {
-				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 acquired = yield* acquireSession({
-					maxActions: fixed.maxActions,
-					maxElapsedMillis: fixed.maxElapsedMillis,
-					actionTimeoutMillis
-				}, {
-					remote: ownedRemote({
-						launch: options.launch,
-						...options.contextWriter === void 0 ? {} : { contextWriter: options.contextWriter },
-						...options.onCleanup === void 0 ? {} : { onCleanup: options.onCleanup },
-						...options.onAllocationUncertain === void 0 ? {} : { onAllocationUncertain: options.onAllocationUncertain }
-					}),
-					keepAlive: options.launch.keepAlive === true,
-					driver: {
-						...driver,
-						...bootstrap === void 0 ? {} : { bootstrap }
-					},
-					connectBindings: bindings.connect,
-					maxReturnedBytes: fixed.maxReturnedBytes
-				}).pipe(Effect.provideService(BrowserbaseClient, client), Effect.provideService(BrowserbaseSessions, sessions), Effect.provideService(BrowserbaseBrowserBinding, binding), Scope.provide(scope));
-				const connected = yield* Effect.cached(acquired.connect.pipe(Effect.map((controls) => makeSession(controls, bindings))));
-				return {
-					reference: acquired.reference,
-					attempt: acquired.lease.attempt,
-					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)))
-				};
-			});
-			/**
-			* Borrowing a session another process allocated. The launch recipe is not replayed and
-			* no allocation is attempted: the requested target is resolved explicitly, credentials
-			* are fetched fresh because expiry races the caller's own status read, and this scope
-			* disconnects locally without ever requesting release. Detaching and reattaching inside
-			* a borrowed scope is deliberately absent; attaching again is the cross-process path,
-			* and it revalidates the session instead of assuming it is still there.
-			*/
-			const attach = Effect.fnUntraced(function* (reference, request) {
-				const fixed = yield* checked(BrowserPolicy, request.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 targetId = request.target === void 0 ? void 0 : yield* checked(Identifier, request.target.targetId, "configure");
-				const acquired = yield* acquireSession({
-					maxActions: fixed.maxActions,
-					maxElapsedMillis: fixed.maxElapsedMillis,
-					actionTimeoutMillis
-				}, {
-					remote: borrowedRemote({
-						reference,
-						...request.pendingWaitMillis === void 0 ? {} : { pendingWaitMillis: request.pendingWaitMillis },
-						...options.onCleanup === void 0 ? {} : { onCleanup: options.onCleanup }
-					}),
-					keepAlive: false,
-					driver: {
-						...driver,
-						...bootstrap === void 0 ? {} : { bootstrap },
-						newPage: false,
-						preserveViewport: true,
-						...targetId === void 0 ? {} : { initialTargetId: targetId }
-					},
-					maxReturnedBytes: fixed.maxReturnedBytes,
-					connectBindings: bindings.connect
-				}).pipe(Effect.provideService(BrowserbaseClient, client), Effect.provideService(BrowserbaseSessions, sessions), Effect.provideService(BrowserbaseBrowserBinding, binding), Scope.provide(scope));
-				return yield* Effect.raceFirst(bindings.failure, acquired.connect.pipe(Effect.map((controls) => makeSession(controls, bindings)))).pipe(Effect.onError(() => acquired.close.pipe(Effect.asVoid)));
-			});
-			return BrowserbaseBrowser.of({
-				acquire,
-				attach,
-				open: (policy, request) => acquire(policy, request).pipe(Effect.flatMap((acquired) => acquired.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.remote !== "confirmed" || cleanup.local !== "closed" || cleanup.issues.length > 0) return yield* BrowserError.make({
-						operation: "close",
-						reason: "provider",
-						outcome: "unknown"
-					});
-					return result;
-				}))
-			});
-		}));
-	}
-};
-/** Only the automation fields cross the schema boundary; launch and callbacks are separate. */
-const projected = (options) => ({
-	...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 }
-});
-//#endregion
-export { BrowserbaseBrowser, Browser_exports as t };
-
-//# sourceMappingURL=Browser.mjs.map
+import "./BrowserBinding.mjs";
+import { t as BrowserbaseBrowser } from "./Browser-DpSajNai.mjs";
+export { BrowserbaseBrowser };

package/dist/BrowserBinding.d.mts

@@ -1,40 +1,13 @@
-import { BrowserError } from "./Errors.mjs";
-import { Context, Effect, Layer, Redacted } from "effect";
+import { Context, Layer } from "effect";
+import * as BrowserRuntime from "effect-browser/browser-runtime";
 //#region src/BrowserBinding.d.ts
-/**
- * The trusted native engine an owned or borrowed browser connects through. It is opaque: only
- * this module issues one, so a value that merely has this shape is refused before allocation
- * rather than trusted with a connection.
- */
-export interface BrowserBinding {
-  readonly _tag: "BrowserbaseBrowserBinding";
-}
-export interface PlaywrightOptions {
-  /**
-   * Trusted host routing. It runs only after the provider-issued address passed the same strict
-   * checks as the default, and returns the CDP endpoint to connect to instead. A local engine
-   * reached this way says nothing about how a hosted connection behaves.
-   */
-  readonly resolveEndpoint?: (provider: {
-    readonly url: Redacted.Redacted<string>;
-  }) => Effect.Effect<string, BrowserError>;
-  /**
-   * Trusted instrumentation of the engine's own browser object, called once per connection with
-   * the endpoint it reached, before the owner drives it. The object is typed `unknown` so that
-   * no declaration of this package names the optional native peer; it is host configuration,
-   * never model-facing.
-   */
-  readonly onConnected?: (connection: {
-    readonly native: unknown;
-    readonly endpoint: string;
-  }) => void;
-}
-/** Playwright over CDP, lazily loaded at connection time and never at Layer construction. */
+export type BrowserBinding = BrowserRuntime.BrowserBinding;
+export type PlaywrightOptions = BrowserRuntime.PlaywrightOptions;
+/** Validate provider authority before invoking any trusted host routing. */
 export declare const playwright: (options?: PlaywrightOptions) => BrowserBinding;
-/** Defaults to Playwright with the provider's own address, so no consumer has to provide it. */
-export declare const BrowserbaseBrowserBinding: Context.Reference<BrowserBinding>;
-/** Supply a binding to every browser Layer built beneath it. */
+export declare const BrowserbaseBrowserBinding: Context.Reference<BrowserRuntime.BrowserBinding>;
 export declare const layer: (binding: BrowserBinding) => Layer.Layer<never>;
 export declare const layerPlaywright: Layer.Layer<never>;
 //#endregion
+export {};
 //# sourceMappingURL=BrowserBinding.d.mts.map

package/dist/BrowserBinding.mjs

@@ -1,2 +1,31 @@
-import { i as playwright, n as layer, r as layerPlaywright, t as BrowserbaseBrowserBinding } from "./BrowserBinding-DlJTGYZL.mjs";
+import { n as validateConnection } from "./Connection-sxyxtwlk.mjs";
+import { Context, Effect, Layer, Redacted, Schema } from "effect";
+import { BrowserError, Reasons } from "effect-browser/errors";
+import * as BrowserRuntime from "effect-browser/browser-runtime";
+//#region src/BrowserBinding.ts
+/** Validate provider authority before invoking any trusted host routing. */
+const playwright = (options = {}) => {
+	const { resolveEndpoint, onConnected } = options;
+	return BrowserRuntime.playwright({
+		resolveEndpoint: ({ url }) => Effect.gen(function* () {
+			const validated = yield* Effect.try({
+				try: () => validateConnection(Redacted.value(url)),
+				catch: (error) => Schema.is(BrowserError)(error) ? error : BrowserError.make({
+					operation: "connect",
+					reason: Reasons.Malformed.make({}),
+					outcome: "undispatched"
+				})
+			});
+			return yield* resolveEndpoint === void 0 ? Effect.succeed(validated) : resolveEndpoint({ url: Redacted.make(validated) });
+		}),
+		...onConnected === void 0 ? {} : { onConnected }
+	});
+};
+const defaultBinding = playwright();
+const BrowserbaseBrowserBinding = Context.Reference("effect-browserbase/BrowserBinding", { defaultValue: () => defaultBinding });
+const layer = (binding) => Layer.succeed(BrowserbaseBrowserBinding, binding);
+const layerPlaywright = layer(defaultBinding);
+//#endregion
 export { BrowserbaseBrowserBinding, layer, layerPlaywright, playwright };
+
+//# sourceMappingURL=BrowserBinding.mjs.map

package/dist/BrowserBinding.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"BrowserBinding.mjs","names":[],"sources":["../src/BrowserBinding.ts"],"sourcesContent":["import { Context, Effect, Layer, Redacted, Schema } from \"effect\";\nimport * as BrowserRuntime from \"effect-browser/browser-runtime\";\nimport { BrowserError, Reasons } from \"effect-browser/errors\";\n\nimport { validateConnection } from \"./internal/provider/Connection.ts\";\n\nexport type BrowserBinding = BrowserRuntime.BrowserBinding;\nexport type PlaywrightOptions = BrowserRuntime.PlaywrightOptions;\n\n/** Validate provider authority before invoking any trusted host routing. */\nexport const playwright = (options: PlaywrightOptions = {}): BrowserBinding => {\n  const { resolveEndpoint, onConnected } = options;\n\n  return BrowserRuntime.playwright({\n    resolveEndpoint: ({ url }) =>\n      Effect.gen(function* () {\n        const validated = yield* Effect.try({\n          try: () => validateConnection(Redacted.value(url)),\n          catch: (error) =>\n            Schema.is(BrowserError)(error)\n              ? error\n              : BrowserError.make({\n                  operation: \"connect\",\n                  reason: Reasons.Malformed.make({}),\n                  outcome: \"undispatched\",\n                }),\n        });\n\n        return yield* resolveEndpoint === undefined\n          ? Effect.succeed(validated)\n          : resolveEndpoint({ url: Redacted.make(validated) });\n      }),\n    ...(onConnected === undefined ? {} : { onConnected }),\n  });\n};\n\nconst defaultBinding = playwright();\n\nexport const BrowserbaseBrowserBinding = Context.Reference<BrowserBinding>(\n  \"effect-browserbase/BrowserBinding\",\n  { defaultValue: () => defaultBinding },\n);\n\nexport const layer = (binding: BrowserBinding): Layer.Layer<never> =>\n  Layer.succeed(BrowserbaseBrowserBinding, binding);\n\nexport const layerPlaywright: Layer.Layer<never> = layer(defaultBinding);\n"],"mappings":";;;;;;AAUA,MAAa,cAAc,UAA6B,CAAC,MAAsB;CAC7E,MAAM,EAAE,iBAAiB,gBAAgB;CAEzC,OAAO,eAAe,WAAW;EAC/B,kBAAkB,EAAE,UAClB,OAAO,IAAI,aAAa;GACtB,MAAM,YAAY,OAAO,OAAO,IAAI;IAClC,WAAW,mBAAmB,SAAS,MAAM,GAAG,CAAC;IACjD,QAAQ,UACN,OAAO,GAAG,YAAY,CAAC,CAAC,KAAK,IACzB,QACA,aAAa,KAAK;KAChB,WAAW;KACX,QAAQ,QAAQ,UAAU,KAAK,CAAC,CAAC;KACjC,SAAS;IACX,CAAC;GACT,CAAC;GAED,OAAO,OAAO,oBAAoB,KAAA,IAC9B,OAAO,QAAQ,SAAS,IACxB,gBAAgB,EAAE,KAAK,SAAS,KAAK,SAAS,EAAE,CAAC;EACvD,CAAC;EACH,GAAI,gBAAgB,KAAA,IAAY,CAAC,IAAI,EAAE,YAAY;CACrD,CAAC;AACH;AAEA,MAAM,iBAAiB,WAAW;AAElC,MAAa,4BAA4B,QAAQ,UAC/C,qCACA,EAAE,oBAAoB,eAAe,CACvC;AAEA,MAAa,SAAS,YACpB,MAAM,QAAQ,2BAA2B,OAAO;AAElD,MAAa,kBAAsC,MAAM,cAAc"}

package/dist/Certificates-D4NQmyeA.d.mts

@@ -0,0 +1,34 @@
+import { CertificateError } from "./Errors.mjs";
+import { t as BrowserbaseClient } from "./Client-B_f6bBLT.mjs";
+import { Context, Effect, Layer, Schema } from "effect";
+//#region src/Certificates.d.ts
+declare const CertificateMetadata_base: Schema.Class<CertificateMetadata, Schema.Struct<{
+  readonly certificateId: Schema.NonEmptyString;
+  readonly projectId: Schema.NonEmptyString;
+  readonly createdAt: Schema.String;
+  readonly updatedAt: Schema.String;
+}>, {}>;
+/** Select a certificate at launch with `provider.proxySettings.caCertificates: [certificateId]`. */
+declare class CertificateMetadata extends CertificateMetadata_base {}
+interface CertificateUpload {
+  /** PEM or DER bytes of one CA certificate. */
+  readonly bytes: Uint8Array;
+  /** Portable basename sent with the part; defaults to `certificate.pem`. */
+  readonly filename?: string;
+  readonly maxBytes?: number;
+  readonly timeoutMillis?: number;
+}
+declare const BrowserbaseCertificates_base: Context.ServiceClass<BrowserbaseCertificates, "effect-browserbase/Certificates", {
+  readonly create: (upload: CertificateUpload) => Effect.Effect<CertificateMetadata, CertificateError>;
+  readonly list: Effect.Effect<ReadonlyArray<CertificateMetadata>, CertificateError>;
+  readonly retrieve: (certificateId: string) => Effect.Effect<CertificateMetadata, CertificateError>;
+  readonly delete: (certificateId: string) => Effect.Effect<void, CertificateError>;
+}>;
+/** Proxy CA certificates. Registration is one bounded multipart mutation, never retried. */
+declare class BrowserbaseCertificates extends BrowserbaseCertificates_base {
+  static readonly layer: Layer.Layer<BrowserbaseCertificates, never, BrowserbaseClient>;
+}
+//#endregion
+export { CertificateMetadata as n, CertificateUpload as r, BrowserbaseCertificates as t };
+export {};
+//# sourceMappingURL=Certificates-D4NQmyeA.d.mts.map

package/dist/Certificates.d.mts

@@ -1,35 +1,3 @@
-import { CertificateError } from "./Errors.mjs";
-import { t as BrowserbaseClient } from "./Client-Ca0zSg1n.mjs";
-import { Context, Effect, Layer, Schema } from "effect";
-declare namespace Certificates_d_exports {
-  export { BrowserbaseCertificates, CertificateMetadata, CertificateUpload };
-}
-declare const CertificateMetadata_base: Schema.Class<CertificateMetadata, Schema.Struct<{
-  readonly certificateId: Schema.NonEmptyString;
-  readonly projectId: Schema.NonEmptyString;
-  readonly createdAt: Schema.String;
-  readonly updatedAt: Schema.String;
-}>, {}>;
-/** Select a certificate at launch with `provider.proxySettings.caCertificates: [certificateId]`. */
-export declare class CertificateMetadata extends CertificateMetadata_base {}
-export interface CertificateUpload {
-  /** PEM or DER bytes of one CA certificate. */
-  readonly bytes: Uint8Array;
-  /** Portable basename sent with the part; defaults to `certificate.pem`. */
-  readonly filename?: string;
-  readonly maxBytes?: number;
-  readonly timeoutMillis?: number;
-}
-declare const BrowserbaseCertificates_base: Context.ServiceClass<BrowserbaseCertificates, "effect-browserbase/Certificates", {
-  readonly create: (upload: CertificateUpload) => Effect.Effect<CertificateMetadata, CertificateError>;
-  readonly list: Effect.Effect<ReadonlyArray<CertificateMetadata>, CertificateError>;
-  readonly retrieve: (certificateId: string) => Effect.Effect<CertificateMetadata, CertificateError>;
-  readonly delete: (certificateId: string) => Effect.Effect<void, CertificateError>;
-}>;
-/** Proxy CA certificates. Registration is one bounded multipart mutation, never retried. */
-export declare class BrowserbaseCertificates extends BrowserbaseCertificates_base {
-  static readonly layer: Layer.Layer<BrowserbaseCertificates, never, BrowserbaseClient>;
-}
-//#endregion
-export { Certificates_d_exports as t };
-//# sourceMappingURL=Certificates.d.mts.map
+import { n as CertificateMetadata, r as CertificateUpload, t as BrowserbaseCertificates } from "./Certificates-D4NQmyeA.mjs";
+export { BrowserbaseCertificates, CertificateMetadata, CertificateUpload };
+export {};

package/dist/Certificates.mjs

@@ -1,15 +1,10 @@
-import { t as __exportAll } from "./rolldown-runtime-D7D4PA-g.mjs";
 import { Identifier } from "./References.mjs";
 import { CertificateError } from "./Errors.mjs";
 import { SafeFilename } from "./Transfers.mjs";
-import { t as BrowserbaseClient } from "./Client-D1_xYM9o.mjs";
+import { t as BrowserbaseClient } from "./Client-4RMKIpL2.mjs";
 import { t as resource } from "./Resource-DBksC4zB.mjs";
 import { Context, Effect, Layer, Schema } from "effect";
 //#region src/Certificates.ts
-var Certificates_exports = /* @__PURE__ */ __exportAll({
-	BrowserbaseCertificates: () => BrowserbaseCertificates,
-	CertificateMetadata: () => CertificateMetadata
-});
 const Timestamp = Schema.String.check(Schema.isMaxLength(64));
 const MAX_CERTIFICATE_BYTES = 1048576;
 /** Select a certificate at launch with `provider.proxySettings.caCertificates: [certificateId]`. */
@@ -85,6 +80,6 @@ var BrowserbaseCertificates = class BrowserbaseCertificates extends Context.Serv
 	}));
 };
 //#endregion
-export { BrowserbaseCertificates, CertificateMetadata, Certificates_exports as t };
+export { BrowserbaseCertificates, CertificateMetadata };
 
 //# sourceMappingURL=Certificates.mjs.map