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

package/dist/BrowserData.mjs

@@ -1,695 +0,0 @@
-import { BrowserError } from "./Errors.mjs";
-import { Schema } from "effect";
-//#region src/BrowserData.ts
-const Identifier = Schema.NonEmptyString.check(Schema.isMaxLength(256), Schema.isPattern(/^[A-Za-z0-9_-]+$/));
-const PositiveInt = Schema.Int.check(Schema.isGreaterThan(0));
-/** Portable basename only; never a local or remote filesystem path. */
-const SafeFilename = Schema.NonEmptyString.check(Schema.isMaxLength(240), Schema.makeFilter((value) => value !== "." && value !== ".." && !/[\x00-\x1f\x7f/\\:]/.test(value) && !/[. ]$/.test(value) && !/^\s/.test(value) && !/^(con|prn|aux|nul|com[1-9]|lpt[1-9])(?:\.|$)/i.test(value), { title: "a portable, non-path download filename" }));
-var Viewport = class extends Schema.Class("BrowserViewport")(Schema.Struct({
-	width: PositiveInt.check(Schema.isLessThanOrEqualTo(4096)),
-	height: PositiveInt.check(Schema.isLessThanOrEqualTo(4096))
-}).check(Schema.makeFilter((v) => v.width * v.height <= 8388608, { title: "at most 8,388,608 viewport pixels" }))) {};
-/** Page/frame IDs are connection-local; targetId is a separate Chromium identity. */
-var Target = class extends Schema.Class("BrowserTarget")({
-	generation: Schema.Natural,
-	pageId: Identifier,
-	frameId: Identifier
-}) {};
-var PageInfo = class extends Schema.Class("BrowserPageInfo")({
-	pageId: Identifier,
-	targetId: Identifier,
-	url: Schema.String.check(Schema.isMaxLength(8192)),
-	title: Schema.String.check(Schema.isMaxLength(512)),
-	selected: Schema.Boolean
-}) {};
-var FrameInfo = class extends Schema.Class("BrowserFrameInfo")({
-	frameId: Identifier,
-	parentFrameId: Schema.NullOr(Identifier),
-	url: Schema.String.check(Schema.isMaxLength(8192)),
-	name: Schema.String.check(Schema.isMaxLength(256))
-}) {};
-const SessionPhase = Schema.Literals([
-	"acquiring",
-	"open",
-	"paused",
-	"detached",
-	"faulted",
-	"uncertain",
-	"closing",
-	"closed"
-]);
-const SessionReason = Schema.Literals([
-	"expired",
-	"callback-failure",
-	"registration-failure",
-	"native-failure",
-	"disconnected",
-	"popup-policy",
-	"dialog-policy",
-	"popup-overflow",
-	"dialog-overflow",
-	"cleanup-capacity",
-	"handoff",
-	"detached",
-	"closed",
-	"page-contained"
-]);
-const DiagnosticCounter = Schema.Natural.check(Schema.isLessThanOrEqualTo(Number.MAX_SAFE_INTEGER));
-/**
-* 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.
-*/
-var Inventory = class extends Schema.Class("BrowserInventory")({
-	generation: DiagnosticCounter,
-	pages: Schema.Array(PageInfo).check(Schema.isMaxLength(32))
-}) {};
-/** The bound on one session's model-reachable actions, like the host-read allowance's. */
-const ActionAllowance = PositiveInt.check(Schema.isLessThanOrEqualTo(1e6));
-/** Host-only admission evidence. Neither an admission token nor proof of remote termination. */
-var SessionStatus = class extends Schema.Class("BrowserSessionStatus")({
-	phase: SessionPhase,
-	reason: Schema.NullOr(SessionReason),
-	generation: DiagnosticCounter,
-	busy: Schema.Boolean,
-	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.
-	*/
-	actions: Schema.Struct({
-		used: Schema.Natural.check(Schema.isLessThanOrEqualTo(1e6)),
-		maximum: ActionAllowance
-	}).check(Schema.makeFilter((actions) => actions.used <= actions.maximum, { title: "no more actions used than allowed" }))
-}) {};
-/** Bounded host facts only: no target identity, page content, native exception or consumer cause. */
-var BrowserDiagnostic = class extends Schema.Class("BrowserDiagnostic")({
-	reason: SessionReason,
-	disposition: Schema.Literals([
-		"pending",
-		"confirmed",
-		"not-dispatched",
-		"unknown"
-	]),
-	generation: DiagnosticCounter,
-	monotonicNanos: Schema.BigInt.check(Schema.isGreaterThanOrEqualToBigInt(0n))
-}) {};
-var BrowserDiagnostics = class extends Schema.Class("BrowserDiagnostics")({
-	records: Schema.Array(BrowserDiagnostic).check(Schema.isMaxLength(32)),
-	total: DiagnosticCounter,
-	dropped: DiagnosticCounter,
-	truncated: Schema.Boolean
-}) {};
-var ObservedControl = class extends Schema.Class("BrowserObservedControl")({
-	elementId: Identifier,
-	kind: Schema.Literals([
-		"link",
-		"button",
-		"input",
-		"select",
-		"textarea",
-		"other"
-	]),
-	label: Schema.String.check(Schema.isMaxLength(256)),
-	disabled: Schema.Boolean,
-	checked: Schema.optionalKey(Schema.Boolean),
-	selected: Schema.optionalKey(Schema.Boolean),
-	inputType: Schema.optionalKey(Schema.String.check(Schema.isMaxLength(32))),
-	required: Schema.optionalKey(Schema.Boolean),
-	/** Native select state. A select is never represented by one `selected` boolean. */
-	multiple: Schema.optionalKey(Schema.Boolean),
-	/** The issued select this native option belongs to, in the same observation. */
-	selectElementId: Schema.optionalKey(Identifier),
-	/** Some choices could not be issued within this reading's shared control/value bounds. */
-	optionsTruncated: Schema.optionalKey(Schema.Boolean)
-}) {};
-const ScrollOffset = Schema.Finite.check(Schema.isBetween({
-	minimum: -Number.MAX_SAFE_INTEGER,
-	maximum: Number.MAX_SAFE_INTEGER
-}));
-const ScrollExtent = Schema.Natural.check(Schema.isLessThanOrEqualTo(Number.MAX_SAFE_INTEGER));
-/**
-* 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.
-*/
-const DocumentScroll = Schema.Struct({
-	x: ScrollOffset,
-	y: ScrollOffset,
-	scrollWidth: ScrollExtent,
-	scrollHeight: ScrollExtent,
-	clientWidth: ScrollExtent,
-	clientHeight: ScrollExtent
-});
-/**
-* 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.
-*/
-var ViewportEvidence = class extends Schema.Class("BrowserViewportEvidence")({
-	width: Schema.Finite,
-	height: Schema.Finite,
-	/** Absent when the document has no scrolling element, or in older/scripted readings. */
-	documentScroll: Schema.optionalKey(DocumentScroll),
-	/** Text that crossed a viewport edge; only its lines on screen were kept. */
-	clippedText: Schema.Natural,
-	/** Left out: another element is on top at the sampled point, or a box there paints over it. */
-	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.
-	*/
-	uncertainText: Schema.Natural,
-	/** Controls that intersect the viewport but cannot be reached there. */
-	unreachableControls: Schema.Natural,
-	/** The traversal budget ran out first, so this reading is known to be incomplete. */
-	exhausted: Schema.Boolean
-}) {};
-/**
-* 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.
-*/
-const ReadingMatch = Schema.String.check(Schema.isMinLength(1), Schema.isMaxLength(256), Schema.makeFilter((value) => value.trim().length > 0, { title: "not only whitespace" }));
-/**
-* 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.
-*/
-var Observation = class extends Schema.Class("BrowserObservation")({
-	target: Target,
-	observationId: Identifier,
-	revision: Schema.Natural,
-	scope: Schema.Literals(["document", "viewport"]),
-	match: Schema.optionalKey(ReadingMatch),
-	url: Schema.String.check(Schema.isMaxLength(8192)),
-	text: Schema.String.check(Schema.isMaxLength(131072)),
-	controls: Schema.Array(ObservedControl).check(Schema.isMaxLength(64)),
-	controlsTruncated: Schema.Boolean,
-	textTruncated: Schema.Boolean,
-	viewport: ViewportEvidence
-}) {};
-var ObservedElement = class extends Schema.Class("BrowserObservedElement")({
-	observationId: Identifier,
-	elementId: Identifier
-}) {};
-/** Observe a condition of this exact node. A replacement never satisfies the reference. */
-var WaitForElementRequest = class extends Schema.Class("BrowserWaitForElementRequest")({
-	reference: ObservedElement,
-	state: Schema.Literals([
-		"visible",
-		"hidden",
-		"enabled",
-		"disabled"
-	]),
-	timeoutMillis: Schema.optionalKey(Schema.Int.check(Schema.isBetween({
-		minimum: 1,
-		maximum: 6e4
-	})))
-}) {};
-/** Issued option element IDs from one observed native select; never values, labels or indices. */
-const SelectOptions = Schema.Array(Identifier).check(Schema.isMinLength(1), Schema.isMaxLength(64), Schema.makeFilter((ids) => new Set(ids).size === ids.length));
-/** Live, connection-owned receipt. It is not a durable promise that remote clocks remain held. */
-var PageSuspension = class extends Schema.Class("BrowserPageSuspension")({
-	pageId: Identifier,
-	targetId: Identifier,
-	suspensionId: Identifier
-}) {};
-var PageExecutionState = class extends Schema.Class("BrowserPageExecutionState")({
-	pageId: Identifier,
-	targetId: Identifier,
-	state: Schema.Literals([
-		"running",
-		"suspended",
-		"unknown"
-	]),
-	suspensionId: Schema.optionalKey(Identifier)
-}) {};
-/** Explicit opt-out: this integration does not claim whole-browser network containment. */
-var BrowserPolicy = class BrowserPolicy extends Schema.Class("BrowserBrowserPolicy")({
-	network: Schema.TaggedStruct("Unrestricted", {}),
-	/** Model-reachable actions for the session's lifetime, 1–1,000,000. `status.actions` reads use. */
-	maxActions: ActionAllowance,
-	maxElapsedMillis: PositiveInt.check(Schema.isLessThanOrEqualTo(216e5)),
-	maxReturnedBytes: PositiveInt.check(Schema.isLessThanOrEqualTo(8388608))
-}) {
-	/**
-	* 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 = {}) {
-		return BrowserPolicy.make({
-			network: { _tag: "Unrestricted" },
-			maxActions: bounds.maxActions ?? 100,
-			maxElapsedMillis: bounds.maxElapsedMillis ?? 3e5,
-			maxReturnedBytes: bounds.maxReturnedBytes ?? 2097152
-		});
-	}
-};
-const TargetUrl = Schema.NonEmptyString.check(Schema.isMaxLength(8192), Schema.makeFilter((value) => {
-	try {
-		const url = new URL(value);
-		return ["http:", "https:"].includes(url.protocol) && url.hostname !== "" && !url.username && !url.password;
-	} catch {
-		return false;
-	}
-}));
-const Selector = Schema.NonEmptyString.check(Schema.isMaxLength(1024));
-var NavigateRequest = class extends Schema.Class("BrowserNavigateRequest")({
-	url: TargetUrl,
-	timeoutMillis: Schema.optionalKey(Schema.Int.check(Schema.isBetween({
-		minimum: 1,
-		maximum: 6e5
-	})))
-}) {};
-/**
-* 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`.
-*/
-var StartNavigationRequest = class extends Schema.Class("BrowserStartNavigationRequest")({
-	url: TargetUrl,
-	timeoutMillis: Schema.optionalKey(Schema.Int.check(Schema.isBetween({
-		minimum: 1,
-		maximum: 6e5
-	})))
-}) {};
-var ReadTextRequest = class extends Schema.Class("BrowserReadTextRequest")({ selector: Schema.optionalKey(Selector) }) {};
-var ClickRequest = class extends Schema.Class("BrowserClickRequest")({ selector: Selector }) {};
-var FillRequest = class extends Schema.Class("BrowserFillRequest")({
-	selector: Selector,
-	value: Schema.String.check(Schema.isMaxLength(65536))
-}) {};
-/**
-* 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.
-*/
-const FormField = Schema.Struct({
-	elementId: Identifier,
-	value: Schema.optionalKey(FillRequest.fields.value),
-	checked: Schema.optionalKey(Schema.Boolean),
-	options: Schema.optionalKey(SelectOptions)
-}).check(Schema.makeFilter((field) => Number(field.value !== void 0) + Number(field.checked !== void 0) + Number(field.options !== void 0) === 1, { title: "exactly one of value, checked or options" }));
-/** At most 32 distinct fields, and a submit control that is not one of them. */
-var FillFormRequest = class extends Schema.Class("BrowserFillFormRequest")(Schema.Struct({
-	observationId: Identifier,
-	fields: Schema.Array(FormField).check(Schema.isMinLength(1), Schema.isMaxLength(32), Schema.makeFilter((fields) => new Set(fields.map((field) => field.elementId)).size === fields.length, { title: "each field at most once" })),
-	submit: Schema.optionalKey(Identifier)
-}).check(Schema.makeFilter((request) => request.submit === void 0 || !request.fields.some((field) => field.elementId === request.submit), { title: "a submit control that is not also a field" }))) {};
-/**
-* 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.
-*/
-const FillFormOptions = Schema.Struct({
-	verify: Schema.optionalKey(Schema.Boolean),
-	settleMillis: Schema.optionalKey(Schema.Int.check(Schema.isBetween({
-		minimum: 0,
-		maximum: 5e3
-	})))
-});
-/**
-* 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.
-*/
-var FormStop = class extends Schema.Class("BrowserFormStop")({
-	stage: Schema.Literals([
-		"field",
-		"verify",
-		"submit"
-	]),
-	elementId: Schema.optionalKey(Identifier),
-	error: BrowserError
-}) {};
-/**
-* 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.
-*/
-var ScrollRequest = class extends Schema.Class("BrowserScrollRequest")({
-	deltaX: Schema.Int.check(Schema.isBetween({
-		minimum: -1e5,
-		maximum: 1e5
-	})),
-	deltaY: Schema.Int.check(Schema.isBetween({
-		minimum: -1e5,
-		maximum: 1e5
-	}))
-}) {};
-/**
-* 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.
-*/
-var ViewportPoint = class extends Schema.Class("BrowserViewportPoint")({
-	x: Schema.Finite.check(Schema.isBetween({
-		minimum: 0,
-		maximum: 16384
-	})),
-	y: Schema.Finite.check(Schema.isBetween({
-		minimum: 0,
-		maximum: 16384
-	}))
-}) {};
-/** A box in the viewport of the frame it was read from, in CSS pixels. */
-var ViewportRect = class extends Schema.Class("BrowserViewportRect")({
-	x: Schema.Finite,
-	y: Schema.Finite,
-	width: Schema.Finite,
-	height: Schema.Finite
-}) {};
-/**
-* 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.
-*/
-var ControlFacts = class extends Schema.Class("BrowserControlFacts")({
-	kind: ObservedControl.fields.kind,
-	label: ObservedControl.fields.label,
-	disabled: Schema.Boolean,
-	checked: Schema.optionalKey(Schema.Boolean),
-	selected: Schema.optionalKey(Schema.Boolean),
-	required: Schema.optionalKey(Schema.Boolean),
-	multiple: Schema.optionalKey(Schema.Boolean),
-	editable: Schema.Boolean,
-	inputType: Schema.optionalKey(Schema.String.check(Schema.isMaxLength(32))),
-	autocomplete: Schema.optionalKey(Schema.String.check(Schema.isMaxLength(128))),
-	/** A resolved link target, or where this control submits its form. Absent when over-long. */
-	destination: Schema.optionalKey(Schema.String.check(Schema.isMaxLength(2048))),
-	formMethod: Schema.optionalKey(Schema.Literals([
-		"get",
-		"post",
-		"dialog"
-	])),
-	box: ViewportRect,
-	placement: Schema.Literals([
-		"inside",
-		"partial",
-		"outside"
-	]),
-	/** `self`: the browser finds this control at its visible centre. Not a pixel comparison. */
-	hitTest: Schema.Literals([
-		"self",
-		"covered",
-		"uncertain",
-		"unsampled"
-	]),
-	/** Only then is `box` in the main frame's viewport, the space pointer input uses. */
-	mainFrame: Schema.Boolean
-}) {};
-/**
-* 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.
-*/
-var Checkpoint = class extends Schema.Class("BrowserCheckpoint")({
-	target: Target,
-	revision: Schema.Natural,
-	url: Schema.String.check(Schema.isMaxLength(8192)),
-	text: Schema.String.check(Schema.isMaxLength(131072)),
-	textTruncated: Schema.Boolean,
-	controls: Schema.Array(ControlFacts).check(Schema.isMaxLength(64)),
-	controlsTruncated: Schema.Boolean,
-	viewport: ViewportEvidence,
-	picture: Schema.optionalKey(Schema.Struct({
-		mediaType: Schema.Literal("image/png"),
-		bytes: Schema.Uint8Array
-	})),
-	documentChanged: Schema.Boolean,
-	startedMonotonicNanos: Schema.BigInt,
-	completedMonotonicNanos: Schema.BigInt
-}) {};
-const ReadingBounds = {
-	maxTextBytes: Schema.optionalKey(Schema.Int.check(Schema.isBetween({
-		minimum: 1,
-		maximum: 131072
-	}))),
-	maxControls: Schema.optionalKey(Schema.Int.check(Schema.isBetween({
-		minimum: 0,
-		maximum: 64
-	})))
-};
-/** Omitted bounds default at admission; `scope` defaults to the whole document. */
-const ObservationOptions = Schema.Struct({
-	scope: Schema.optionalKey(Schema.Literals(["document", "viewport"])),
-	match: Schema.optionalKey(ReadingMatch),
-	...ReadingBounds
-});
-/** A checkpoint always reads the viewport. `picture` adds a PNG of it, within the byte policy. */
-const CheckpointOptions = Schema.Struct({
-	...ReadingBounds,
-	picture: Schema.optionalKey(Schema.Boolean)
-});
-/** One native pointer move. Easing and pacing are the caller's: send the points you want. */
-var PointerMoveRequest = class extends Schema.Class("BrowserPointerMoveRequest")({ to: ViewportPoint }) {};
-/** Moves the pointer onto one exact element where it is. It never scrolls to reach it. */
-var HoverRequest = class extends Schema.Class("BrowserHoverRequest")({ selector: Selector }) {};
-const WheelDelta = Schema.Finite.check(Schema.isBetween({
-	minimum: -1e5,
-	maximum: 1e5
-}));
-/**
-* 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.
-*/
-var WheelRequest = class extends Schema.Class("BrowserWheelRequest")({
-	deltaX: WheelDelta,
-	deltaY: WheelDelta,
-	at: Schema.optionalKey(ViewportPoint)
-}) {};
-/**
-* 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.
-*/
-const NamedKey = Schema.Literals([
-	"Enter",
-	"Tab",
-	"Backspace",
-	"Delete",
-	"Escape",
-	"ArrowLeft",
-	"ArrowRight",
-	"ArrowUp",
-	"ArrowDown",
-	"Home",
-	"End",
-	"PageUp",
-	"PageDown"
-]);
-/** One printable ASCII character, space included: every one is a key on the US layout. */
-const PrintableKey = Schema.String.check(Schema.isPattern(/^[\x20-\x7e]$/));
-const KeyModifier = Schema.Literals([
-	"Shift",
-	"Control",
-	"Alt",
-	"Meta"
-]);
-/** One key, down then up, with any modifiers held around it. */
-const KeyStroke = Schema.Struct({
-	key: Schema.Union([NamedKey, PrintableKey]),
-	modifiers: Schema.optionalKey(Schema.Array(KeyModifier).check(Schema.makeFilter((held) => new Set(held).size === held.length, { title: "each modifier at most once" })))
-});
-/**
-* 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.
-*/
-var PressRequest = class extends Schema.Class("BrowserPressRequest")({
-	...KeyStroke.fields,
-	into: Schema.optionalKey(Selector)
-}) {};
-/** Counted in characters, not UTF-16 units, because that is how many strokes it costs. */
-const TypedText = Schema.NonEmptyString.check(Schema.makeFilter((text) => [...text].length <= 256, { title: "at most 256 characters" }), Schema.makeFilter((text) => [...text].every((character) => {
-	const point = character.codePointAt(0) ?? 0;
-	return point > 31 && point !== 127 && (point < 55296 || point > 57343);
-}), { title: "no control characters or unpaired surrogates" }));
-/**
-* 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.
-*/
-var TypeRequest = class extends Schema.Class("BrowserTypeRequest")({
-	text: TypedText,
-	into: Schema.optionalKey(Selector)
-}) {};
-/**
-* 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.
-*/
-var InputReceipt = class extends Schema.Class("BrowserInputReceipt")({
-	target: Target,
-	kind: Schema.Literals([
-		"pointer-move",
-		"hover",
-		"wheel",
-		"click",
-		"press",
-		"type"
-	]),
-	position: Schema.NullOr(ViewportPoint),
-	intended: Schema.optionalKey(Schema.Struct({
-		position: ViewportPoint,
-		relativePosition: ViewportPoint,
-		qualification: Schema.Literal("checked-exact-node-sample")
-	})),
-	delta: Schema.optionalKey(Schema.Struct({
-		x: WheelDelta,
-		y: WheelDelta
-	})),
-	startedMonotonicNanos: Schema.BigInt,
-	completedMonotonicNanos: Schema.BigInt
-}) {};
-/** `set` dispatched input; `unchanged` needed none, because a toggle already held its state. */
-var FormFieldResult = class extends Schema.Class("BrowserFormFieldResult")({
-	elementId: Identifier,
-	status: Schema.Literals(["set", "unchanged"]),
-	input: Schema.optionalKey(InputReceipt)
-}) {};
-/** The bounded receipts for any toggle clicks and the one optional submit click. */
-var FillFormResult = class extends Schema.Class("BrowserFillFormResult")({
-	fields: Schema.Array(FormFieldResult).check(Schema.isMaxLength(32)),
-	submitted: Schema.Boolean,
-	url: TargetUrl,
-	submitInput: Schema.optionalKey(InputReceipt),
-	stopped: Schema.optionalKey(FormStop)
-}) {};
-var ScreenshotRequest = class extends Schema.Class("BrowserScreenshotRequest")({ fullPage: Schema.Boolean }) {};
-var NavigationResult = class extends Schema.Class("BrowserNavigationResult")({ url: TargetUrl }) {};
-var ActionResult = class extends Schema.Class("BrowserActionResult")({
-	url: TargetUrl,
-	/** Present for clicks; fill and scripted scroll results have no native input receipt. */
-	input: Schema.optionalKey(InputReceipt)
-}) {};
-var TextResult = class extends Schema.Class("BrowserTextResult")({ text: Schema.String.check(Schema.isMaxLength(8388608)) }) {};
-var ScreenshotResult = class extends Schema.Class("BrowserScreenshotResult")({
-	mediaType: Schema.Literal("image/png"),
-	bytes: Schema.Uint8Array
-}) {};
-const FileMediaType = Schema.NonEmptyString.check(Schema.isMaxLength(128), Schema.isPattern(/^[a-z0-9][a-z0-9!#$&^_+.-]*\/[a-z0-9][a-z0-9!#$&^_+.-]*$/));
-/** Small selection is in-memory by design: bytes the caller already holds, never a path. */
-var InlineFile = class extends Schema.Class("BrowserInlineFile")({
-	name: SafeFilename,
-	mediaType: FileMediaType,
-	bytes: Schema.Uint8Array.check(Schema.makeFilter((value) => value.byteLength >= 1 && value.byteLength <= 1048576, { title: "between one byte and one mebibyte" }))
-}) {};
-const InlineFiles = Schema.Array(InlineFile).check(Schema.isMaxLength(8), Schema.makeFilter((files) => files.length > 0 && files.reduce((total, file) => total + file.bytes.byteLength, 0) <= 4194304, { title: "at most four mebibytes of in-memory selection" }));
-const AdmissionLimits = Schema.Struct({
-	pendingPerPage: Schema.optionalKey(Schema.Int.check(Schema.isBetween({
-		minimum: 1,
-		maximum: 1024
-	}))),
-	pendingPerSession: Schema.optionalKey(Schema.Int.check(Schema.isBetween({
-		minimum: 1,
-		maximum: 1024
-	})))
-});
-/** Finite metadata retention and subscriber resources; native capture bytes have separate limits. */
-const TimelineLimits = Schema.Struct({
-	maxDurationMillis: Schema.optionalKey(Schema.Int.check(Schema.isBetween({
-		minimum: 1,
-		maximum: 216e5
-	}))),
-	maxEvents: Schema.optionalKey(Schema.Int.check(Schema.isBetween({
-		minimum: 1,
-		maximum: 65536
-	}))),
-	maxBytes: Schema.optionalKey(Schema.Int.check(Schema.isBetween({
-		minimum: 2048,
-		maximum: 67108864
-	}))),
-	maxSubscribers: Schema.optionalKey(Schema.Int.check(Schema.isBetween({
-		minimum: 1,
-		maximum: 256
-	}))),
-	maxEventBytes: Schema.optionalKey(Schema.Int.check(Schema.isBetween({
-		minimum: 2048,
-		maximum: 1048576
-	})))
-}).check(Schema.makeFilter((limits) => limits.maxEventBytes === void 0 || limits.maxBytes === void 0 || limits.maxEventBytes <= limits.maxBytes, { title: "event metadata fits the retained metadata budget" }));
-const AutomationOptions = Schema.Struct({
-	timelineLimits: Schema.optionalKey(TimelineLimits),
-	admissionLimits: Schema.optionalKey(AdmissionLimits),
-	observationLimits: Schema.optionalKey(Schema.Struct({
-		maxSnapshotsPerPage: Schema.Int.check(Schema.isBetween({
-			minimum: 1,
-			maximum: 128
-		})),
-		maxSnapshotsPerSession: Schema.Int.check(Schema.isBetween({
-			minimum: 1,
-			maximum: 4096
-		})),
-		maxHandlesPerPage: Schema.Int.check(Schema.isBetween({
-			minimum: 1,
-			maximum: 65536
-		})),
-		maxHandlesPerSession: Schema.Int.check(Schema.isBetween({
-			minimum: 1,
-			maximum: 2097152
-		})),
-		maxBytesPerPage: Schema.Int.check(Schema.isBetween({
-			minimum: 1,
-			maximum: 268435456
-		})),
-		maxBytesPerSession: Schema.Int.check(Schema.isBetween({
-			minimum: 1,
-			maximum: 1073741824
-		}))
-	})),
-	actionTimeoutMillis: Schema.optionalKey(Schema.Int.check(Schema.isBetween({
-		minimum: 1,
-		maximum: 6e4
-	}))),
-	/** Independent host-only checkpoint/control-facts allowance; normalized to 10,000 by the runtime. */
-	maxHostReads: Schema.optionalKey(Schema.Int.check(Schema.isBetween({
-		minimum: 1,
-		maximum: 1e6
-	}))),
-	maxPages: Schema.optionalKey(Schema.Int.check(Schema.isBetween({
-		minimum: 1,
-		maximum: 32
-	}))),
-	initialPage: Schema.optionalKey(Schema.Union([Schema.Struct({ targetId: Identifier }), Schema.Struct({ newPage: Schema.Literal(true) })])),
-	popupPolicy: Schema.optionalKey(Schema.Literals([
-		"retain",
-		"close",
-		"pause"
-	])),
-	dialogPolicy: Schema.optionalKey(Schema.Literals(["dismiss", "pause"])),
-	pageControl: Schema.optionalKey(Schema.Boolean)
-});
-//#endregion
-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 };
-
-//# sourceMappingURL=BrowserData.mjs.map