effect-browser 0.2.0-beta.8 → 0.3.0-beta.5

package/dist/BrowserData-CPIIIHol.d.mts

@@ -1,585 +0,0 @@
-import { BrowserError } from "./Errors.mjs";
-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", "page-contained"]>;
-type SessionReason = typeof SessionReason.Type;
-declare const Inventory_base: Schema.Class<Inventory, Schema.Struct<{
-  readonly generation: Schema.Natural;
-  readonly pages: Schema.$Array<typeof PageInfo>;
-}>, {}>;
-/**
- * Bounded fresh metadata from one owner generation. Native URL/title reads are non-atomic.
- * PageInfo is data; callers must acquire an issued Page and observe it explicitly before input.
- * The separate pages lifecycle stream attaches its cached registry snapshot and cursor atomically.
- */
-declare class Inventory extends Inventory_base {}
-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", "page-contained"]>>;
-  readonly generation: Schema.Natural;
-  readonly busy: Schema.Boolean;
-  readonly unresolvedDispatch: Schema.Boolean;
-  /**
-   * Actions admitted against the policy's `maxActions`, as the owner counted them. Host reads
-   * (`checkpoint`, `controlFacts`) and uncharged reads such as a form's verification are not
-   * actions. `used` equals `maximum` once the allowance is spent; the owner stays open.
-   */
-  readonly actions: Schema.Struct<{
-    readonly used: Schema.Natural;
-    readonly maximum: Schema.Int;
-  }>;
-}>, {}>;
-/** 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", "page-contained"]>;
-  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 {}
-/**
- * The read frame's root document scroll geometry, sampled in CSS pixels with the reading.
- * Offsets can be negative (for example RTL); dimensions are the scrolling element's measured
- * scrollWidth/Height and clientWidth/Height. They do not describe a nested scrolling container
- * or expose unseen text, and do not establish a scroll direction or an end-of-document condition.
- */
-declare const DocumentScroll: Schema.Struct<{
-  readonly x: Schema.Finite;
-  readonly y: Schema.Finite;
-  readonly scrollWidth: Schema.Natural;
-  readonly scrollHeight: Schema.Natural;
-  readonly clientWidth: Schema.Natural;
-  readonly clientHeight: Schema.Natural;
-}>;
-type DocumentScroll = typeof DocumentScroll.Type;
-declare const ViewportEvidence_base: Schema.Class<ViewportEvidence, Schema.Struct<{
-  readonly width: Schema.Finite;
-  readonly height: Schema.Finite;
-  /** Absent when the document has no scrolling element, or in older/scripted readings. */
-  readonly documentScroll: Schema.optionalKey<Schema.Struct<{
-    readonly x: Schema.Finite;
-    readonly y: Schema.Finite;
-    readonly scrollWidth: Schema.Natural;
-    readonly scrollHeight: Schema.Natural;
-    readonly clientWidth: Schema.Natural;
-    readonly clientHeight: Schema.Natural;
-  }>>;
-  /** Text that crossed a viewport edge; only its lines on screen were kept. */
-  readonly clippedText: Schema.Natural;
-  /** Left out: another element is on top at the sampled point, or a box there paints over it. */
-  readonly coveredText: Schema.Natural;
-  /**
-   * Left out: something that takes no pointer events lies over it and the browser's own hit test
-   * could not settle whether it paints there, for example beneath another such box, in a child
-   * frame, or after too many such points in one reading.
-   */
-  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, what it left out, and its document scroll geometry. These
- * counts and measured layout facts can be shown to 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. Something that takes no pointer events is invisible to that test, so the
- * browser is asked what is on top there with pointer events ignored: a box that paints at the
- * point covers the text, and one that paints nothing there, such as an empty full-screen
- * container, does not. Text that could not be settled that way is left out as uncertain.
- */
-declare class ViewportEvidence extends ViewportEvidence_base {}
-/**
- * Case-insensitive text a reading keeps. It is applied inside the page before any limit, so
- * matching controls are not crowded out by earlier ones. It filters what is read; it never
- * searches for, re-finds or substitutes a node.
- */
-declare const ReadingMatch: Schema.String;
-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 match: Schema.optionalKey<Schema.String>;
-  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. A reading with `match` keeps only
- * matching text lines and controls, so what it leaves out is not evidence of absence. 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.TaggedStruct<"Unrestricted", {}>;
-  /** Model-reachable actions for the session's lifetime, 1–1,000,000. `status.actions` reads use. */
-  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. A long session raises `maxActions`
-   * (up to 1,000,000) and `maxElapsedMillis` (up to six hours) together.
-   */
-  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 {}
-/**
- * One observed control and the one state a form gives it: replacement text, the checked state a
- * checkbox, radio or switch should end in (it is clicked only when it differs, and a native radio
- * is never asked to clear itself), or issued option IDs of a native select from the same
- * observation.
- */
-declare const FormField: Schema.Struct<{
-  readonly elementId: Schema.NonEmptyString;
-  readonly value: Schema.optionalKey<Schema.String>;
-  readonly checked: Schema.optionalKey<Schema.Boolean>;
-  readonly options: Schema.optionalKey<Schema.$Array<Schema.NonEmptyString>>;
-}>;
-type FormField = typeof FormField.Type;
-declare const FillFormRequest_base: Schema.Class<FillFormRequest, Schema.Struct<{
-  readonly observationId: Schema.NonEmptyString;
-  readonly fields: Schema.$Array<Schema.Struct<{
-    readonly elementId: Schema.NonEmptyString;
-    readonly value: Schema.optionalKey<Schema.String>;
-    readonly checked: Schema.optionalKey<Schema.Boolean>;
-    readonly options: Schema.optionalKey<Schema.$Array<Schema.NonEmptyString>>;
-  }>>;
-  readonly submit: Schema.optionalKey<Schema.NonEmptyString>;
-}>, {}>;
-/** At most 32 distinct fields, and a submit control that is not one of them. */
-declare class FillFormRequest extends FillFormRequest_base {}
-/**
- * Host choices about how a form proceeds. `verify` (default true) re-reads every field before
- * submit and stops when one no longer holds what its own step left there. `settleMillis`
- * (default 50, at most 5000; 0 skips it) is how long each dispatched step lets the page's own
- * handlers run, after at least two rendered frames, before its result is read back.
- */
-declare const FillFormOptions: Schema.Struct<{
-  readonly verify: Schema.optionalKey<Schema.Boolean>;
-  readonly settleMillis: Schema.optionalKey<Schema.Int>;
-}>;
-type FillFormOptions = typeof FillFormOptions.Type;
-declare const FormStop_base: Schema.Class<FormStop, Schema.Struct<{
-  readonly stage: Schema.Literals<readonly ["field", "verify", "submit"]>;
-  readonly elementId: Schema.optionalKey<Schema.NonEmptyString>;
-  readonly error: typeof BrowserError;
-}>, {}>;
-/**
- * Where a form stopped and why. `error.outcome` says whether this step itself was dispatched;
- * nothing after it was. `elementId` names the control it stopped at, when there is one: a
- * verification that could not read the form at all names none.
- */
-declare class FormStop extends FormStop_base {}
-declare const ScrollRequest_base: Schema.Class<ScrollRequest, Schema.Struct<{
-  readonly deltaX: Schema.Int;
-  readonly deltaY: Schema.Int;
-}>, {}>;
-/**
- * What a form did, in order. `stopped` is present when it did not finish: the fields before it
- * stay set, because a form is not a transaction. `submitted` is true only when the submit click
- * completed; a stop at `submit` with an `unknown` outcome may have sent it.
- */
-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"]>>;
-  readonly match: Schema.optionalKey<Schema.String>;
-}>;
-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, with ordered native commands submitted in
- * bounded windows under a single action timeout. An interrupted run is never replayed.
- * 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. The exact node is
- * checked before subsequent windows; already submitted input cannot be recalled on focus loss.
- */
-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", "click", "press", "type"]>;
-  readonly position: Schema.NullOr<typeof ViewportPoint>;
-  readonly intended: Schema.optionalKey<Schema.Struct<{
-    readonly position: typeof ViewportPoint;
-    readonly relativePosition: typeof ViewportPoint;
-    readonly qualification: Schema.Literal<"checked-exact-node-sample">;
-  }>>;
-  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, null before it has placed the pointer, or unknown when Playwright chose the click
- * point internally. For clicks, the interval brackets Playwright's supported click call, which
- * can include its actionability and navigation waits; the browser's exact dispatch instant is
- * unavailable. 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 FormFieldResult_base: Schema.Class<FormFieldResult, Schema.Struct<{
-  readonly elementId: Schema.NonEmptyString;
-  readonly status: Schema.Literals<readonly ["set", "unchanged"]>;
-  readonly input: Schema.optionalKey<typeof InputReceipt>;
-}>, {}>;
-/** `set` dispatched input; `unchanged` needed none, because a toggle already held its state. */
-declare class FormFieldResult extends FormFieldResult_base {}
-declare const FillFormResult_base: Schema.Class<FillFormResult, Schema.Struct<{
-  readonly fields: Schema.$Array<typeof FormFieldResult>;
-  readonly submitted: Schema.Boolean;
-  readonly url: Schema.NonEmptyString;
-  readonly submitInput: Schema.optionalKey<typeof InputReceipt>;
-  readonly stopped: Schema.optionalKey<typeof FormStop>;
-}>, {}>;
-/** The bounded receipts for any toggle clicks and the one optional submit click. */
-declare class FillFormResult extends FillFormResult_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;
-  /** Present for clicks; fill and scripted scroll results have no native input receipt. */
-  readonly input: Schema.optionalKey<typeof InputReceipt>;
-}>, {}>;
-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 AdmissionLimits: Schema.Struct<{
-  readonly pendingPerPage: Schema.optionalKey<Schema.Int>;
-  readonly pendingPerSession: Schema.optionalKey<Schema.Int>;
-}>;
-type AdmissionLimits = typeof AdmissionLimits.Type;
-/** Finite metadata retention and subscriber resources; native capture bytes have separate limits. */
-declare const TimelineLimits: Schema.Struct<{
-  readonly maxDurationMillis: Schema.optionalKey<Schema.Int>;
-  readonly maxEvents: Schema.optionalKey<Schema.Int>;
-  readonly maxBytes: Schema.optionalKey<Schema.Int>;
-  readonly maxSubscribers: Schema.optionalKey<Schema.Int>;
-  readonly maxEventBytes: Schema.optionalKey<Schema.Int>;
-}>;
-type TimelineLimits = typeof TimelineLimits.Type;
-declare const AutomationOptions: Schema.Struct<{
-  readonly timelineLimits: Schema.optionalKey<Schema.Struct<{
-    readonly maxDurationMillis: Schema.optionalKey<Schema.Int>;
-    readonly maxEvents: Schema.optionalKey<Schema.Int>;
-    readonly maxBytes: Schema.optionalKey<Schema.Int>;
-    readonly maxSubscribers: Schema.optionalKey<Schema.Int>;
-    readonly maxEventBytes: Schema.optionalKey<Schema.Int>;
-  }>>;
-  readonly admissionLimits: Schema.optionalKey<Schema.Struct<{
-    readonly pendingPerPage: Schema.optionalKey<Schema.Int>;
-    readonly pendingPerSession: Schema.optionalKey<Schema.Int>;
-  }>>;
-  readonly observationLimits: Schema.optionalKey<Schema.Struct<{
-    readonly maxSnapshotsPerPage: Schema.Int;
-    readonly maxSnapshotsPerSession: Schema.Int;
-    readonly maxHandlesPerPage: Schema.Int;
-    readonly maxHandlesPerSession: Schema.Int;
-    readonly maxBytesPerPage: Schema.Int;
-    readonly maxBytesPerSession: Schema.Int;
-  }>>;
-  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 { Target as $, NavigationResult as A, PressRequest as B, InlineFiles as C, KeyStroke as D, KeyModifier as E, PageExecutionState as F, ScreenshotResult as G, ReadingMatch as H, PageInfo as I, Selector as J, ScrollRequest as K, PageSuspension as L, ObservationOptions as M, ObservedControl as N, NamedKey as O, ObservedElement as P, StartNavigationRequest as Q, PointerMoveRequest as R, InlineFile as S, Inventory as T, SafeFilename as U, ReadTextRequest as V, ScreenshotRequest as W, SessionReason as X, SessionPhase as Y, SessionStatus as Z, FormFieldResult as _, BrowserDiagnostics as a, ViewportEvidence as at, HoverRequest as b, CheckpointOptions as c, WaitForElementRequest as ct, DocumentScroll as d, TargetUrl as et, FillFormOptions as f, FormField as g, FillRequest as h, BrowserDiagnostic as i, Viewport as it, Observation as j, NavigateRequest as k, ClickRequest as l, WheelRequest as lt, FillFormResult as m, AdmissionLimits as n, TimelineLimits as nt, BrowserPolicy as o, ViewportPoint as ot, FillFormRequest as p, SelectOptions as q, AutomationOptions as r, TypeRequest as rt, Checkpoint as s, ViewportRect as st, ActionResult as t, TextResult as tt, ControlFacts as u, FormStop as v, InputReceipt as w, Identifier as x, FrameInfo as y, PositiveInt as z };
-export {};
-//# sourceMappingURL=BrowserData-CPIIIHol.d.mts.map

package/dist/BrowserData.d.mts

@@ -1,3 +0,0 @@
-import { $ as Target, A as NavigationResult, B as PressRequest, C as InlineFiles, D as KeyStroke, E as KeyModifier, F as PageExecutionState, G as ScreenshotResult, H as ReadingMatch, I as PageInfo, J as Selector, K as ScrollRequest, L as PageSuspension, M as ObservationOptions, N as ObservedControl, O as NamedKey, P as ObservedElement, Q as StartNavigationRequest, R as PointerMoveRequest, S as InlineFile, T as Inventory, U as SafeFilename, V as ReadTextRequest, W as ScreenshotRequest, X as SessionReason, Y as SessionPhase, Z as SessionStatus, _ as FormFieldResult, a as BrowserDiagnostics, at as ViewportEvidence, b as HoverRequest, c as CheckpointOptions, ct as WaitForElementRequest, d as DocumentScroll, et as TargetUrl, f as FillFormOptions, g as FormField, h as FillRequest, i as BrowserDiagnostic, it as Viewport, j as Observation, k as NavigateRequest, l as ClickRequest, lt as WheelRequest, m as FillFormResult, n as AdmissionLimits, nt as TimelineLimits, o as BrowserPolicy, ot as ViewportPoint, p as FillFormRequest, q as SelectOptions, r as AutomationOptions, rt as TypeRequest, s as Checkpoint, st as ViewportRect, t as ActionResult, tt as TextResult, u as ControlFacts, v as FormStop, w as InputReceipt, x as Identifier, y as FrameInfo, z as PositiveInt } from "./BrowserData-CPIIIHol.mjs";
-export { ActionResult, AdmissionLimits, AutomationOptions, BrowserDiagnostic, BrowserDiagnostics, BrowserPolicy, Checkpoint, CheckpointOptions, ClickRequest, ControlFacts, DocumentScroll, FillFormOptions, FillFormRequest, FillFormResult, FillRequest, FormField, FormFieldResult, FormStop, FrameInfo, HoverRequest, Identifier, InlineFile, InlineFiles, InputReceipt, Inventory, KeyModifier, KeyStroke, NamedKey, NavigateRequest, NavigationResult, Observation, ObservationOptions, ObservedControl, ObservedElement, PageExecutionState, PageInfo, PageSuspension, PointerMoveRequest, PositiveInt, PressRequest, ReadTextRequest, ReadingMatch, SafeFilename, ScreenshotRequest, ScreenshotResult, ScrollRequest, SelectOptions, Selector, SessionPhase, SessionReason, SessionStatus, StartNavigationRequest, Target, TargetUrl, TextResult, TimelineLimits, TypeRequest, Viewport, ViewportEvidence, ViewportPoint, ViewportRect, WaitForElementRequest, WheelRequest };
-export {};