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

package/dist/Page-B7X6DQUn.d.mts

@@ -0,0 +1,595 @@
+import { p as PolicyDenied, t as BrowserError } from "./BrowserError-Coy7EW1N.mjs";
+import { E as WheelScrolled, S as TextInserted, T as TrackPlanned, _ as PointerReleased, b as Subject, d as Navigated, f as PageClosed, g as PointerPressed, h as PageUntracked, i as BrowserEvent, l as Disconnected, m as PageOpened, o as CursorChanged, p as PageLoaded, s as DialogShown, t as Action, u as KeyChanged, w as TrackPerformed, y as SessionEnding } from "./BrowserEvent-BRu2juEz.mjs";
+import { r as Changes, t as Change } from "./Change-iMlcuzVD.mjs";
+import { a as Image, n as CaptureStats, o as ScreencastOptions, r as Frame } from "./Frame-Di2PxyF7.mjs";
+import { n as Snapshot, r as SnapshotOptions } from "./Snapshot-B34hZ4Jl.mjs";
+import { Duration, Effect, Schema, Stream } from "effect";
+import { Prompt } from "effect/ai";
+import { Page } from "playwright-core";
+declare namespace Moment_d_exports {
+  export { Account, CaptureOptions, Moment, Window, account, capture, toPrompt };
+}
+declare const Window_base: Schema.Class<Window, Schema.Struct<{
+  readonly page: Schema.String;
+  /** Where the window starts, in host monotonic milliseconds on the owning browser’s clock. */
+  readonly since: Schema.Finite;
+  /** Where it ends, never after it was taken. */
+  readonly until: Schema.Finite;
+  /** The page's events after `since`, up to `until`, oldest first, without the input presentation track. */
+  readonly events: Schema.$Array<Schema.Union<readonly [typeof PageOpened, typeof PageClosed, typeof PageUntracked, typeof Navigated, typeof PageLoaded, typeof Action, typeof TrackPlanned, typeof TrackPerformed, typeof PointerPressed, typeof PointerReleased, typeof WheelScrolled, typeof KeyChanged, typeof TextInserted, typeof CursorChanged, typeof DialogShown, typeof Disconnected, typeof SessionEnding]>>;
+  /**
+   * What visibly changed after `since`, up to `until`; absent where `missing` says why. A page's
+   * first window starts its record, so the record sees none of it.
+   */
+  readonly changes: Schema.optional<typeof Changes>;
+  /** Screencast frames painted from `since` to `until`, oldest first, as far back as kept. */
+  readonly frames: Schema.$Array<typeof Frame>;
+  /**
+   * Why each part that could not be read is missing: the read of its changes, by whatever
+   * operation failed there, or a moment's picture (`frame`) or outline (`snapshot`).
+   */
+  readonly missing: Schema.$Array<typeof BrowserError>;
+}>, {}>;
+/** A page's events, changes and frames over one window of its browser's host clock. */
+declare class Window extends Window_base {}
+declare const Moment_base: Schema.Class<Moment, Schema.Struct<{
+  readonly page: Schema.String;
+  readonly since: Schema.Finite;
+  readonly until: Schema.Finite;
+  readonly events: Schema.$Array<Schema.Union<readonly [typeof PageOpened, typeof PageClosed, typeof PageUntracked, typeof Navigated, typeof PageLoaded, typeof Action, typeof TrackPlanned, typeof TrackPerformed, typeof PointerPressed, typeof PointerReleased, typeof WheelScrolled, typeof KeyChanged, typeof TextInserted, typeof CursorChanged, typeof DialogShown, typeof Disconnected, typeof SessionEnding]>>;
+  readonly changes: Schema.optional<typeof Changes>;
+  readonly frames: Schema.$Array<typeof Frame>;
+  readonly missing: Schema.$Array<typeof BrowserError>;
+  snapshot: Schema.optional<typeof Snapshot>;
+}>, Window> & Pick<{}, never>;
+/**
+ * A window that ends at a picture of the page, its last frame, unless `missing` says why it has
+ * none. Its frames are a few, spread over the window, so that it still begins where it starts.
+ */
+declare class Moment extends Moment_base {}
+interface CaptureOptions {
+  /**
+   * Where the window starts, as for `Page.window`: a previous window or moment, so that consecutive
+   * ones neither repeat nor miss an event or a change, or a `Duration` back from the picture.
+   * Defaults to 5 seconds.
+   */
+  readonly since?: WindowOptions["since"] | undefined;
+  /** Frames to keep, at least 1, spread over the window and ending with the picture. Defaults to 2. */
+  readonly frames?: number | undefined;
+  /**
+   * Whether to take the page's outline at the end, or its options; `true` means 4,000 characters.
+   * Defaults to `false`: the frames and the timeline carry most moments, while an outline costs a
+   * round trip to the page and can double a moment's tokens.
+   */
+  readonly snapshot?: SnapshotOptions | boolean | undefined;
+  /** Show what fields hold in the moment's changes; a secret field still reads `••••`. */
+  readonly unmask?: boolean | undefined;
+}
+declare const capture: (page: Page$1, options?: CaptureOptions | undefined) => Effect.Effect<Moment, BrowserError, never>;
+/** What a window says of its page at its end: what was still in flux, and what had settled. */
+interface Account {
+  /**
+   * How long, in milliseconds, the page had been still at the end: since the last change in view
+   * its record shows, or the last paint its screencast frames show, or else since the window, or
+   * its record, began. Undefined where neither could tell, with no record of the window and no
+   * painted frame: a screenshot shows the page, not when it last changed. Frames show paint only
+   * while a capture runs, and the record does not see a canvas, so a canvas that keeps drawing
+   * with no capture running reads as still.
+   */
+  readonly stillFor: number | undefined;
+  /**
+   * The changes still under way at the end: what kept changing, more than once in the window or
+   * already before it, and changed again within twice its own pace before the end.
+   */
+  readonly changing: ReadonlyArray<Change>;
+  /** Every other change, which shows what it settled at. */
+  readonly settled: ReadonlyArray<Change>;
+}
+/**
+ * An account of the window's page at its end: how long it had been still, and which of its
+ * changes were still under way and which had settled. A window whose record saw none of it has
+ * neither.
+ */
+declare const account: (window: Window) => Account;
+/**
+ * The moment as one user message: the page's outline when the moment has one, what changed, most
+ * notable first, what kept changing told as still changing at the moment or settled since when, by
+ * its account, with the actions that the changes followed, that changes followed though none
+ * names them, or that drew what only the screenshots show, what could not be read and why, and its
+ * frames captioned with their times, the last one "the moment" where it is the picture at its end.
+ * Give a model its task with `Prompt.setSystem`, and add what the caller knows about the page as
+ * more text.
+ */
+declare const toPrompt: (moment: Moment) => Prompt.Prompt;
+declare namespace Page_d_exports {
+  export { ChangesOptions, ClickOptions, ElementState, Fact, FindQuery, Found, FrameOptions, InputGuard, InputRequest, Page$1 as Page, Point, PressOptions, ReadyOptions, Region, ResolvedTarget, ScreenshotOptions, ScrollOptions, State, Target, Text, TextOptions, TypeOptions, WaitCondition, WindowOptions, Zoom, correlate, failFast, redacted };
+}
+interface Point {
+  readonly x: number;
+  readonly y: number;
+}
+/** A ref from a snapshot, such as `"e12"`, or a viewport point. */
+type Target = string | Point;
+declare const Region_base: Schema.Class<Region, Schema.Struct<{
+  readonly x: Schema.Int;
+  readonly y: Schema.Int;
+  readonly width: Schema.Int;
+  readonly height: Schema.Int;
+}>, {}>;
+/** An integer rectangle in viewport CSS pixels. */
+declare class Region extends Region_base {}
+declare const Zoom_base: Schema.Class<Zoom, Schema.Struct<{
+  readonly page: Schema.String;
+  readonly region: typeof Region;
+  readonly image: typeof Image;
+}>, {}>;
+/** A crop and its viewport origin: add that origin to a point read from the crop. */
+declare class Zoom extends Zoom_base {}
+declare const ResolvedTarget_base: Schema.Class<ResolvedTarget, Schema.Struct<{
+  readonly point: Schema.Struct<{
+    readonly x: Schema.Finite;
+    readonly y: Schema.Finite;
+  }>;
+  readonly element: Schema.String;
+  /** The element's lowercase tag name. */
+  readonly tag: Schema.String;
+  readonly role: Schema.NullOr<Schema.String>;
+  readonly name: Schema.String;
+  readonly context: Schema.Struct<{
+    readonly row: Schema.optional<Schema.String>;
+    readonly column: Schema.optional<Schema.String>;
+    readonly label: Schema.optional<Schema.String>;
+    readonly heading: Schema.optional<Schema.String>;
+  }>;
+  /** For a point target, the box of what it found there. */
+  readonly box: Schema.optional<Schema.Struct<{
+    readonly x: Schema.Finite;
+    readonly y: Schema.Finite;
+    readonly width: Schema.Finite;
+    readonly height: Schema.Finite;
+  }>>;
+  readonly cursor: Schema.String;
+  readonly href: Schema.optional<Schema.String>;
+}>, {}>;
+/** The target as it read before input. Point coordinates are never snapped to another position. */
+declare class ResolvedTarget extends ResolvedTarget_base {}
+interface ClickOptions {
+  readonly button?: "left" | "right" | "middle" | undefined;
+  /** 2 for a double click. */
+  readonly clickCount?: number | undefined;
+  /** Hold the button down this long before releasing it. */
+  readonly holdMillis?: number | undefined;
+}
+interface TypeOptions {
+  /** Type into this text field: it is focused first, and its content replaced unless `replace` is false. */
+  readonly into?: string | undefined;
+  readonly replace?: boolean | undefined;
+  /** Press Enter afterwards. */
+  readonly submit?: boolean | undefined;
+  /**
+   * The text is a secret: type it only into a field the page marks secret, such as a password,
+   * and otherwise refuse with `NotActionable` before any input. A replayed password asks this.
+   */
+  readonly secret?: boolean | undefined;
+}
+interface PressOptions {
+  /**
+   * Focus this element, by ref, before the first press: a link, a button or a field. The keys go to
+   * whatever has focus otherwise.
+   */
+  readonly on?: string | undefined;
+  /** Press the keys this many times. */
+  readonly times?: number | undefined;
+  /** Hold the keys down this long before releasing them, as a game control might need. */
+  readonly holdMillis?: number | undefined;
+}
+interface ScrollOptions {
+  readonly dx?: number | undefined;
+  /** Pixels to scroll down; negative scrolls up. Defaults to most of a viewport. */
+  readonly dy?: number | undefined;
+  /** Scroll whatever is under this point or element. Defaults to the middle of the viewport. */
+  readonly at?: Target | undefined;
+}
+/**
+ * How current a picture must be. The newest screencast frame serves when it qualifies, at no cost;
+ * otherwise a new screenshot is taken.
+ */
+interface FrameOptions {
+  /**
+   * The oldest a reused frame may be, from its paint, at the earliest its timing allows, to now.
+   * Defaults to 250 milliseconds; 0 always takes a new screenshot.
+   */
+  readonly maxAge?: Duration.Input | undefined;
+  /**
+   * `"input"`: reuse only a frame painted after this page's latest input, including input of an
+   * interrupted action, and never while an action is changing the page. For a caller that has
+   * just acted on the page.
+   */
+  readonly after?: "input" | undefined;
+}
+/** A screenshot reuses only a frame painted after the page's latest input, as `after: "input"`. */
+interface ScreenshotOptions {
+  /** The oldest a reused frame may be, as for `frame`. Defaults to 250 milliseconds. */
+  readonly maxAge?: Duration.Input | undefined;
+  /** A region of the viewport, captured in CSS pixels at the viewport's own scale; always new. */
+  readonly clip?: {
+    readonly x: number;
+    readonly y: number;
+    readonly width: number;
+    readonly height: number;
+  } | undefined;
+  /** JPEG quality, 0 to 100. Defaults to 80. */
+  readonly quality?: number | undefined;
+  /** `"jpeg"`, the default, or `"png"`, which is always a new picture. */
+  readonly format?: "jpeg" | "png" | undefined;
+}
+/**
+ * What `find` looks for. Every rule given must hold; with none, it finds every element in scope
+ * that has a role or is a control.
+ */
+interface FindQuery {
+  /** An ARIA role, such as `"button"` or `"heading"`, ignoring case. */
+  readonly role?: string | undefined;
+  /**
+   * The accessible name: a string that reads the same once spaces are collapsed and case folded,
+   * or a pattern found in it.
+   */
+  readonly name?: string | RegExp | undefined;
+  /**
+   * Text it shows, ignoring case and spacing, or a pattern. Text inside a control or a heading is
+   * that control's or heading's, and only the smallest element showing it matches, not every
+   * element around it.
+   */
+  readonly text?: string | RegExp | undefined;
+  /** Whole words in its context (row, column, label or heading), ignoring case and spacing. */
+  readonly near?: string | undefined;
+  /** Only what a point action at this viewport point would reach: the control there, or else what is painted there. */
+  readonly at?: Point | undefined;
+  /** The viewport (the default), or the whole document. */
+  readonly scope?: "viewport" | "document" | undefined;
+}
+/**
+ * An element's state as its markup gives it: `checked` for what can be checked, `expanded`,
+ * `selected` and `pressed` where the page says either way, and `level` for headings.
+ */
+declare const ElementState: Schema.Struct<{
+  readonly disabled: Schema.Boolean;
+  readonly focused: Schema.Boolean;
+  readonly checked: Schema.optional<Schema.Boolean>;
+  readonly expanded: Schema.optional<Schema.Boolean>;
+  readonly selected: Schema.optional<Schema.Boolean>;
+  readonly pressed: Schema.optional<Schema.Boolean>;
+  readonly level: Schema.optional<Schema.Int>;
+}>;
+type ElementState = typeof ElementState.Type;
+declare const Found_base: Schema.Class<Found, Schema.Struct<{
+  readonly ref: Schema.String;
+  readonly subject: typeof Subject;
+  /** Its box, rounded. Reading the document, it may be out of view. */
+  readonly box: Schema.Struct<{
+    readonly x: Schema.Finite;
+    readonly y: Schema.Finite;
+    readonly width: Schema.Finite;
+    readonly height: Schema.Finite;
+  }>;
+  readonly inViewport: Schema.Boolean;
+  readonly state: Schema.Struct<{
+    readonly disabled: Schema.Boolean;
+    readonly focused: Schema.Boolean;
+    readonly checked: Schema.optional<Schema.Boolean>;
+    readonly expanded: Schema.optional<Schema.Boolean>;
+    readonly selected: Schema.optional<Schema.Boolean>;
+    readonly pressed: Schema.optional<Schema.Boolean>;
+    readonly level: Schema.optional<Schema.Int>;
+  }>;
+}>, {}>;
+/** An element `find` found: a ref for the actions, what it is, where it is and its state. */
+declare class Found extends Found_base {}
+interface TextOptions {
+  /** `"viewport"` (the default) reads what the viewport shows; a ref reads that element whole. */
+  readonly scope?: string | undefined;
+  /** Bound on the text's length, cut at a line. Defaults to 12,000 characters. */
+  readonly maxChars?: number | undefined;
+  /** Show what fields hold; a secret field still reads `••••`. Defaults to false. */
+  readonly unmask?: boolean | undefined;
+}
+declare const Text_base: Schema.Class<Text, Schema.Struct<{
+  readonly url: Schema.String;
+  readonly title: Schema.String;
+  readonly text: Schema.String;
+  /** True when `text` was cut at `maxChars`. */
+  readonly truncated: Schema.Boolean;
+  /** Host monotonic milliseconds from the browser's captured Effect Clock. */
+  readonly at: Schema.Finite;
+}>, {}>;
+/** What a page showed as text: a line per block, with table cells apart by tabs. */
+declare class Text extends Text_base {}
+/** What `waitFor` waits for. */
+interface WaitCondition {
+  /** A CSS selector for what to watch; the document's body without one. */
+  readonly selector?: string | undefined;
+  /**
+   * `"visible"` (the default): something it matches shows; `"hidden"`: nothing it matches shows;
+   * `"enabled"`: something it matches shows and is not disabled.
+   */
+  readonly state?: "visible" | "hidden" | "enabled" | undefined;
+  /** Only what shows this text counts, case and all, with runs of spaces read as one. */
+  readonly text?: string | undefined;
+}
+interface ReadyOptions {
+  /** What must stay still during quietMillis: screen paint (default), or recorded content. */
+  readonly still?: "screen" | "content" | undefined;
+  /** How long the selected evidence must stay still; screen paint by default. */
+  readonly quietMillis?: number | undefined;
+  readonly timeout?: Duration.Input | undefined;
+}
+/** The window `changes` reads, and whether to show what fields hold. */
+interface ChangesOptions {
+  /**
+   * Where the window starts: the changes a previous read returned, to continue exactly where they
+   * ended; a frame, at its paint; or host monotonic milliseconds, which mapped to the page's clock
+   * may miss or repeat changes near the start if the browser's clock mapping changed since. Defaults
+   * to the start of the record.
+   */
+  readonly since?: Changes | Frame | number | undefined;
+  /**
+   * Where it ends: a frame, at its paint, so a delayed frame's window holds nothing it does not
+   * show; or host monotonic milliseconds. Defaults to now, and is never later.
+   */
+  readonly until?: Frame | number | undefined;
+  /** Show what fields hold; a secret field still reads `••••`. Defaults to false. */
+  readonly unmask?: boolean | undefined;
+}
+/** The window `window` reads, and whether to show what fields hold. */
+interface WindowOptions {
+  /**
+   * Where the window starts: a previous window, to continue exactly where it ended; a frame, at its
+   * paint; host monotonic milliseconds; or a `Duration` back from `until`. A start after `until`
+   * leaves the window empty there.
+   */
+  readonly since: Window | Frame | Duration.Duration | number;
+  /**
+   * Where it ends: a frame, at its paint, such as one a delayed consumer airs now; or host
+   * monotonic milliseconds. Defaults to now, and is never later.
+   */
+  readonly until?: Frame | number | undefined;
+  /** Show what fields hold in its changes; a secret field still reads `••••`. Defaults to false. */
+  readonly unmask?: boolean | undefined;
+}
+declare const State_base: Schema.Class<State, Schema.Struct<{
+  readonly page: Schema.String;
+  /** When this was taken. */
+  readonly at: Schema.Finite;
+  /** Where the main frame last committed or moved, without userinfo or known secret parameters. */
+  readonly url: Schema.String;
+  /** The page's document, as `Navigated` counts them. */
+  readonly document: Schema.Int;
+  /** When the main frame committed it; absent for the one the browser began tracking it with. */
+  readonly committedAt: Schema.optional<Schema.Finite>;
+  /** How far that document has loaded, as the page's own session heard; absent until parsed. */
+  readonly load: Schema.optional<typeof PageLoaded>;
+  /** The newest screencast frame, of whichever document it names. */
+  readonly frame: Schema.optional<typeof Frame>;
+  /** The viewport's text as it was last read, with the page's title then. */
+  readonly text: Schema.optional<typeof Text>;
+}>, {}>;
+/**
+ * What the library knows of a page now, without asking it, each part with when it learned it, in
+ * host monotonic milliseconds: a part's age is `at` less its time. Text read before the current
+ * document began is left out, since it tells of a document that has gone.
+ */
+declare class State extends State_base {}
+/**
+ * What the page's structure establishes about an input, or says it cannot establish:
+ *
+ * - `form-submit`: it submits a form, which sends the form's fields.
+ * - `cross-origin`: it navigates or submits to another origin.
+ * - `download`: it follows a download link.
+ * - `upload`: it opens a file chooser.
+ * - `secret`: it types, with `type`, into a field marked as a password, a one-time code or a
+ *   card's number, code or expiry, or submits a form holding a filled one.
+ * - `scripted`: it activates something the browser gives no effect of its own, such as a
+ *   `type="button"` button, a `role="button"` element or a canvas, so only the page's script
+ *   decides what happens.
+ * - `opaque`: nothing names what receives it: a canvas, a frame or an unnamed element.
+ *
+ * Facts never come from what an element's text says. What an input means, such as a payment
+ * or a deletion, takes a judge that reads the evidence in the {@link InputRequest}.
+ */
+declare const Fact: Schema.Literals<readonly ["form-submit", "cross-origin", "download", "upload", "secret", "scripted", "opaque"]>;
+type Fact = typeof Fact.Type;
+declare const InputRequest_base: Schema.Class<InputRequest, Schema.Struct<{
+  readonly page: Schema.String;
+  /**
+   * The page's URL, without a fragment that only names a place on the page. This and the other
+   * addresses keep no userinfo or known secret parameters.
+   */
+  readonly url: Schema.String;
+  /** The page's title, at most 120 characters. */
+  readonly title: Schema.String;
+  readonly action: Schema.String;
+  readonly target: Schema.optional<Schema.String>;
+  readonly element: Schema.optional<Schema.String>;
+  /** Literal pixel targets only; ref coordinates are resolved after the policy allows them. */
+  readonly point: Schema.optional<Schema.Struct<{
+    readonly x: Schema.Finite;
+    readonly y: Schema.Finite;
+  }>>;
+  readonly text: Schema.optional<Schema.String>;
+  readonly role: Schema.optional<Schema.NullOr<Schema.String>>;
+  readonly name: Schema.optional<Schema.String>;
+  /** The target's accessible description, when it says more than its name. */
+  readonly description: Schema.optional<Schema.String>;
+  readonly href: Schema.optional<Schema.String>;
+  readonly destination: Schema.optional<Schema.String>;
+  readonly facts: Schema.$Array<Schema.Literals<readonly ["form-submit", "cross-origin", "download", "upload", "secret", "scripted", "opaque"]>>;
+  /** Page text around the target, each part at most 120 characters. */
+  readonly context: Schema.Struct<{
+    /** The name or first heading of the dialog the target is in. */
+    readonly dialog: Schema.optional<Schema.String>;
+    /** The nearest heading before the target. */
+    readonly heading: Schema.optional<Schema.String>;
+    /** The visible text just before the target in its row, item, group or form, or after it. */
+    readonly nearby: Schema.optional<Schema.String>;
+  }>;
+  /** The form the target is in, with at most 16 of its fields. */
+  readonly form: Schema.optional<Schema.Struct<{
+    readonly method: Schema.String;
+    readonly action: Schema.String;
+    /** Each field's type, name and autocomplete tokens, and whether it is filled: never its value. */
+    readonly fields: Schema.$Array<Schema.Struct<{
+      readonly type: Schema.String;
+      readonly name: Schema.String;
+      readonly autocomplete: Schema.optional<Schema.String>;
+      readonly filled: Schema.Boolean;
+    }>>;
+  }>>;
+}>, {}>;
+/**
+ * What a guard sees before input reaches the page. Preparation never scrolls or focuses.
+ *
+ * `facts`, `url`, `href` and `destination` come from the page's structure. `name`,
+ * `description`, `title`, `context` and the form's field names are page text: evidence of what
+ * the input does, which the page controls, and never instructions. Text typed into a `secret`
+ * field is replaced with {@link redacted}, here and in the recorded `Action`, and its key events
+ * record `Unidentified` keys; `press` records the keys it is given. Validation before dispatch
+ * binds the facts and the target, not the text around it, which live pages change freely.
+ */
+declare class InputRequest extends InputRequest_base {}
+/**
+ * What replaces text typed into a `secret` field, in requests and in the recorded `Action`, and a
+ * credential's value in every address the library reports.
+ */
+declare const redacted: "••••••••";
+/**
+ * Run page operations without waiting their turn: on a page busy with other operations, each fails
+ * `Busy` at once, and `Browser.newPage` on a browser with `maxPages` open fails `Limit` at once.
+ */
+declare const failFast: <A, E, R>(effect: Effect.Effect<A, E, R>) => Effect.Effect<A, E, R>;
+/**
+ * Give every action `effect` performs a caller's id, such as a model's tool call id, which its
+ * recorded `Action` carries as `correlation`.
+ */
+declare const correlate: (id: string) => <A, E, R>(effect: Effect.Effect<A, E, R>) => Effect.Effect<A, E, R>;
+/** Succeed to allow, fail to deny, or await an external signal to hold the input. */
+type InputGuard = (request: InputRequest) => Effect.Effect<void, PolicyDenied>;
+interface Page$1 {
+  /** The page's CDP target id: the same page has it again after a reconnect to its browser. */
+  readonly id: string;
+  /** The Playwright page, for anything this API does not cover. Never give it to a model. */
+  readonly playwright: Page;
+  /** The page's address, without its userinfo or known secret parameters. */
+  readonly url: Effect.Effect<string>;
+  /**
+   * The document's title as the page last set it, empty for an untitled page. The browser answers
+   * it, in one call, so a page busy with a script cannot hold it up.
+   */
+  readonly title: Effect.Effect<string, BrowserError>;
+  readonly goto: (url: string) => Effect.Effect<void, BrowserError>;
+  /** The previous history entry, including one only a frame created; `NotFound` when none. */
+  readonly back: Effect.Effect<void, BrowserError>;
+  readonly reload: Effect.Effect<void, BrowserError>;
+  /** Make this the visible tab. Background tabs paint rarely and send few screencast frames. */
+  readonly bringToFront: Effect.Effect<void, BrowserError>;
+  /** Close the tab, succeeding once it has closed, or at once when it already had. */
+  readonly close: Effect.Effect<void, BrowserError>;
+  readonly snapshot: (options?: SnapshotOptions) => Effect.Effect<Snapshot, BrowserError>;
+  /**
+   * A picture of the viewport, in CSS pixels: a screencast frame painted since the page's latest
+   * input, if one qualifies, or a new one. A caller that has just acted sees what its action did.
+   */
+  readonly screenshot: (options?: ScreenshotOptions) => Effect.Effect<Image, BrowserError>;
+  /**
+   * The viewport with its timing: the newest screencast frame if it qualifies, else a new
+   * screenshot timed by the host interval in which it was taken.
+   */
+  readonly frame: (options?: FrameOptions) => Effect.Effect<Frame, BrowserError>;
+  /** A crop in CSS pixels, unmagnified, with the origin that keeps later input in viewport pixels. */
+  readonly zoom: (region: Region) => Effect.Effect<Zoom, BrowserError>;
+  /**
+   * The viewport's size in CSS pixels, the space of points, crops and page scrolls. Over CDP the
+   * page reports it, within the action timeout.
+   */
+  readonly viewport: Effect.Effect<{
+    readonly width: number;
+    readonly height: number;
+  }, BrowserError>;
+  /**
+   * The elements that match a query, in tree order, with refs the actions take, in one call to the
+   * page. All that match are returned, so a caller tells them apart by their context; none is an
+   * empty result, not a failure.
+   */
+  readonly find: (query?: FindQuery) => Effect.Effect<ReadonlyArray<Found>, BrowserError>;
+  /**
+   * The text the viewport shows, or one element whole, in one call to the page. Field values read
+   * `••••` unless `unmask`, and a secret field's always do, as does one that was secret when the
+   * library saw it.
+   */
+  readonly text: (options?: TextOptions) => Effect.Effect<Text, BrowserError>;
+  /**
+   * What visibly changed over a window, in one call to the page. The first read starts the page's
+   * record, so it finds none; from then the page records, and from the start of each later
+   * document, until nobody has read it for two minutes. See `Change`.
+   */
+  readonly changes: (options?: ChangesOptions) => Effect.Effect<Changes, BrowserError>;
+  /**
+   * The page's events, changes and frames over a window: the frames and events it keeps, at no
+   * call, and its changes, in one call, the first starting its record as `changes` does. A part
+   * that cannot be read is missing, with why; the window fails only for bounds that are not finite.
+   */
+  readonly window: (options: WindowOptions) => Effect.Effect<Window, BrowserError>;
+  /**
+   * What the library knows of the page now, at no call and with no wait for its turn: where it is,
+   * its document and how far it has loaded, its newest frame, and its text and title as last read.
+   */
+  readonly state: Effect.Effect<State>;
+  readonly click: (target: Target, options?: ClickOptions) => Effect.Effect<ResolvedTarget, BrowserError>;
+  readonly hover: (target: Target) => Effect.Effect<void, BrowserError>;
+  readonly drag: (from: Target, to: Target) => Effect.Effect<void, BrowserError>;
+  /** Type into a text field, or to whatever has focus unless a typed key could activate it. */
+  readonly type: (text: string, options?: TypeOptions) => Effect.Effect<void, BrowserError>;
+  /** Keys such as `"Enter"`, `"Space"`, `"ArrowLeft"` or `"Control+A"`. */
+  readonly press: (keys: string, options?: PressOptions) => Effect.Effect<void, BrowserError>;
+  readonly scroll: (options?: ScrollOptions) => Effect.Effect<void, BrowserError>;
+  /**
+   * Choose options of a `<select>` by value or label; returns the chosen labels. A refusal, such
+   * as no matching option, is undispatched.
+   */
+  readonly select: (ref: string, values: ReadonlyArray<string>) => Effect.Effect<string, BrowserError>;
+  /**
+   * Wait until a condition holds, in one call that the page answers as it comes, looking every
+   * 100 ms, or `Timeout` after `timeout`, 10 seconds by default. A selector that is not CSS is an
+   * `InvalidRequest`.
+   */
+  readonly waitFor: (condition: WaitCondition, timeout?: Duration.Input) => Effect.Effect<void, BrowserError>;
+  /**
+   * Wait until the page is ready to be shown, asking the page every 100 ms: its document is parsed
+   * and has painted since, nothing that ends is animating in view, its fonts and the images in
+   * view have loaded, and the viewport shows something. With `quietMillis`, the screen must then
+   * also stay still that long: nothing in view changed, where the page's changes are recorded, and
+   * no frame comes, counted from the first frame of a capture the wait starts itself. A canvas
+   * that keeps drawing, such as a live chart, is never still, and a page
+   * is never ready without a painted frame, as a hidden tab may be. `Timeout` after `timeout`,
+   * 15 seconds by default.
+   */
+  readonly ready: (options?: ReadyOptions) => Effect.Effect<void, BrowserError>;
+  /**
+   * Screencast frames for as long as the stream runs. Concurrent streams share one screencast and
+   * its settings; explicit options that differ from a running screencast's fail with InvalidRequest.
+   */
+  readonly screencast: (options?: ScreencastOptions) => Stream.Stream<Frame, BrowserError>;
+  /**
+   * What this page's captures received, delivered and dropped, over its life or the latest
+   * `window`, which reaches back at most a minute; a longer one is an `InvalidRequest`.
+   */
+  readonly captureStats: (options?: {
+    readonly window?: Duration.Input | undefined;
+  }) => Effect.Effect<CaptureStats, BrowserError>;
+  /** Screencast frames painted within `frameHistory` of the newest, oldest first. */
+  readonly recentFrames: Effect.Effect<ReadonlyArray<Frame>>;
+  /** This page's events among the browser's latest `eventHistory`, oldest first. */
+  readonly recentEvents: Effect.Effect<ReadonlyArray<BrowserEvent>>;
+}
+//#endregion
+export { Account as A, TypeOptions as C, correlate as D, Zoom as E, account as F, capture as I, toPrompt as L, Moment as M, Moment_d_exports as N, failFast as O, Window as P, TextOptions as S, WindowOptions as T, ScreenshotOptions as _, FindQuery as a, Target as b, InputGuard as c, Page_d_exports as d, Point as f, ResolvedTarget as g, Region as h, Fact as i, CaptureOptions as j, redacted as k, InputRequest as l, ReadyOptions as m, ClickOptions as n, Found as o, PressOptions as p, ElementState as r, FrameOptions as s, ChangesOptions as t, Page$1 as u, ScrollOptions as v, WaitCondition as w, Text as x, State as y };
+//# sourceMappingURL=Page-B7X6DQUn.d.mts.map

