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

package/dist/Browser.d.mts

@@ -0,0 +1,177 @@
+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 { C as ObservationOptions, D as PageInfo, F as ScreenshotResult, G as TextResult, H as StartNavigationRequest, I as ScrollRequest, K as TypeRequest, L as SelectOptions, M as ReadTextRequest, P as ScreenshotRequest, Q as WheelRequest, S as Observation, T as ObservedElement, U as Target, V as SessionStatus, Z as WaitForElementRequest, b as NavigateRequest, c as ClickRequest, d as FrameInfo, f as HoverRequest, g as InputReceipt, i as BrowserDiagnostics, j as PressRequest, k as PointerMoveRequest, l as ControlFacts, o as Checkpoint, q as Viewport, s as CheckpointOptions, t as ActionResult, u as FillRequest, v as KeyStroke, x as NavigationResult } from "./BrowserData-DJAnUHoZ.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>;
+  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  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  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":";;;;;;;;;AAoPA,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"}

package/dist/BrowserData-DJAnUHoZ.d.mts

@@ -0,0 +1,412 @@
+import { Schema } from "effect";
+//#region src/BrowserData.d.ts
+declare const Identifier: Schema.NonEmptyString;
+declare const PositiveInt: Schema.Int;
+/** Portable basename only; never a local or remote filesystem path. */
+declare const SafeFilename: Schema.NonEmptyString;
+declare const Viewport_base: Schema.Class<Viewport, Schema.Struct<{
+  readonly width: Schema.Int;
+  readonly height: Schema.Int;
+}>, {}>;
+declare class Viewport extends Viewport_base {}
+declare const Target_base: Schema.Class<Target, Schema.Struct<{
+  readonly generation: Schema.Natural;
+  readonly pageId: Schema.NonEmptyString;
+  readonly frameId: Schema.NonEmptyString;
+}>, {}>;
+/** Page/frame IDs are connection-local; targetId is a separate Chromium identity. */
+declare class Target extends Target_base {}
+declare const PageInfo_base: Schema.Class<PageInfo, Schema.Struct<{
+  readonly pageId: Schema.NonEmptyString;
+  readonly targetId: Schema.NonEmptyString;
+  readonly url: Schema.String;
+  readonly title: Schema.String;
+  readonly selected: Schema.Boolean;
+}>, {}>;
+declare class PageInfo extends PageInfo_base {}
+declare const FrameInfo_base: Schema.Class<FrameInfo, Schema.Struct<{
+  readonly frameId: Schema.NonEmptyString;
+  readonly parentFrameId: Schema.NullOr<Schema.NonEmptyString>;
+  readonly url: Schema.String;
+  readonly name: Schema.String;
+}>, {}>;
+declare class FrameInfo extends FrameInfo_base {}
+declare const SessionPhase: Schema.Literals<readonly ["acquiring", "open", "paused", "detached", "faulted", "uncertain", "closing", "closed"]>;
+type SessionPhase = typeof SessionPhase.Type;
+declare const SessionReason: Schema.Literals<readonly ["expired", "callback-failure", "registration-failure", "native-failure", "disconnected", "popup-policy", "dialog-policy", "popup-overflow", "dialog-overflow", "cleanup-capacity", "handoff", "detached", "closed"]>;
+type SessionReason = typeof SessionReason.Type;
+declare const SessionStatus_base: Schema.Class<SessionStatus, Schema.Struct<{
+  readonly phase: Schema.Literals<readonly ["acquiring", "open", "paused", "detached", "faulted", "uncertain", "closing", "closed"]>;
+  readonly reason: Schema.NullOr<Schema.Literals<readonly ["expired", "callback-failure", "registration-failure", "native-failure", "disconnected", "popup-policy", "dialog-policy", "popup-overflow", "dialog-overflow", "cleanup-capacity", "handoff", "detached", "closed"]>>;
+  readonly generation: Schema.Natural;
+  readonly busy: Schema.Boolean;
+  readonly unresolvedDispatch: Schema.Boolean;
+}>, {}>;
+/** Host-only admission evidence. Neither an admission token nor proof of remote termination. */
+declare class SessionStatus extends SessionStatus_base {}
+declare const BrowserDiagnostic_base: Schema.Class<BrowserDiagnostic, Schema.Struct<{
+  readonly reason: Schema.Literals<readonly ["expired", "callback-failure", "registration-failure", "native-failure", "disconnected", "popup-policy", "dialog-policy", "popup-overflow", "dialog-overflow", "cleanup-capacity", "handoff", "detached", "closed"]>;
+  readonly disposition: Schema.Literals<readonly ["pending", "confirmed", "not-dispatched", "unknown"]>;
+  readonly generation: Schema.Natural;
+  readonly monotonicNanos: Schema.BigInt;
+}>, {}>;
+/** Bounded host facts only: no target identity, page content, native exception or consumer cause. */
+declare class BrowserDiagnostic extends BrowserDiagnostic_base {}
+declare const BrowserDiagnostics_base: Schema.Class<BrowserDiagnostics, Schema.Struct<{
+  readonly records: Schema.$Array<typeof BrowserDiagnostic>;
+  readonly total: Schema.Natural;
+  readonly dropped: Schema.Natural;
+  readonly truncated: Schema.Boolean;
+}>, {}>;
+declare class BrowserDiagnostics extends BrowserDiagnostics_base {}
+declare const ObservedControl_base: Schema.Class<ObservedControl, Schema.Struct<{
+  readonly elementId: Schema.NonEmptyString;
+  readonly kind: Schema.Literals<readonly ["link", "button", "input", "select", "textarea", "other"]>;
+  readonly label: Schema.String;
+  readonly disabled: Schema.Boolean;
+  readonly checked: Schema.optionalKey<Schema.Boolean>;
+  readonly selected: Schema.optionalKey<Schema.Boolean>;
+  readonly inputType: Schema.optionalKey<Schema.String>;
+  readonly required: Schema.optionalKey<Schema.Boolean>;
+  /** Native select state. A select is never represented by one `selected` boolean. */
+  readonly multiple: Schema.optionalKey<Schema.Boolean>;
+  /** The issued select this native option belongs to, in the same observation. */
+  readonly selectElementId: Schema.optionalKey<Schema.NonEmptyString>;
+  /** Some choices could not be issued within this reading's shared control/value bounds. */
+  readonly optionsTruncated: Schema.optionalKey<Schema.Boolean>;
+}>, {}>;
+declare class ObservedControl extends ObservedControl_base {}
+declare const ViewportEvidence_base: Schema.Class<ViewportEvidence, Schema.Struct<{
+  readonly width: Schema.Finite;
+  readonly height: Schema.Finite;
+  /** Text that crossed a viewport edge; only its lines on screen were kept. */
+  readonly clippedText: Schema.Natural;
+  /** Left out: the browser found another element at the sampled point. */
+  readonly coveredText: Schema.Natural;
+  readonly uncertainText: Schema.Natural;
+  /** Controls that intersect the viewport but cannot be reached there. */
+  readonly unreachableControls: Schema.Natural;
+  /** The traversal budget ran out first, so this reading is known to be incomplete. */
+  readonly exhausted: Schema.Boolean;
+}>, {}>;
+/**
+ * How a viewport reading was bounded and what it left out. These are counts, so they are safe
+ * to show a model. Visibility is geometry and hit-testing, never a pixel comparison: text is
+ * kept when its line boxes intersect the viewport and the browser finds its own element at a
+ * sampled point. `uncertainText` lay under something that takes no pointer events, which
+ * hit-testing cannot see through, so it is left out rather than called visible.
+ */
+declare class ViewportEvidence extends ViewportEvidence_base {}
+declare const Observation_base: Schema.Class<Observation, Schema.Struct<{
+  readonly target: typeof Target;
+  readonly observationId: Schema.NonEmptyString;
+  readonly revision: Schema.Natural;
+  readonly scope: Schema.Literals<readonly ["document", "viewport"]>;
+  readonly url: Schema.String;
+  readonly text: Schema.String;
+  readonly controls: Schema.$Array<typeof ObservedControl>;
+  readonly controlsTruncated: Schema.Boolean;
+  readonly textTruncated: Schema.Boolean;
+  readonly viewport: typeof ViewportEvidence;
+}>, {}>;
+/**
+ * Revision is admission fencing, not a claim of a complete DOM version or atomic snapshot. A
+ * `viewport` reading holds what is on screen and reachable, plus the bounded choices of its
+ * native selects. Those choices are not a claim that a closed dropdown's rows were visible.
+ * A `document` reading is the whole body, wherever it is. Nothing here carries a destination,
+ * a form or a field value.
+ */
+declare class Observation extends Observation_base {}
+declare const ObservedElement_base: Schema.Class<ObservedElement, Schema.Struct<{
+  readonly observationId: Schema.NonEmptyString;
+  readonly elementId: Schema.NonEmptyString;
+}>, {}>;
+declare class ObservedElement extends ObservedElement_base {}
+declare const WaitForElementRequest_base: Schema.Class<WaitForElementRequest, Schema.Struct<{
+  readonly reference: typeof ObservedElement;
+  readonly state: Schema.Literals<readonly ["visible", "hidden", "enabled", "disabled"]>;
+  readonly timeoutMillis: Schema.optionalKey<Schema.Int>;
+}>, {}>;
+/** Observe a condition of this exact node. A replacement never satisfies the reference. */
+declare class WaitForElementRequest extends WaitForElementRequest_base {}
+/** Issued option element IDs from one observed native select; never values, labels or indices. */
+declare const SelectOptions: Schema.$Array<Schema.NonEmptyString>;
+type SelectOptions = typeof SelectOptions.Type;
+declare const PageSuspension_base: Schema.Class<PageSuspension, Schema.Struct<{
+  readonly pageId: Schema.NonEmptyString;
+  readonly targetId: Schema.NonEmptyString;
+  readonly suspensionId: Schema.NonEmptyString;
+}>, {}>;
+/** Live, connection-owned receipt. It is not a durable promise that remote clocks remain held. */
+declare class PageSuspension extends PageSuspension_base {}
+declare const PageExecutionState_base: Schema.Class<PageExecutionState, Schema.Struct<{
+  readonly pageId: Schema.NonEmptyString;
+  readonly targetId: Schema.NonEmptyString;
+  readonly state: Schema.Literals<readonly ["running", "suspended", "unknown"]>;
+  readonly suspensionId: Schema.optionalKey<Schema.NonEmptyString>;
+}>, {}>;
+declare class PageExecutionState extends PageExecutionState_base {}
+declare const BrowserPolicy_base: Schema.Class<BrowserPolicy, Schema.Struct<{
+  readonly network: Schema.Struct<{
+    readonly _tag: Schema.Literal<"Unrestricted">;
+  }>;
+  readonly maxActions: Schema.Int;
+  readonly maxElapsedMillis: Schema.Int;
+  readonly maxReturnedBytes: Schema.Int;
+}>, {}>;
+/** Explicit opt-out: this integration does not claim whole-browser network containment. */
+declare class BrowserPolicy extends BrowserPolicy_base {
+  /**
+   * Conservative bounds for trusted host code: 100 actions, five minutes, 2 MiB returned.
+   * The network choice is spelled out in the name because this runtime cannot prove a
+   * narrower one; override any bound, never the network.
+   */
+  static unrestricted(bounds?: Partial<Pick<BrowserPolicy, "maxActions" | "maxElapsedMillis" | "maxReturnedBytes">>): BrowserPolicy;
+}
+declare const TargetUrl: Schema.NonEmptyString;
+declare const Selector: Schema.NonEmptyString;
+declare const NavigateRequest_base: Schema.Class<NavigateRequest, Schema.Struct<{
+  readonly url: Schema.NonEmptyString;
+  readonly timeoutMillis: Schema.optionalKey<Schema.Int>;
+}>, {}>;
+declare class NavigateRequest extends NavigateRequest_base {}
+declare const StartNavigationRequest_base: Schema.Class<StartNavigationRequest, Schema.Struct<{
+  readonly url: Schema.NonEmptyString;
+  readonly timeoutMillis: Schema.optionalKey<Schema.Int>;
+}>, {}>;
+/**
+ * A navigation left in flight. `timeoutMillis` is how long the browser may take to reach
+ * DOMContentLoaded; omitted, it is the action timeout, as it is for `navigate`.
+ */
+declare class StartNavigationRequest extends StartNavigationRequest_base {}
+declare const ReadTextRequest_base: Schema.Class<ReadTextRequest, Schema.Struct<{
+  readonly selector: Schema.optionalKey<Schema.NonEmptyString>;
+}>, {}>;
+declare class ReadTextRequest extends ReadTextRequest_base {}
+declare const ClickRequest_base: Schema.Class<ClickRequest, Schema.Struct<{
+  readonly selector: Schema.NonEmptyString;
+}>, {}>;
+declare class ClickRequest extends ClickRequest_base {}
+declare const FillRequest_base: Schema.Class<FillRequest, Schema.Struct<{
+  readonly selector: Schema.NonEmptyString;
+  readonly value: Schema.String;
+}>, {}>;
+declare class FillRequest extends FillRequest_base {}
+declare const ScrollRequest_base: Schema.Class<ScrollRequest, Schema.Struct<{
+  readonly deltaX: Schema.Int;
+  readonly deltaY: Schema.Int;
+}>, {}>;
+declare class ScrollRequest extends ScrollRequest_base {}
+declare const ViewportPoint_base: Schema.Class<ViewportPoint, Schema.Struct<{
+  readonly x: Schema.Finite;
+  readonly y: Schema.Finite;
+}>, {}>;
+/**
+ * CSS pixels in the main frame's viewport, the space Chromium dispatches pointer input in. It
+ * is not a document offset, a device pixel, or a coordinate inside a child frame.
+ */
+declare class ViewportPoint extends ViewportPoint_base {}
+declare const ViewportRect_base: Schema.Class<ViewportRect, Schema.Struct<{
+  readonly x: Schema.Finite;
+  readonly y: Schema.Finite;
+  readonly width: Schema.Finite;
+  readonly height: Schema.Finite;
+}>, {}>;
+/** A box in the viewport of the frame it was read from, in CSS pixels. */
+declare class ViewportRect extends ViewportRect_base {}
+declare const ControlFacts_base: Schema.Class<ControlFacts, Schema.Struct<{
+  readonly kind: Schema.Literals<readonly ["link", "button", "input", "select", "textarea", "other"]>;
+  readonly label: Schema.String;
+  readonly disabled: Schema.Boolean;
+  readonly checked: Schema.optionalKey<Schema.Boolean>;
+  readonly selected: Schema.optionalKey<Schema.Boolean>;
+  readonly required: Schema.optionalKey<Schema.Boolean>;
+  readonly multiple: Schema.optionalKey<Schema.Boolean>;
+  readonly editable: Schema.Boolean;
+  readonly inputType: Schema.optionalKey<Schema.String>;
+  readonly autocomplete: Schema.optionalKey<Schema.String>;
+  /** A resolved link target, or where this control submits its form. Absent when over-long. */
+  readonly destination: Schema.optionalKey<Schema.String>;
+  readonly formMethod: Schema.optionalKey<Schema.Literals<readonly ["get", "post", "dialog"]>>;
+  readonly box: typeof ViewportRect;
+  readonly placement: Schema.Literals<readonly ["inside", "partial", "outside"]>;
+  /** `self`: the browser finds this control at its visible centre. Not a pixel comparison. */
+  readonly hitTest: Schema.Literals<readonly ["self", "covered", "uncertain", "unsampled"]>;
+  /** Only then is `box` in the main frame's viewport, the space pointer input uses. */
+  readonly mainFrame: Schema.Boolean;
+}>, {}>;
+/**
+ * What a host needs to decide whether a control may be acted on. Host-only: a destination can
+ * carry a token, so none of this is part of the model-facing `Observation`. It never includes a
+ * field's value or any markup.
+ */
+declare class ControlFacts extends ControlFacts_base {}
+declare const Checkpoint_base: Schema.Class<Checkpoint, Schema.Struct<{
+  readonly target: typeof Target;
+  readonly revision: Schema.Natural;
+  readonly url: Schema.String;
+  readonly text: Schema.String;
+  readonly textTruncated: Schema.Boolean;
+  readonly controls: Schema.$Array<typeof ControlFacts>;
+  readonly controlsTruncated: Schema.Boolean;
+  readonly viewport: typeof ViewportEvidence;
+  readonly picture: Schema.optionalKey<Schema.Struct<{
+    readonly mediaType: Schema.Literal<"image/png">;
+    readonly bytes: Schema.Uint8Array;
+  }>>;
+  readonly documentChanged: Schema.Boolean;
+  readonly startedMonotonicNanos: Schema.BigInt;
+  readonly completedMonotonicNanos: Schema.BigInt;
+}>, {}>;
+/**
+ * Passive evidence for a recorder: what was on screen, and optionally a picture of it. It issues
+ * no element references and never replaces the observation an agent's tools act on, so
+ * inspecting, checkpointing and then acting on the inspected node all compose.
+ *
+ * It is host-only, because it carries control facts. Text and picture are read one after the
+ * other, never atomically: the interval says when, and `documentChanged` says the document was
+ * replaced in between, so the two may describe different documents.
+ */
+declare class Checkpoint extends Checkpoint_base {}
+/** Omitted bounds default at admission; `scope` defaults to the whole document. */
+declare const ObservationOptions: Schema.Struct<{
+  readonly maxTextBytes: Schema.optionalKey<Schema.Int>;
+  readonly maxControls: Schema.optionalKey<Schema.Int>;
+  readonly scope: Schema.optionalKey<Schema.Literals<readonly ["document", "viewport"]>>;
+}>;
+type ObservationOptions = typeof ObservationOptions.Type;
+/** A checkpoint always reads the viewport. `picture` adds a PNG of it, within the byte policy. */
+declare const CheckpointOptions: Schema.Struct<{
+  readonly maxTextBytes: Schema.optionalKey<Schema.Int>;
+  readonly maxControls: Schema.optionalKey<Schema.Int>;
+  readonly picture: Schema.optionalKey<Schema.Boolean>;
+}>;
+type CheckpointOptions = typeof CheckpointOptions.Type;
+declare const PointerMoveRequest_base: Schema.Class<PointerMoveRequest, Schema.Struct<{
+  readonly to: typeof ViewportPoint;
+}>, {}>;
+/** One native pointer move. Easing and pacing are the caller's: send the points you want. */
+declare class PointerMoveRequest extends PointerMoveRequest_base {}
+declare const HoverRequest_base: Schema.Class<HoverRequest, Schema.Struct<{
+  readonly selector: Schema.NonEmptyString;
+}>, {}>;
+/** Moves the pointer onto one exact element where it is. It never scrolls to reach it. */
+declare class HoverRequest extends HoverRequest_base {}
+declare const WheelRequest_base: Schema.Class<WheelRequest, Schema.Struct<{
+  readonly deltaX: Schema.Finite;
+  readonly deltaY: Schema.Finite;
+  readonly at: Schema.optionalKey<typeof ViewportPoint>;
+}>, {}>;
+/**
+ * One native wheel event where the pointer is, or at `at` after moving there first. The browser
+ * chooses what scrolls, exactly as it would for a person, so a nested scroll container under
+ * the pointer scrolls instead of the page.
+ */
+declare class WheelRequest extends WheelRequest_base {}
+/**
+ * The keys a `press` may name, spelled as the `KeyboardEvent.key` the page will see. The set is
+ * closed on purpose: a key name is parsed by the native engine, so none reaches it unreviewed.
+ */
+declare const NamedKey: Schema.Literals<readonly ["Enter", "Tab", "Backspace", "Delete", "Escape", "ArrowLeft", "ArrowRight", "ArrowUp", "ArrowDown", "Home", "End", "PageUp", "PageDown"]>;
+type NamedKey = typeof NamedKey.Type;
+declare const KeyModifier: Schema.Literals<readonly ["Shift", "Control", "Alt", "Meta"]>;
+type KeyModifier = typeof KeyModifier.Type;
+/** One key, down then up, with any modifiers held around it. */
+declare const KeyStroke: Schema.Struct<{
+  readonly key: Schema.Union<readonly [Schema.Literals<readonly ["Enter", "Tab", "Backspace", "Delete", "Escape", "ArrowLeft", "ArrowRight", "ArrowUp", "ArrowDown", "Home", "End", "PageUp", "PageDown"]>, Schema.String]>;
+  readonly modifiers: Schema.optionalKey<Schema.$Array<Schema.Literals<readonly ["Shift", "Control", "Alt", "Meta"]>>>;
+}>;
+type KeyStroke = typeof KeyStroke.Type;
+declare const PressRequest_base: Schema.Class<PressRequest, Schema.Struct<{
+  readonly key: Schema.Union<readonly [Schema.Literals<readonly ["Enter", "Tab", "Backspace", "Delete", "Escape", "ArrowLeft", "ArrowRight", "ArrowUp", "ArrowDown", "Home", "End", "PageUp", "PageDown"]>, Schema.String]>;
+  readonly modifiers: Schema.optionalKey<Schema.$Array<Schema.Literals<readonly ["Shift", "Control", "Alt", "Meta"]>>>;
+  readonly into: Schema.optionalKey<Schema.NonEmptyString>;
+}>, {}>;
+/**
+ * One real key stroke. It goes to whatever has focus in the page, exactly as it would for a
+ * person, unless `into` names the one element that must already have it. It never focuses that
+ * element, because that would hide a scripted focus inside a native-input operation: click it
+ * first.
+ */
+declare class PressRequest extends PressRequest_base {}
+declare const TypeRequest_base: Schema.Class<TypeRequest, Schema.Struct<{
+  readonly text: Schema.NonEmptyString;
+  readonly into: Schema.optionalKey<Schema.NonEmptyString>;
+}>, {}>;
+/**
+ * Text as the real key strokes that produce it, two native commands for each character, one
+ * after another under a single action timeout: send a long passage as several shorter runs.
+ * A character the US layout cannot produce is inserted as text, as an input method commits it,
+ * and raises no key events. Control characters are refused, so a line break can never press
+ * Enter from inside a run of text: a named key is always its own `press`. `into` works as it
+ * does for `PressRequest`: a guard on where the text lands, never a focus.
+ */
+declare class TypeRequest extends TypeRequest_base {}
+declare const InputReceipt_base: Schema.Class<InputReceipt, Schema.Struct<{
+  readonly target: typeof Target;
+  readonly kind: Schema.Literals<readonly ["pointer-move", "hover", "wheel", "press", "type"]>;
+  readonly position: Schema.NullOr<typeof ViewportPoint>;
+  readonly delta: Schema.optionalKey<Schema.Struct<{
+    readonly x: Schema.Finite;
+    readonly y: Schema.Finite;
+  }>>;
+  readonly startedMonotonicNanos: Schema.BigInt;
+  readonly completedMonotonicNanos: Schema.BigInt;
+}>, {}>;
+/**
+ * What native input was dispatched, where and when. `position` is the point this owner
+ * commanded, or null when it has not yet placed the pointer on this page. The interval is on
+ * the host monotonic clock that stamps `CapturedFrame.receivedMonotonicNanos`, so input and
+ * pixels share one timeline. A wheel event is dispatched, not awaited: the receipt does not
+ * claim the page finished scrolling, or that any frame shows it. A receipt never says which
+ * key was pressed or what was typed.
+ */
+declare class InputReceipt extends InputReceipt_base {}
+declare const ScreenshotRequest_base: Schema.Class<ScreenshotRequest, Schema.Struct<{
+  readonly fullPage: Schema.Boolean;
+}>, {}>;
+declare class ScreenshotRequest extends ScreenshotRequest_base {}
+declare const NavigationResult_base: Schema.Class<NavigationResult, Schema.Struct<{
+  readonly url: Schema.NonEmptyString;
+}>, {}>;
+declare class NavigationResult extends NavigationResult_base {}
+declare const ActionResult_base: Schema.Class<ActionResult, Schema.Struct<{
+  readonly url: Schema.NonEmptyString;
+}>, {}>;
+declare class ActionResult extends ActionResult_base {}
+declare const TextResult_base: Schema.Class<TextResult, Schema.Struct<{
+  readonly text: Schema.String;
+}>, {}>;
+declare class TextResult extends TextResult_base {}
+declare const ScreenshotResult_base: Schema.Class<ScreenshotResult, Schema.Struct<{
+  readonly mediaType: Schema.Literal<"image/png">;
+  readonly bytes: Schema.Uint8Array;
+}>, {}>;
+declare class ScreenshotResult extends ScreenshotResult_base {}
+declare const InlineFile_base: Schema.Class<InlineFile, Schema.Struct<{
+  readonly name: Schema.NonEmptyString;
+  readonly mediaType: Schema.NonEmptyString;
+  readonly bytes: Schema.Uint8Array;
+}>, {}>;
+/** Small selection is in-memory by design: bytes the caller already holds, never a path. */
+declare class InlineFile extends InlineFile_base {}
+declare const InlineFiles: Schema.$Array<typeof InlineFile>;
+declare const AutomationOptions: Schema.Struct<{
+  readonly actionTimeoutMillis: Schema.optionalKey<Schema.Int>;
+  /** Independent host-only checkpoint/control-facts allowance; normalized to 10,000 by the runtime. */
+  readonly maxHostReads: Schema.optionalKey<Schema.Int>;
+  readonly maxPages: Schema.optionalKey<Schema.Int>;
+  readonly initialPage: Schema.optionalKey<Schema.Union<readonly [Schema.Struct<{
+    readonly targetId: Schema.NonEmptyString;
+  }>, Schema.Struct<{
+    readonly newPage: Schema.Literal<true>;
+  }>]>>;
+  readonly popupPolicy: Schema.optionalKey<Schema.Literals<readonly ["retain", "close", "pause"]>>;
+  readonly dialogPolicy: Schema.optionalKey<Schema.Literals<readonly ["dismiss", "pause"]>>;
+  readonly pageControl: Schema.optionalKey<Schema.Boolean>;
+}>;
+type AutomationOptions = typeof AutomationOptions.Type;
+//#endregion
+export { PositiveInt as A, SessionReason as B, ObservationOptions as C, PageInfo as D, PageExecutionState as E, ScreenshotResult as F, TextResult as G, StartNavigationRequest as H, ScrollRequest as I, ViewportEvidence as J, TypeRequest as K, SelectOptions as L, ReadTextRequest as M, SafeFilename as N, PageSuspension as O, ScreenshotRequest as P, WheelRequest as Q, Selector as R, Observation as S, ObservedElement as T, Target as U, SessionStatus as V, TargetUrl as W, ViewportRect as X, ViewportPoint as Y, WaitForElementRequest as Z, KeyModifier as _, BrowserPolicy as a, NavigateRequest as b, ClickRequest as c, FrameInfo as d, HoverRequest as f, InputReceipt as g, InlineFiles as h, BrowserDiagnostics as i, PressRequest as j, PointerMoveRequest as k, ControlFacts as l, InlineFile as m, AutomationOptions as n, Checkpoint as o, Identifier as p, Viewport as q, BrowserDiagnostic as r, CheckpointOptions as s, ActionResult as t, FillRequest as u, KeyStroke as v, ObservedControl as w, NavigationResult as x, NamedKey as y, SessionPhase as z };
+export {};
+//# sourceMappingURL=BrowserData-DJAnUHoZ.d.mts.map