effect-browser 0.0.0-reserved.0 → 0.2.0-beta.1

package/dist/Browser.d.mts

@@ -0,0 +1,189 @@
+import { f as Plan, g as ReadinessOutcome, s as Bootstrap_d_exports, t as BindingDiagnostics } from "./Bootstrap-B9UUXsvF.mjs";
+import { BrowserError, InitializationError } from "./Errors.mjs";
+import { $ as TypeRequest, D as NavigationResult, E as NavigateRequest, F as PointerMoveRequest, H as ScreenshotResult, J as SessionStatus, L as PressRequest, N as PageInfo, O as Observation, Q as TextResult, R as ReadTextRequest, S as InputReceipt, U as ScrollRequest, V as ScreenshotRequest, W as SelectOptions, X as Target, Y as StartNavigationRequest, _ as FrameInfo, at as WheelRequest, c as ClickRequest, d as FillFormRequest, et as Viewport, f as FillFormResult, i as BrowserDiagnostics, it as WaitForElementRequest, j as ObservedElement, k as ObservationOptions, l as ControlFacts, o as Checkpoint, p as FillRequest, s as CheckpointOptions, t as ActionResult, u as FillFormOptions, v as HoverRequest, w as KeyStroke } from "./BrowserData-CRuxEZcn.mjs";
+import { Effect, Scope } from "effect";
+//#region src/Browser.d.ts
+/**
+ * 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.
+   * An already-completed navigation cannot stop a successor. Concurrent callers share their
+   * active attempt. Before dispatch, cancellation or a busy refusal permits a later request
+   * once native setup has retired. A dispatched attempt's outcome, including failure or
+   * interruption, is retained permanently; an uncertain stop is never replayed.
+   */
+  readonly stop: Effect.Effect<void, BrowserError>;
+}
+/** Common operations. Direct, retained and pinned views choose their target at different times. */
+export interface TargetOperations {
+  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>;
+}
+/**
+ * One explicit page/frame target. Selection may move independently; each operation re-resolves
+ * this identity inside the same owner and connection. Closing/detaching it or reconnecting makes
+ * the handle stale before dispatch.
+ */
+export interface PinnedTarget extends TargetOperations {
+  readonly target: Target;
+}
+/** A checked selection retained at acquisition; moving selection away and back makes it stale. */
+export interface RetainedTarget extends TargetOperations {}
+/**
+ * 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.
+ *
+ * The inherited target operations resolve the selected page/frame when their Effect executes.
+ * Use `retain` to retain the current selection with stale-on-selection-change semantics, or
+ * `pinPage` / `pinFrame` when work must stay on an explicit target while selection moves.
+ */
+export interface BrowserSession<E = never> extends TargetOperations {
+  /** The implementation which owns this live connection. */
+  readonly implementation: string;
+  /** Copied host-only state, readable without admission in every lifecycle phase. */
+  readonly status: Effect.Effect<SessionStatus>;
+  /** Bounded native/policy diagnostics. Typed callback causes remain in bindingDiagnostics. */
+  readonly diagnostics: Effect.Effect<BrowserDiagnostics>;
+  /** Close this scope and require its own ownership-specific cleanup evidence. */
+  readonly closeChecked: Effect.Effect<void, BrowserError>;
+  /** 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>>;
+  /** Resolve, validate and retain the selection under owner admission. */
+  readonly retain: Effect.Effect<RetainedTarget, 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, plus bounded choices of visible native
+   * selects; the default reads the whole document. 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>;
+  /** One selection using this exact select and its issued option element IDs, with fresh checks. */
+  readonly selectOption: (reference: ObservedElement, options: SelectOptions, 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>;
+  /**
+   * Set several controls of one observation in order, then optionally click one submit control.
+   * Every step acts on the exact observed node after the same fresh checks as `fillElement`,
+   * except that a control may have become enabled since it was observed, and each is admitted
+   * and charged as its own action. The observation stays usable for this form's own steps only;
+   * anything else that changes the page still retires it, and the form retires it when it ends.
+   * The first refused or uncertain step ends the form. Submit is sent only after every field
+   * succeeded and, unless `verify` is false, still holds what its step left there. Fields set
+   * before a stop stay set. It fails only when its first step does; otherwise `stopped` says
+   * where it ended and why.
+   */
+  readonly fillForm: (request: FillFormRequest, admission?: ElementAdmission, options?: FillFormOptions) => Effect.Effect<FillFormResult, BrowserError>;
+  readonly pages: Effect.Effect<ReadonlyArray<PageInfo>, BrowserError>;
+  readonly frames: Effect.Effect<ReadonlyArray<FrameInfo>, BrowserError>;
+  /** List frames on one exact page without selecting it. */
+  readonly framesOf: (page: PageInfo) => Effect.Effect<ReadonlyArray<FrameInfo>, BrowserError>;
+  /** Pin the page's main frame without changing the session selection. */
+  readonly pinPage: (page: PageInfo) => Effect.Effect<PinnedTarget, BrowserError>;
+  /** Pin one frame that currently belongs to the exact page, without changing selection. */
+  readonly pinFrame: (page: PageInfo, frame: FrameInfo) => Effect.Effect<PinnedTarget, BrowserError>;
+  readonly selectPage: (page: PageInfo) => Effect.Effect<void, BrowserError>;
+  readonly selectFrame: (frameId: string) => Effect.Effect<void, BrowserError>;
+  /** Create a tab without selecting it and return that exact tab's checked identity. */
+  readonly createPage: Effect.Effect<PageInfo, BrowserError>;
+  readonly closePage: (page: PageInfo) => Effect.Effect<void, BrowserError>;
+  readonly resizeViewport: (viewport: Viewport) => Effect.Effect<void, BrowserError>;
+  /**
+   * Wait on the original observed node within the host deadline. Hidden includes its detachment;
+   * document replacement is stale. Success observes a condition, without authorizing later input.
+   */
+  readonly waitForElement: (request: WaitForElementRequest) => 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>;
+}
+/** Helpers that do not supervise callback failures accept any live browser session. */
+export type AnySession = BrowserSession<unknown>;
+/** 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>;
+}
+/**
+ * Acquire, supervise and close one browser in a fresh scope. The callback keeps the concrete
+ * Chromium or provider session type. Its scoped work is joined before checked browser cleanup,
+ * and cleanup failures remain typed even when the callback has already failed or was cancelled.
+ * Acquisition is evaluated once; an uncertain result is never retried.
+ */
+export declare const scoped: {
+  <S extends BrowserSession<unknown>, A, E2, R2>(f: (session: S) => Effect.Effect<A, E2, R2>): <E, AE, AR>(open: Effect.Effect<S & BrowserSession<E>, AE, AR>) => Effect.Effect<A, AE | E | E2 | InitializationError | BrowserError, Exclude<AR | R2, Scope.Scope>>;
+  <S, E, AE, AR, A, E2, R2>(open: Effect.Effect<S & BrowserSession<E>, AE, AR>, f: (session: S & BrowserSession<E>) => Effect.Effect<A, E2, R2>): Effect.Effect<A, AE | E | E2 | InitializationError | BrowserError, Exclude<AR | R2, Scope.Scope>>;
+};
+//#endregion
+export {};
+//# sourceMappingURL=Browser.d.mts.map

package/dist/Browser.mjs

@@ -0,0 +1,14 @@
+import { Effect } from "effect";
+import { dual } from "effect/Function";
+//#region src/Browser.ts
+/**
+* Acquire, supervise and close one browser in a fresh scope. The callback keeps the concrete
+* Chromium or provider session type. Its scoped work is joined before checked browser cleanup,
+* and cleanup failures remain typed even when the callback has already failed or was cancelled.
+* Acquisition is evaluated once; an uncertain result is never retried.
+*/
+const scoped = dual(2, (open, f) => Effect.scoped(Effect.flatMap(open, (session) => Effect.scoped(Effect.raceFirst(session.failure, Effect.suspend(() => f(session)))).pipe(Effect.onExit(() => session.closeChecked)))));
+//#endregion
+export { scoped };
+
+//# sourceMappingURL=Browser.mjs.map

package/dist/Browser.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"Browser.mjs","names":[],"sources":["../src/Browser.ts"],"sourcesContent":["import { Effect, type Scope } from \"effect\";\nimport { dual } from \"effect/Function\";\n\nimport type * as Bootstrap from \"./Bootstrap.ts\";\nimport type {\n  BrowserDiagnostics,\n  Checkpoint,\n  CheckpointOptions,\n  FillFormOptions,\n  FillFormRequest,\n  FillFormResult,\n  FillRequest,\n  HoverRequest,\n  InputReceipt,\n  KeyStroke,\n  NavigateRequest,\n  NavigationResult,\n  ObservationOptions,\n  ObservedElement,\n  PointerMoveRequest,\n  PressRequest,\n  ReadTextRequest,\n  ScreenshotRequest,\n  ScreenshotResult,\n  ScrollRequest,\n  SelectOptions,\n  SessionStatus,\n  StartNavigationRequest,\n  TextResult,\n  TypeRequest,\n  WaitForElementRequest,\n  WheelRequest,\n  ControlFacts,\n  ActionResult,\n  ClickRequest,\n  FrameInfo,\n  Observation,\n  PageInfo,\n  Target,\n  Viewport,\n} from \"./BrowserData.ts\";\nimport type { BrowserError, InitializationError } from \"./Errors.ts\";\n\n/**\n * A host's decision about one control, made on facts read from the exact node immediately\n * before input. Returning anything but `true`, or throwing, sends nothing and fails `denied`.\n * It is a plain synchronous function on purpose: it runs while the owner's permit is held, where\n * waiting on a model or a network call would stall every other operation. It is not an atomic\n * check-and-input transaction, because page script can still run before the native input lands.\n */\nexport interface ElementAdmission {\n  readonly admit: (facts: ControlFacts) => boolean;\n}\n\n/**\n * A navigation the browser is still performing. The owner's permit was released when it was\n * dispatched, so while it loads a host may read, `checkpoint`, hold and resume this page, and\n * use any other page. Anything that would change this page fails `busy` until it settles.\n *\n * Leaving its scope unsettled fences the session, exactly as an interrupted mutation does,\n * because nothing then knows what the browser did. It is never replayed.\n */\nexport interface NavigationOperation {\n  /** What was navigated, read before dispatch. */\n  readonly target: Target;\n  /**\n   * The document reached DOMContentLoaded. It belongs to this one navigation: a successor that\n   * reaches the same URL fails it instead. Interrupting a waiter stops nothing in the browser.\n   */\n  readonly completed: Effect.Effect<NavigationResult, BrowserError>;\n  /**\n   * Asks the browser to stop loading and waits for this navigation to settle, after which\n   * `completed` fails `interrupted`. Success is a known outcome and the session stays usable:\n   * the page holds whatever had loaded. It does not undo anything the page already did.\n   * An already-completed navigation cannot stop a successor. Concurrent callers share their\n   * active attempt. Before dispatch, cancellation or a busy refusal permits a later request\n   * once native setup has retired. A dispatched attempt's outcome, including failure or\n   * interruption, is retained permanently; an uncertain stop is never replayed.\n   */\n  readonly stop: Effect.Effect<void, BrowserError>;\n}\n\n/** Common operations. Direct, retained and pinned views choose their target at different times. */\nexport interface TargetOperations {\n  readonly navigate: (request: NavigateRequest) => Effect.Effect<NavigationResult, BrowserError>;\n  /** `navigate`, left in flight: the same single dispatch, completed by the caller. */\n  readonly startNavigation: (\n    request: StartNavigationRequest,\n  ) => Effect.Effect<NavigationOperation, BrowserError, Scope.Scope>;\n  readonly readText: (request: ReadTextRequest) => Effect.Effect<TextResult, BrowserError>;\n  readonly click: (request: ClickRequest) => Effect.Effect<ActionResult, BrowserError>;\n  readonly fill: (request: FillRequest) => Effect.Effect<ActionResult, BrowserError>;\n  /** Script in the page: instantaneous, and it raises no wheel event. */\n  readonly scroll: (request: ScrollRequest) => Effect.Effect<ActionResult, BrowserError>;\n  /** One real pointer move, in main-frame viewport pixels. */\n  readonly pointerMove: (request: PointerMoveRequest) => Effect.Effect<InputReceipt, BrowserError>;\n  /** Places the pointer on one exact element where it is, or fails `not-visible` unsent. */\n  readonly hover: (request: HoverRequest) => Effect.Effect<InputReceipt, BrowserError>;\n  /** One real wheel event; the browser decides what under the pointer scrolls. */\n  readonly wheel: (request: WheelRequest) => Effect.Effect<InputReceipt, BrowserError>;\n  /** One real key stroke to whatever has focus, or fails `not-focused` unsent if `into` lacks it. */\n  readonly press: (request: PressRequest) => Effect.Effect<InputReceipt, BrowserError>;\n  /** Text as the real key strokes that produce it, under the same focus rule as `press`. */\n  readonly type: (request: TypeRequest) => Effect.Effect<InputReceipt, BrowserError>;\n  readonly screenshot: (\n    request: ScreenshotRequest,\n  ) => Effect.Effect<ScreenshotResult, BrowserError>;\n}\n\n/**\n * One explicit page/frame target. Selection may move independently; each operation re-resolves\n * this identity inside the same owner and connection. Closing/detaching it or reconnecting makes\n * the handle stale before dispatch.\n */\nexport interface PinnedTarget extends TargetOperations {\n  readonly target: Target;\n}\n\n/** A checked selection retained at acquisition; moving selection away and back makes it stale. */\nexport interface RetainedTarget extends TargetOperations {}\n\n/**\n * Host control over one owned browser. This is not a serializable model value: copying a\n * session object cannot copy its capture, page-control or connection authority.\n *\n * The inherited target operations resolve the selected page/frame when their Effect executes.\n * Use `retain` to retain the current selection with stale-on-selection-change semantics, or\n * `pinPage` / `pinFrame` when work must stay on an explicit target while selection moves.\n */\nexport interface BrowserSession<E = never> extends TargetOperations {\n  /** The implementation which owns this live connection. */\n  readonly implementation: string;\n  /** Copied host-only state, readable without admission in every lifecycle phase. */\n  readonly status: Effect.Effect<SessionStatus>;\n  /** Bounded native/policy diagnostics. Typed callback causes remain in bindingDiagnostics. */\n  readonly diagnostics: Effect.Effect<BrowserDiagnostics>;\n  /** Close this scope and require its own ownership-specific cleanup evidence. */\n  readonly closeChecked: Effect.Effect<void, BrowserError>;\n  /** First fail-session callback cause, preserving the consumer's error type on the host. */\n  readonly failure: Effect.Effect<never, E | InitializationError>;\n  /** Bounded host-only evidence; consumer causes are never projected into a page reply. */\n  readonly bindingDiagnostics: Effect.Effect<Bootstrap.BindingDiagnostics<E>>;\n  /** Resolve, validate and retain the selection under owner admission. */\n  readonly retain: Effect.Effect<RetainedTarget, BrowserError>;\n  readonly target: Effect.Effect<Target, BrowserError>;\n  /**\n   * The one observation whose nodes later actions may name. `scope: \"viewport\"` keeps only text\n   * and controls that are on screen and reachable, plus bounded choices of visible native\n   * selects; the default reads the whole document. It carries no destination, form or field value.\n   */\n  readonly observe: (options?: ObservationOptions) => Effect.Effect<Observation, BrowserError>;\n  /**\n   * Passive evidence for a recorder, with a picture when asked. It issues no references and\n   * leaves the observation above exactly as it was. Host-only: it carries control facts.\n   */\n  readonly checkpoint: (options?: CheckpointOptions) => Effect.Effect<Checkpoint, BrowserError>;\n  /** Host-only facts about one observed control, read from that exact node just now. */\n  readonly controlFacts: (reference: ObservedElement) => Effect.Effect<ControlFacts, BrowserError>;\n  /**\n   * After a page hold, nothing observed on that page may be acted on unchecked. This checks one\n   * reference: still attached, and still the control that was inspected. It never searches by\n   * selector or label for a substitute, and it sends nothing.\n   */\n  readonly revalidateElement: (\n    reference: ObservedElement,\n  ) => Effect.Effect<ObservedElement, BrowserError>;\n  readonly clickElement: (\n    reference: ObservedElement,\n    admission?: ElementAdmission,\n  ) => Effect.Effect<ActionResult, BrowserError>;\n  readonly fillElement: (\n    reference: ObservedElement,\n    value: string,\n    admission?: ElementAdmission,\n  ) => Effect.Effect<ActionResult, BrowserError>;\n  /** One selection using this exact select and its issued option element IDs, with fresh checks. */\n  readonly selectOption: (\n    reference: ObservedElement,\n    options: SelectOptions,\n    admission?: ElementAdmission,\n  ) => Effect.Effect<ActionResult, BrowserError>;\n  readonly hoverElement: (\n    reference: ObservedElement,\n    admission?: ElementAdmission,\n  ) => Effect.Effect<InputReceipt, BrowserError>;\n  /** A key stroke sent only if the exact node an observation named already has focus. */\n  readonly pressElement: (\n    reference: ObservedElement,\n    stroke: KeyStroke,\n    admission?: ElementAdmission,\n  ) => Effect.Effect<InputReceipt, BrowserError>;\n  /** Real typing with `fillElement`'s exactness: that node must already have focus. */\n  readonly typeElement: (\n    reference: ObservedElement,\n    text: string,\n    admission?: ElementAdmission,\n  ) => Effect.Effect<InputReceipt, BrowserError>;\n  /**\n   * Set several controls of one observation in order, then optionally click one submit control.\n   * Every step acts on the exact observed node after the same fresh checks as `fillElement`,\n   * except that a control may have become enabled since it was observed, and each is admitted\n   * and charged as its own action. The observation stays usable for this form's own steps only;\n   * anything else that changes the page still retires it, and the form retires it when it ends.\n   * The first refused or uncertain step ends the form. Submit is sent only after every field\n   * succeeded and, unless `verify` is false, still holds what its step left there. Fields set\n   * before a stop stay set. It fails only when its first step does; otherwise `stopped` says\n   * where it ended and why.\n   */\n  readonly fillForm: (\n    request: FillFormRequest,\n    admission?: ElementAdmission,\n    options?: FillFormOptions,\n  ) => Effect.Effect<FillFormResult, BrowserError>;\n  readonly pages: Effect.Effect<ReadonlyArray<PageInfo>, BrowserError>;\n  readonly frames: Effect.Effect<ReadonlyArray<FrameInfo>, BrowserError>;\n  /** List frames on one exact page without selecting it. */\n  readonly framesOf: (page: PageInfo) => Effect.Effect<ReadonlyArray<FrameInfo>, BrowserError>;\n  /** Pin the page's main frame without changing the session selection. */\n  readonly pinPage: (page: PageInfo) => Effect.Effect<PinnedTarget, BrowserError>;\n  /** Pin one frame that currently belongs to the exact page, without changing selection. */\n  readonly pinFrame: (\n    page: PageInfo,\n    frame: FrameInfo,\n  ) => Effect.Effect<PinnedTarget, BrowserError>;\n  readonly selectPage: (page: PageInfo) => Effect.Effect<void, BrowserError>;\n  readonly selectFrame: (frameId: string) => Effect.Effect<void, BrowserError>;\n  /** Create a tab without selecting it and return that exact tab's checked identity. */\n  readonly createPage: Effect.Effect<PageInfo, BrowserError>;\n  readonly closePage: (page: PageInfo) => Effect.Effect<void, BrowserError>;\n  readonly resizeViewport: (viewport: Viewport) => Effect.Effect<void, BrowserError>;\n  /**\n   * Wait on the original observed node within the host deadline. Hidden includes its detachment;\n   * document replacement is stale. Success observes a condition, without authorizing later input.\n   */\n  readonly waitForElement: (request: WaitForElementRequest) => Effect.Effect<void, BrowserError>;\n  readonly waitFor: (request: {\n    readonly selector: string;\n    readonly state: \"visible\" | \"hidden\" | \"attached\" | \"detached\";\n  }) => Effect.Effect<void, BrowserError>;\n  /** Navigation observation is registered before the single click dispatch. */\n  readonly clickAndWait: (request: ClickRequest) => Effect.Effect<ActionResult, BrowserError>;\n  /**\n   * Readiness of the current document only. Dependent operations wait for it themselves;\n   * this reports it without charging an action, so a caller can decide what to do about a\n   * document that predates the registrations.\n   */\n  readonly ready: Effect.Effect<Bootstrap.ReadinessOutcome, InitializationError>;\n}\n\n/** Helpers that do not supervise callback failures accept any live browser session. */\nexport type AnySession = BrowserSession<unknown>;\n\n/** Dependencies are captured at acquisition, not erased into an environment-free service Layer. */\nexport interface OpenOptions<E = never, R = never> {\n  readonly bootstrap?: Bootstrap.Plan<E, R>;\n}\n\n/**\n * Acquire, supervise and close one browser in a fresh scope. The callback keeps the concrete\n * Chromium or provider session type. Its scoped work is joined before checked browser cleanup,\n * and cleanup failures remain typed even when the callback has already failed or was cancelled.\n * Acquisition is evaluated once; an uncertain result is never retried.\n */\nexport const scoped: {\n  <S extends BrowserSession<unknown>, A, E2, R2>(\n    f: (session: S) => Effect.Effect<A, E2, R2>,\n  ): <E, AE, AR>(\n    open: Effect.Effect<S & BrowserSession<E>, AE, AR>,\n  ) => Effect.Effect<\n    A,\n    AE | E | E2 | InitializationError | BrowserError,\n    Exclude<AR | R2, Scope.Scope>\n  >;\n  <S, E, AE, AR, A, E2, R2>(\n    open: Effect.Effect<S & BrowserSession<E>, AE, AR>,\n    f: (session: S & BrowserSession<E>) => Effect.Effect<A, E2, R2>,\n  ): Effect.Effect<\n    A,\n    AE | E | E2 | InitializationError | BrowserError,\n    Exclude<AR | R2, Scope.Scope>\n  >;\n} = dual(\n  2,\n  <S, E, AE, AR, A, E2, R2>(\n    open: Effect.Effect<S & BrowserSession<E>, AE, AR>,\n    f: (session: S & BrowserSession<E>) => Effect.Effect<A, E2, R2>,\n  ) =>\n    Effect.scoped(\n      Effect.flatMap(open, (session) =>\n        Effect.scoped(\n          Effect.raceFirst(\n            session.failure,\n            Effect.suspend(() => f(session)),\n          ),\n        ).pipe(Effect.onExit(() => session.closeChecked)),\n      ),\n    ),\n);\n"],"mappings":";;;;;;;;;AAuQA,MAAa,SAkBT,KACF,IAEE,MACA,MAEA,OAAO,OACL,OAAO,QAAQ,OAAO,YACpB,OAAO,OACL,OAAO,UACL,QAAQ,SACR,OAAO,cAAc,EAAE,OAAO,CAAC,CACjC,CACF,CAAC,CAAC,KAAK,OAAO,aAAa,QAAQ,YAAY,CAAC,CAClD,CACF,CACJ"}