package/dist/Page.d.mts

@@ -0,0 +1,2 @@
+import { C as TypeOptions, D as correlate, E as Zoom, O as failFast, S as TextOptions, T as WindowOptions, _ as ScreenshotOptions, a as FindQuery, b as Target, c as InputGuard, f as Point, g as ResolvedTarget, h as Region, i as Fact, k as redacted, l as InputRequest, m as ReadyOptions, n as ClickOptions, o as Found, p as PressOptions, r as ElementState, s as FrameOptions, t as ChangesOptions, u as Page, v as ScrollOptions, w as WaitCondition, x as Text, y as State } from "./Page-B7X6DQUn.mjs";
+export { ChangesOptions, ClickOptions, ElementState, Fact, FindQuery, Found, FrameOptions, InputGuard, InputRequest, Page, Point, PressOptions, ReadyOptions, Region, ResolvedTarget, ScreenshotOptions, ScrollOptions, State, Target, Text, TextOptions, TypeOptions, WaitCondition, WindowOptions, Zoom, correlate, failFast, redacted };

package/dist/Page.mjs

@@ -0,0 +1,2 @@
+import { c as State, d as correlate, f as failFast, i as InputRequest, l as Text, n as Fact, o as Region, p as redacted, r as Found, s as ResolvedTarget, t as ElementState, u as Zoom } from "./Page-B5cjaUp5.mjs";
+export { ElementState, Fact, Found, InputRequest, Region, ResolvedTarget, State, Text, Zoom, correlate, failFast, redacted };