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

package/dist/Page-B5cjaUp5.mjs

@@ -0,0 +1,618 @@
+import { t as __exportAll } from "./rolldown-runtime-D7D4PA-g.mjs";
+import { Box, PageLoaded, Subject, SubjectContext } from "./BrowserEvent.mjs";
+import { c as FailFast, o as withheld, s as Correlation } from "./url-Cd04Okid.mjs";
+import { Frame, Image } from "./Frame.mjs";
+import { Effect, Schema } from "effect";
+//#region src/internal/input/evidence.inpage.ts
+/**
+* In the page: what the page says about an input's first target, for a judge, and which fields a
+* form would send. It never reads what a field holds. See `reading/names.inpage.ts` for what a page-side part may use.
+*/
+const evidence = (names, placing) => {
+	const { clean, isDocument, isInput, isSelect, isTextArea, nameOf, parentOf, roleOf, textOf } = names;
+	const { groups, headingBefore, textBeside, treeOf } = placing;
+	/** A field a submission would send. */
+	const isField = (element) => (isInput(element) && ![
+		"button",
+		"submit",
+		"reset",
+		"image"
+	].includes(element.type) || isSelect(element) || isTextArea(element)) && !element.matches(":disabled");
+	const isFilled = (field) => isInput(field) && (field.type === "checkbox" || field.type === "radio") ? field.checked : isInput(field) && field.type === "file" ? (field.files?.length ?? 0) > 0 : field.value !== "";
+	const dialogOf = (element) => {
+		for (let node = element; node !== null; node = parentOf(node)) if (node.tagName === "DIALOG" || /^(?:alert)?dialog$/.test(node.getAttribute("role") ?? "")) return node;
+	};
+	/** What the page says about an input's first target, for a judge. Never a field's value. */
+	const evidenceOf = (element, form, method, action) => {
+		const name = nameOf(element, roleOf(element));
+		const ids = element.getAttribute("aria-describedby");
+		const description = clean(ids === null ? element.getAttribute("aria-description") ?? element.getAttribute("title") : ids.split(/\s+/).map((id) => element.ownerDocument.getElementById(id)?.textContent ?? "").join(" "), 120);
+		const dialog = dialogOf(element);
+		const title = dialog?.querySelector("h1,h2,h3,h4,h5,h6,[role=heading]");
+		const dialogName = dialog === void 0 ? "" : clean(nameOf(dialog, "dialog"), 120) || (title === null || title === void 0 ? "" : clean(textOf(title), 120));
+		const root = element.getRootNode();
+		const top = isDocument(root) ? root.body ?? root : root;
+		const inTree = element.closest("dialog,[role=dialog],[role=alertdialog]");
+		let nearby = "";
+		for (const scope of /* @__PURE__ */ new Set([
+			element.closest(groups),
+			inTree,
+			top
+		])) if (scope !== null && nearby === "") nearby = textBeside(element, scope, true) || textBeside(element, scope, false);
+		const heading = headingBefore(element, treeOf(element));
+		const fields = form === null ? [] : Array.from(form.elements).filter(isField).slice(0, 16).map((field) => {
+			const autocomplete = clean(field.getAttribute("autocomplete"), 40);
+			return {
+				type: isInput(field) ? field.type : field.tagName.toLowerCase(),
+				name: clean(isInput(field) && field.type === "hidden" ? field.getAttribute("name") : nameOf(field, roleOf(field)), 40),
+				...autocomplete === "" ? {} : { autocomplete },
+				filled: isFilled(field)
+			};
+		});
+		return {
+			title: clean(document.title, 120),
+			...description === "" || description === name ? {} : { description },
+			...dialogName === "" ? {} : { dialog: dialogName },
+			...heading === void 0 ? {} : { heading },
+			...nearby === "" ? {} : { nearby },
+			...form === null ? {} : { form: {
+				method: method ?? form.method,
+				action: action ?? form.action,
+				fields
+			} }
+		};
+	};
+	return {
+		evidenceOf,
+		isField,
+		isFilled
+	};
+};
+const FormFieldSchema = Schema.Struct({
+	type: Schema.String,
+	name: Schema.String,
+	autocomplete: Schema.optional(Schema.String),
+	filled: Schema.Boolean
+});
+const EvidenceSchema = Schema.Struct({
+	title: Schema.String,
+	description: Schema.optional(Schema.String),
+	dialog: Schema.optional(Schema.String),
+	heading: Schema.optional(Schema.String),
+	nearby: Schema.optional(Schema.String),
+	form: Schema.optional(Schema.Struct({
+		method: Schema.String,
+		action: Schema.String,
+		fields: Schema.Array(FormFieldSchema)
+	}))
+});
+//#endregion
+//#region src/internal/input/guard.inpage.ts
+/**
+* In the page: what the input guard decides on. It inspects an input's targets for the facts a
+* policy weighs, such as a form submission or a secret field, binds an approval to them, and
+* checks before each press that the approved target would still receive it. See `reading/names.inpage.ts` for what a page-side part may use.
+*/
+const Fact$1 = Schema.Literals([
+	"form-submit",
+	"cross-origin",
+	"download",
+	"upload",
+	"secret",
+	"scripted",
+	"opaque"
+]);
+const guard = (names, targets, evidence) => {
+	const { activeElement, clean, describe, inCurrentDocument, interactiveRoles, isButton, isDisabled, isHtml, isInput, isLabel, isRoot, isSecret, isSelect, isTextArea, lookup, parentOf, refFor, roleOf } = names;
+	const { controlOf, details, hitAt, hrefAttribute, linkOf, receives, within } = targets;
+	const { evidenceOf, isField, isFilled } = evidence;
+	/**
+	* The element whose activation behaviour a click or key on `element` runs, as the browser
+	* resolves it along the composed path: a link, button, input, summary or a label's control.
+	*/
+	const activationTarget = (element) => {
+		for (let node = element; node !== null; node = parentOf(node)) {
+			if (hrefAttribute(node) !== null || node.tagName === "BUTTON" || node.tagName === "SUMMARY" || isInput(node) && node.type !== "hidden") return node;
+			if (isLabel(node) && node.control !== null) return node.control;
+		}
+	};
+	/**
+	* A control between a press's hit and the approved target that is not the target's own
+	* activation, such as a link or button a hover handler nested into it. The approval inspected
+	* the target, so that control would act unapproved.
+	*/
+	const nestedControl = (element, hit) => {
+		if (!within(element, hit)) return void 0;
+		const own = activationTarget(element);
+		for (let node = hit; node !== null && node !== element; node = parentOf(node) ?? node.ownerDocument.defaultView?.frameElement ?? null) if (node !== own && (hrefAttribute(node) !== null || node.tagName === "BUTTON" || node.tagName === "SUMMARY" || isInput(node) && node.type !== "hidden" || isSelect(node) || isTextArea(node) || isLabel(node) && node.control !== null && node.control !== own || activatingRoles.has(roleOf(node) ?? ""))) return node;
+	};
+	const textEntry = (element) => isInput(element) && ![
+		"button",
+		"reset",
+		"submit",
+		"image",
+		"checkbox",
+		"radio",
+		"file",
+		"range",
+		"color",
+		"hidden"
+	].includes(element.type) || isTextArea(element) || isHtml(element) && element.isContentEditable;
+	const activatingRoles = /* @__PURE__ */ new Set([
+		"button",
+		"link",
+		"checkbox",
+		"radio",
+		"switch",
+		"tab",
+		"menuitem",
+		"menuitemcheckbox",
+		"menuitemradio",
+		"option",
+		"treeitem"
+	]);
+	const typingRefusal = (element, explicit) => textEntry(element) ? void 0 : explicit ? `${describe(element)} is not a text field` : activationTarget(element) !== void 0 || isSelect(element) || activatingRoles.has(roleOf(element) ?? "") ? `focus is on ${describe(element)}, which typed text could activate or change; type into a text field by ref, or use press for keys` : void 0;
+	const isSubmitter = (element) => isButton(element) && element.type === "submit" || isInput(element) && (element.type === "submit" || element.type === "image");
+	const defaultSubmitter = (form) => {
+		const root = form.getRootNode();
+		return isRoot(root) ? Array.from(root.querySelectorAll("button,input")).find((candidate) => isSubmitter(candidate) && candidate.form === form) : void 0;
+	};
+	const purpose = (control, form) => [
+		control.getAttribute("id"),
+		control.getAttribute("name"),
+		control.getAttribute("inputmode"),
+		control.getAttribute("autocomplete"),
+		control.getAttribute("aria-label"),
+		form?.getAttribute("id"),
+		form?.getAttribute("name"),
+		form?.getAttribute("aria-label")
+	];
+	const boundUrl = (url) => {
+		const hash = url.indexOf("#");
+		return hash === -1 || /^#[/!]/.test(url.slice(hash)) ? url : url.slice(0, hash);
+	};
+	const inspectInput = (element, plan) => {
+		const metadata = details(element, element, 0, 0);
+		const control = activationTarget(element) ?? element;
+		const form = isInput(control) || isButton(control) || isTextArea(control) || isSelect(control) ? control.form : null;
+		const key = plan.keys === null ? void 0 : /(?:^|\+)(\+|[^+]+)$/.exec(plan.keys)?.[1];
+		const enter = key === "Enter";
+		const activation = plan.action === "click" || plan.action === "press" && (enter || key === "Space");
+		const fieldEnter = isInput(control) && ![
+			"button",
+			"reset",
+			"submit",
+			"image",
+			"file",
+			"color",
+			"hidden"
+		].includes(control.type) && (plan.action === "press" && enter || plan.action === "type" && plan.submit);
+		const submits = form !== null && (activation && isSubmitter(control) || fieldEnter);
+		const submitter = isSubmitter(control) ? control : form === null ? void 0 : defaultSubmitter(form);
+		const formDestination = form === null ? void 0 : submitter?.hasAttribute("formaction") === true ? submitter.formAction : form.action;
+		const formMethod = form === null ? void 0 : submitter?.hasAttribute("formmethod") === true ? submitter.formMethod : form.method;
+		const formTarget = form === null ? void 0 : submitter?.hasAttribute("formtarget") === true ? submitter.formTarget : form.target;
+		const link = linkOf(element);
+		const href = link === void 0 ? null : hrefAttribute(link);
+		const sends = submits && formMethod !== "dialog";
+		const destination = sends ? formDestination : activation ? metadata.href : void 0;
+		const acts = plan.action !== "hover" && plan.action !== "scroll";
+		const builtIn = sends || href !== null && !/^\s*(?:#\s*|javascript:[^]*)$/i.test(href) || isInput(control) && ![
+			"button",
+			"submit",
+			"image",
+			"reset"
+		].includes(control.type) || (isInput(control) || isButton(control)) && control.type === "reset" && form !== null || control.tagName === "SUMMARY" || control.closest("select") !== null || textEntry(control);
+		const facts = [];
+		if (sends) facts.push("form-submit");
+		if (activation && link?.hasAttribute("download") === true) facts.push("download");
+		if (activation && isInput(control) && control.type === "file") facts.push("upload");
+		if (plan.action === "type" && isSecret(control) || sends && form !== null && Array.from(form.elements).some((field) => isField(field) && isSecret(field) && isFilled(field))) facts.push("secret");
+		if (activation && !builtIn) facts.push("scripted");
+		if (acts && (metadata.role === "canvas" || metadata.role === "iframe" || metadata.name === "")) facts.push("opaque");
+		const role = metadata.role;
+		const boundName = role !== null && (interactiveRoles.has(role) || role === "canvas" || role === "iframe") && !(isHtml(element) && element.isContentEditable) ? metadata.name : null;
+		const fingerprint = JSON.stringify([
+			purpose(control, form),
+			element.tagName,
+			element.id,
+			role,
+			boundName,
+			metadata.href,
+			control === element ? null : refFor(control),
+			isInput(control) || isButton(control) ? control.type : control.tagName,
+			control.matches(":disabled") || isDisabled(control),
+			control.getAttribute("readonly"),
+			control.getAttribute("aria-readonly"),
+			isHtml(control) && control.isContentEditable,
+			control.getAttribute("name"),
+			control.getAttribute("accept"),
+			control.hasAttribute("multiple"),
+			link?.getAttribute("download"),
+			form === null ? null : refFor(form),
+			form === null ? null : boundUrl(form.action),
+			form?.method,
+			form?.target,
+			submitter === void 0 ? null : refFor(submitter),
+			formDestination === void 0 ? void 0 : boundUrl(formDestination),
+			formMethod,
+			formTarget,
+			submitter?.formNoValidate,
+			form?.noValidate
+		]);
+		return {
+			inspected: {
+				ref: refFor(element),
+				element: metadata.element,
+				role: metadata.role,
+				name: metadata.name,
+				cursor: metadata.cursor,
+				...metadata.href === void 0 ? {} : { href: metadata.href },
+				secret: isSecret(control),
+				fingerprint
+			},
+			facts,
+			destination,
+			explain: () => evidenceOf(element, form, formMethod, formDestination)
+		};
+	};
+	const inspect = (plan) => {
+		const targets = [];
+		const facts = /* @__PURE__ */ new Set();
+		let destination = plan.destination ?? void 0;
+		let explain = () => ({ title: clean(document.title, 120) });
+		for (const [index, target] of plan.targets.entries()) {
+			let element;
+			if (target === null) element = activeElement();
+			else if (typeof target === "string") {
+				element = lookup(target);
+				if (element === void 0) return {
+					error: "stale",
+					detail: target + " is not on the page any more",
+					index
+				};
+			} else {
+				if (!Number.isFinite(target.x) || !Number.isFinite(target.y) || target.x < 0 || target.y < 0 || target.x >= window.innerWidth || target.y >= window.innerHeight) return {
+					error: "outside",
+					detail: "the point is outside the viewport"
+				};
+				const hit = hitAt(document, target.x, target.y);
+				element = hit === null ? null : controlOf(hit);
+				if (element === null) return {
+					error: "offscreen",
+					detail: "nothing is painted at the point"
+				};
+			}
+			if (element === null) {
+				targets.push(null);
+				continue;
+			}
+			if (!inCurrentDocument(element)) return {
+				error: "stale",
+				detail: "the input target belongs to a replaced document",
+				index
+			};
+			const refusal = plan.action === "type" ? typingRefusal(element, target !== null) : void 0;
+			if (refusal !== void 0) return {
+				error: "untypeable",
+				detail: refusal
+			};
+			const inspected = inspectInput(element, plan);
+			if (index === 0) explain = inspected.explain;
+			targets.push(inspected.inspected);
+			for (const fact of inspected.facts) facts.add(fact);
+			destination ??= inspected.destination;
+			if (inspected.destination !== void 0) try {
+				if (new URL(inspected.destination, location.href).origin !== location.origin) facts.add("cross-origin");
+			} catch {
+				return {
+					error: "outside",
+					detail: "the input destination is not a valid URL"
+				};
+			}
+		}
+		if (destination !== void 0) try {
+			destination = new URL(destination, location.href).href;
+			if (new URL(destination).origin !== location.origin) facts.add("cross-origin");
+		} catch {
+			return {
+				error: "outside",
+				detail: "the input destination is not a valid URL"
+			};
+		}
+		return {
+			url: boundUrl(location.href),
+			targets,
+			facts: [...facts],
+			...destination === void 0 ? {} : { destination },
+			explain
+		};
+	};
+	const prepareInput = (plan) => {
+		const inspected = inspect(plan);
+		if ("error" in inspected) return inspected;
+		const { explain, ...prepared } = inspected;
+		return {
+			...prepared,
+			evidence: explain()
+		};
+	};
+	const validate = (plan, prepared, options) => {
+		const current = inspect(plan);
+		if ("error" in current) return current.error === "stale" ? current : {
+			error: "changed",
+			detail: current.detail
+		};
+		if (current.url !== prepared.url || (current.destination === void 0 || prepared.destination === void 0 ? current.destination !== prepared.destination : boundUrl(current.destination) !== boundUrl(prepared.destination)) || JSON.stringify(current.facts) !== JSON.stringify(prepared.facts) || current.targets.length !== prepared.targets.length || current.targets.some((target, index) => {
+			const previous = prepared.targets[index];
+			return target === null ? previous !== null : previous === null || previous === void 0 || target.ref !== previous.ref || target.fingerprint !== previous.fingerprint;
+		})) return {
+			error: "changed",
+			detail: "the page or input target changed while the policy was deciding"
+		};
+		if (options.focused === true) {
+			const active = activeElement();
+			const expected = prepared.targets[0];
+			if (active === null || expected === null || expected === void 0 || refFor(active) !== expected.ref) return {
+				error: "changed",
+				detail: "focus moved away from the approved element"
+			};
+		}
+		for (const press of options.presses ?? []) {
+			const expected = prepared.targets[press.index];
+			const element = expected === null || expected === void 0 ? void 0 : lookup(expected.ref);
+			const hit = hitAt(document, press.x, press.y);
+			if (element === void 0 || hit === null || !receives(element, hit)) return {
+				error: "changed",
+				detail: `the approved target is no longer under the pointer at (${press.x}, ${press.y})`
+			};
+			const nested = nestedControl(element, hit);
+			if (nested !== void 0) return {
+				error: "changed",
+				detail: `${describe(nested)} inside the approved target would receive the press at (${press.x}, ${press.y})`
+			};
+		}
+		return { ok: true };
+	};
+	const validateInput = (plan, prepared, options = {}) => {
+		if ((options.presses ?? []).length === 0) return validate(plan, prepared, options);
+		const { promise, resolve } = Promise.withResolvers();
+		if (document.visibilityState === "hidden") resolve();
+		else requestAnimationFrame(() => requestAnimationFrame(() => resolve()));
+		return promise.then(() => validate(plan, prepared, options));
+	};
+	return {
+		prepareInput,
+		textEntry,
+		typingRefusal,
+		validateInput
+	};
+};
+const InputPreparationError = Schema.Struct({
+	error: Schema.String,
+	detail: Schema.String,
+	index: Schema.optional(Schema.Finite)
+});
+const PreparedInputResultSchema = Schema.Union([Schema.Struct({
+	url: Schema.String,
+	targets: Schema.Array(Schema.NullOr(Schema.Struct({
+		ref: Schema.String,
+		element: Schema.String,
+		role: Schema.NullOr(Schema.String),
+		name: Schema.String,
+		cursor: Schema.String,
+		href: Schema.optional(Schema.String),
+		secret: Schema.Boolean,
+		fingerprint: Schema.String
+	}))),
+	facts: Schema.Array(Fact$1),
+	destination: Schema.optional(Schema.String),
+	evidence: EvidenceSchema
+}), InputPreparationError]);
+const ValidatedInputResultSchema = Schema.Union([Schema.Struct({ ok: Schema.Literal(true) }), InputPreparationError]);
+//#endregion
+//#region src/Page.ts
+/**
+* One browser tab: navigation, snapshots, pictures and input.
+*
+* A page waits only for itself: its operations take turns in one lane of its own. An action, which
+* sends input or navigates, has the page to itself, in the order actions were asked; reads share
+* it, after the action in flight and every action asked before them, so a read describes the page
+* an action left. A wait for a turn ends at the operation's deadline as `Busy`, never `Timeout`,
+* and a full deadline then bounds the operation itself; `failFast` fails it at once instead.
+* Identical reads asked between the same actions share one call to the page, and one whose
+* callers gave up finishes for the next caller to ask it. A policy holds outside the lane while
+* other operations continue; its target is revalidated before dispatch. Element targets are refs
+* from a snapshot; point targets are viewport coordinates in CSS pixels, the same coordinates as a
+* screenshot's pixels. Mouse and keyboard input share a bounded pipeline, so pacing does not wait
+* for each protocol reply. Target lookup happens before the input is sent.
+*
+* @since 0.3.0
+*/
+var Page_exports = /* @__PURE__ */ __exportAll({
+	ElementState: () => ElementState,
+	Fact: () => Fact,
+	Found: () => Found,
+	InputRequest: () => InputRequest,
+	Region: () => Region,
+	ResolvedTarget: () => ResolvedTarget,
+	State: () => State,
+	Text: () => Text,
+	Zoom: () => Zoom,
+	correlate: () => correlate,
+	failFast: () => failFast,
+	redacted: () => redacted
+});
+/** An integer rectangle in viewport CSS pixels. */
+var Region = class extends Schema.Class("effect-browser/Region")({
+	x: Schema.Int.check(Schema.isGreaterThanOrEqualTo(0)),
+	y: Schema.Int.check(Schema.isGreaterThanOrEqualTo(0)),
+	width: Schema.Int.check(Schema.isGreaterThan(0)),
+	height: Schema.Int.check(Schema.isGreaterThan(0))
+}) {};
+/** A crop and its viewport origin: add that origin to a point read from the crop. */
+var Zoom = class extends Schema.Class("effect-browser/Zoom")({
+	page: Schema.String,
+	region: Region,
+	image: Image
+}) {};
+/** The target as it read before input. Point coordinates are never snapped to another position. */
+var ResolvedTarget = class extends Schema.Class("effect-browser/ResolvedTarget")({
+	point: Schema.Struct({
+		x: Schema.Finite,
+		y: Schema.Finite
+	}),
+	element: Schema.String,
+	/** The element's lowercase tag name. */
+	tag: Schema.String,
+	role: Schema.NullOr(Schema.String),
+	name: Schema.String,
+	context: SubjectContext,
+	/** For a point target, the box of what it found there. */
+	box: Schema.optional(Box),
+	cursor: Schema.String,
+	href: Schema.optional(Schema.String)
+}) {};
+/**
+* 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.
+*/
+const ElementState = Schema.Struct({
+	disabled: Schema.Boolean,
+	focused: Schema.Boolean,
+	checked: Schema.optional(Schema.Boolean),
+	expanded: Schema.optional(Schema.Boolean),
+	selected: Schema.optional(Schema.Boolean),
+	pressed: Schema.optional(Schema.Boolean),
+	level: Schema.optional(Schema.Int)
+});
+/** An element `find` found: a ref for the actions, what it is, where it is and its state. */
+var Found = class extends Schema.Class("effect-browser/Found")({
+	ref: Schema.String,
+	subject: Subject,
+	/** Its box, rounded. Reading the document, it may be out of view. */
+	box: Box,
+	inViewport: Schema.Boolean,
+	state: ElementState
+}) {};
+/** What a page showed as text: a line per block, with table cells apart by tabs. */
+var Text = class extends Schema.Class("effect-browser/Text")({
+	url: Schema.String,
+	title: Schema.String,
+	text: Schema.String,
+	/** True when `text` was cut at `maxChars`. */
+	truncated: Schema.Boolean,
+	/** Host monotonic milliseconds from the browser's captured Effect Clock. */
+	at: Schema.Finite
+}) {};
+/**
+* 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.
+*/
+var State = class extends Schema.Class("effect-browser/PageState")({
+	page: Schema.String,
+	/** When this was taken. */
+	at: Schema.Finite,
+	/** Where the main frame last committed or moved, without userinfo or known secret parameters. */
+	url: Schema.String,
+	/** The page's document, as `Navigated` counts them. */
+	document: Schema.Int.check(Schema.isGreaterThanOrEqualTo(0)),
+	/** When the main frame committed it; absent for the one the browser began tracking it with. */
+	committedAt: Schema.optional(Schema.Finite),
+	/** How far that document has loaded, as the page's own session heard; absent until parsed. */
+	load: Schema.optional(PageLoaded),
+	/** The newest screencast frame, of whichever document it names. */
+	frame: Schema.optional(Frame),
+	/** The viewport's text as it was last read, with the page's title then. */
+	text: Schema.optional(Text)
+}) {};
+/**
+* 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}.
+*/
+const Fact = Fact$1;
+/**
+* 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.
+*/
+var InputRequest = class extends Schema.Class("effect-browser/InputRequest")({
+	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.
+	*/
+	url: Schema.String,
+	/** The page's title, at most 120 characters. */
+	title: Schema.String,
+	action: Schema.String,
+	target: Schema.optional(Schema.String),
+	element: Schema.optional(Schema.String),
+	/** Literal pixel targets only; ref coordinates are resolved after the policy allows them. */
+	point: Schema.optional(Schema.Struct({
+		x: Schema.Finite,
+		y: Schema.Finite
+	})),
+	text: Schema.optional(Schema.String),
+	role: Schema.optional(Schema.NullOr(Schema.String)),
+	name: Schema.optional(Schema.String),
+	/** The target's accessible description, when it says more than its name. */
+	description: Schema.optional(Schema.String),
+	href: Schema.optional(Schema.String),
+	destination: Schema.optional(Schema.String),
+	facts: Schema.Array(Fact),
+	/** Page text around the target, each part at most 120 characters. */
+	context: Schema.Struct({
+		/** The name or first heading of the dialog the target is in. */
+		dialog: Schema.optional(Schema.String),
+		/** The nearest heading before the target. */
+		heading: Schema.optional(Schema.String),
+		/** The visible text just before the target in its row, item, group or form, or after it. */
+		nearby: Schema.optional(Schema.String)
+	}),
+	/** The form the target is in, with at most 16 of its fields. */
+	form: Schema.optional(Schema.Struct({
+		method: Schema.String,
+		action: Schema.String,
+		/** Each field's type, name and autocomplete tokens, and whether it is filled: never its value. */
+		fields: Schema.Array(FormFieldSchema)
+	}))
+}) {};
+/**
+* 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.
+*/
+const redacted = withheld;
+/**
+* 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.
+*/
+const failFast = (effect) => Effect.provideService(effect, FailFast, true);
+/**
+* Give every action `effect` performs a caller's id, such as a model's tool call id, which its
+* recorded `Action` carries as `correlation`.
+*/
+const correlate = (id) => (effect) => Effect.provideService(effect, Correlation, id);
+//#endregion
+export { evidence as _, Page_exports as a, State as c, correlate as d, failFast as f, guard as g, ValidatedInputResultSchema as h, InputRequest as i, Text as l, PreparedInputResultSchema as m, Fact as n, Region as o, redacted as p, Found as r, ResolvedTarget as s, ElementState as t, Zoom as u };
+
+//# sourceMappingURL=Page-B5cjaUp5.mjs.map