@enekesabel/playwright-lite 0.2.1 → 0.3.0

package/dist/index.mjs

@@ -480,20 +480,198 @@ var UtilityScript$1 = class {
 };
 const LiteUtilityScript = module$1.exports.UtilityScript();
 //#endregion
+//#region src/jsHandle.ts
+const invalidArguments = "Too many arguments. If you need to pass more than 1 argument to the function wrap them in an object.";
+function assertEvaluationOptions(options) {
+	if (options !== void 0 && (typeof options !== "object" || options === null || Array.isArray(options))) throw new Error(invalidArguments);
+	if (options?.exposeFunctions === true) throw new Error("Unsupported Playwright option: evaluate.exposeFunctions");
+	if (options?.exposeFunctions !== void 0 && typeof options.exposeFunctions !== "boolean") throw new Error("exposeFunctions must be a boolean");
+}
+function assertMaxArguments(count, maximum) {
+	if (count > maximum) throw new Error(invalidArguments);
+}
+/**
+* A reference to one value in the controlled document.
+*
+* Mirrors pinned 26a9e47 client/jsHandle.ts and server/javascript.ts: the value
+* never leaves the document, and every member either evaluates against it or
+* copies it out through the pinned serializers.
+*/
+var AdapterJSHandle = class {
+	value;
+	evaluation;
+	disposedError = "JSHandle is disposed!";
+	disposed = false;
+	preview;
+	constructor(value, evaluation) {
+		this.value = value;
+		this.evaluation = evaluation;
+	}
+	/** Internal boundary used by evaluation argument and target unwrapping. */
+	valueForEvaluation(evaluation) {
+		if (this.evaluation !== evaluation) throw new Error("JSHandles can be evaluated only in the context they were created!");
+		if (this.disposed) throw new Error(this.disposedError);
+		return this.value;
+	}
+	asElement() {
+		return null;
+	}
+	async evaluate(pageFunction, arg, options) {
+		assertMaxArguments(arguments.length, 3);
+		assertEvaluationOptions(options);
+		return this.evaluation.byValue(pageFunction, typeof pageFunction === "function", arg, this);
+	}
+	async evaluateHandle(pageFunction, arg, options) {
+		assertMaxArguments(arguments.length, 3);
+		assertEvaluationOptions(options);
+		return this.evaluation.byHandle(pageFunction, typeof pageFunction === "function", arg, this);
+	}
+	/** Pinned javascript.ts:188 reads the property off the value itself. */
+	async getProperty(propertyName) {
+		const value = this.valueForEvaluation(this.evaluation);
+		return this.evaluation.handleFor(value[propertyName]);
+	}
+	/**
+	* Pinned crExecutionContext.ts:75 lists own enumerable data properties, and
+	* javascript.ts:197 answers with an empty map for a value without an object.
+	*/
+	async getProperties() {
+		const value = this.valueForEvaluation(this.evaluation);
+		const properties = /* @__PURE__ */ new Map();
+		if (value === null || typeof value !== "object" && typeof value !== "function") return properties;
+		for (const name of Object.getOwnPropertyNames(value)) {
+			const descriptor = Object.getOwnPropertyDescriptor(value, name);
+			if (!descriptor?.enumerable || !("value" in descriptor)) continue;
+			properties.set(name, this.evaluation.handleFor(descriptor.value));
+		}
+		return properties;
+	}
+	async jsonValue() {
+		return this.evaluation.jsonValue(this.valueForEvaluation(this.evaluation));
+	}
+	async dispose() {
+		this.toString();
+		this.disposed = true;
+		this.value = void 0;
+	}
+	async [Symbol.asyncDispose]() {
+		await this.dispose();
+	}
+	toString() {
+		return this.preview ??= this.computePreview();
+	}
+	computePreview() {
+		return previewValue(this.value);
+	}
+};
+/**
+* Mirrors the handle preview pinned 26a9e47 crExecutionContext.ts:123
+* (`renderPreview`) derives from a Chromium remote object: a value that crosses
+* the protocol renders as `String(value)`, and an object renders as V8's
+* `RemoteObject.description`. Handles created inside the document carry no
+* remote object, so the description is reconstructed from the value.
+*/
+function previewValue(value) {
+	if (value === null) return "null";
+	if (typeof value === "bigint") return `${value}n`;
+	if (typeof value === "function") return String(value);
+	if (typeof value !== "object") return Object.is(value, -0) ? "-0" : String(value);
+	const tag = Object.prototype.toString.call(value).slice(8, -1);
+	if (tag === "Date" || tag === "RegExp") return String(value);
+	if (tag === "Error") return value.stack || String(value);
+	const name = tag === "Object" ? constructorName(value) : tag;
+	if (tag === "Map" || tag === "Set") return `${name}(${value.size})`;
+	if (tag === "Array" || ArrayBuffer.isView(value)) return `${name}(${value.length})`;
+	return name;
+}
+function constructorName(value) {
+	return value.constructor?.name || "Object";
+}
+//#endregion
+//#region src/protocolValidation.ts
+/**
+* Client-boundary checks from the pinned Playwright protocol semantics.
+* See packages/protocol/src/validatorPrimitives.ts and spec/frame.yml at
+* 26a9e470a7b3c7822084b09fb7f13902c5f37b51.
+*/
+function validateString(value, name) {
+	if (value instanceof String) return value.valueOf();
+	if (typeof value === "string") return value;
+	throw new Error(`${name}: expected string, got ${typeof value}`);
+}
+function validateInteger(value, name) {
+	const integer = value instanceof Number ? value.valueOf() : value;
+	if (typeof integer !== "number") throw new Error(`${name}: expected integer, got ${typeof value}`);
+	if (!Number.isInteger(integer)) throw new Error(`${name}: expected integer, got float ${integer}`);
+	return integer;
+}
+/**
+* `delay` is `float?` in the pinned protocol for press, type and the pointer
+* actions. Like the pointer options, a non-finite value is rejected instead of
+* reaching the input path as NaN, and a boxed `Number` is unwrapped for the
+* caller to forward instead of leaking an object into the input path.
+*/
+function validateDelay(value) {
+	if (value === void 0) return void 0;
+	const delay = value instanceof Number ? value.valueOf() : value;
+	if (typeof delay !== "number" || !Number.isFinite(delay)) throw new TypeError("delay: expected number");
+	return delay;
+}
+/**
+* `force` is `boolean?` in the pinned protocol for every action that takes it.
+* Like the pointer options, a boxed `Boolean` is unwrapped so the caller
+* forwards a primitive instead of an always-truthy object.
+*/
+function validateForce(method, value) {
+	if (value === void 0) return void 0;
+	const force = value instanceof Boolean ? value.valueOf() : value;
+	if (typeof force !== "boolean") throw new TypeError(`${method} force must be a boolean`);
+	return force;
+}
+/**
+* `signal` is a client-side option in the pinned API: it never reaches the
+* protocol, so the adapter checks the value itself. `name` is the API member
+* or option group the message speaks for, such as `click` or `Query`.
+*/
+function validateSignal(name, value) {
+	if (value === void 0 || value instanceof AbortSignal) return;
+	throw new TypeError(`${name} signal must be an AbortSignal`);
+}
+/**
+* Rejects options the adapter does not implement, shared by the `Locator` and
+* `ElementHandle` forms of a member so both reject the same option with the
+* same message. Returns the normalized `delay`, unwrapped like the pointer
+* options.
+*/
+function rejectUnsupportedOptions(method, options, supported = []) {
+	if (!options) return void 0;
+	const unsupported = Object.keys(options).filter((key) => options[key] !== void 0 && !supported.includes(key));
+	if (unsupported.length > 0) throw new Error(`${method}(): unsupported Playwright option(s): ${unsupported.join(", ")}.`);
+	validateSignal(method, options.signal);
+	if (supported.includes("noWaitAfter")) validateNoWaitAfter(method, options.noWaitAfter);
+	return supported.includes("delay") ? validateDelay(options.delay) : void 0;
+}
+function validateNoWaitAfter(method, value) {
+	if (method !== "click" && method !== "press") return;
+	if (value === void 0 || typeof value === "boolean" || value instanceof Boolean) return;
+	throw new Error(`noWaitAfter: expected boolean, got ${typeof value}`);
+}
+//#endregion
 //#region src/elementHandle.ts
 /**
-* A browser-native, fixed reference to one element in the controlled document.
+* A browser-native, fixed reference to one node in the controlled document.
 *
-* This deliberately is not a Locator: selector operations below remain scoped
-* to `element`, even after the document replaces a matching node.
+* Pinned dom.ts:120 derives ElementHandle from JSHandle; the node members below
+* extend the handle members with it. This deliberately is not a Locator:
+* selector operations remain scoped to `element`, even after the document
+* replaces a matching node.
 */
-var AdapterElementHandle = class {
+var AdapterElementHandle = class extends AdapterJSHandle {
 	ownerPage;
-	element;
-	disposed = false;
+	disposedError = "ElementHandle has been disposed";
 	constructor(ownerPage, element) {
+		super(element, ownerPage.evaluation);
 		this.ownerPage = ownerPage;
-		this.element = element;
 	}
 	async click(options) {
 		await this.ownerPage.clickSelector(this.requireElement(), "elementHandle.click", options?.timeout, void 0, options);
@@ -505,14 +683,79 @@ var AdapterElementHandle = class {
 		await this.ownerPage.hoverSelector(this.requireElement(), "elementHandle.hover", options?.timeout, void 0, options);
 	}
 	async check(options) {
-		await this.ownerPage.setCheckedSelector(this.requireElement(), true, "elementHandle.check", options);
+		await this.ownerPage.setCheckedSelector(this.requireElement(), true, "elementHandle.check", options, void 0, "check");
 	}
 	async uncheck(options) {
-		await this.ownerPage.setCheckedSelector(this.requireElement(), false, "elementHandle.uncheck", options);
+		await this.ownerPage.setCheckedSelector(this.requireElement(), false, "elementHandle.uncheck", options, void 0, "uncheck");
 	}
 	async setChecked(checked, options) {
 		await this.ownerPage.setCheckedSelector(this.requireElement(), checked, "elementHandle.setChecked", options);
 	}
+	async fill(value, options) {
+		rejectUnsupportedOptions("fill", options, [
+			"force",
+			"noWaitAfter",
+			"signal",
+			"timeout"
+		]);
+		const force = validateForce("fill", options?.force);
+		await withAbortPrefix("elementHandle.fill", () => this.ownerPage.fillSelector(this.requireElement(), value, "elementHandle.fill", options?.timeout, void 0, true, options?.signal, "fill", force));
+	}
+	async focus() {
+		await this.ownerPage.focusSelector(this.requireElement(), "elementHandle.focus");
+	}
+	async type(text, options) {
+		rejectUnsupportedOptions("type", options, [
+			"delay",
+			"noWaitAfter",
+			"signal",
+			"timeout"
+		]);
+		await withAbortPrefix("elementHandle.type", () => this.ownerPage.typeSelector(this.requireElement(), text, options, "elementHandle.type", true));
+	}
+	async selectOption(values, options) {
+		rejectUnsupportedOptions("selectOption", options, [
+			"force",
+			"noWaitAfter",
+			"signal",
+			"timeout"
+		]);
+		const force = validateForce("selectOption", options?.force);
+		return withAbortPrefix("elementHandle.selectOption", () => this.ownerPage.selectOptionSelector(this.requireElement(), values, "elementHandle.selectOption", options?.timeout, void 0, true, options?.signal, force));
+	}
+	async setInputFiles(files, options) {
+		rejectUnsupportedOptions("setInputFiles", options, [
+			"noWaitAfter",
+			"signal",
+			"timeout"
+		]);
+		await withAbortPrefix("elementHandle.setInputFiles", () => this.ownerPage.setInputFilesSelector(this.requireElement(), files, options, true, "elementHandle.setInputFiles"));
+	}
+	async dispatchEvent(type, eventInit = {}) {
+		await this.ownerPage.dispatchEventSelector(this.requireElement(), type, eventInit, "elementHandle.dispatchEvent");
+	}
+	async press(key, options) {
+		const delay = rejectUnsupportedOptions("press", options, [
+			"delay",
+			"noWaitAfter",
+			"signal",
+			"timeout"
+		]);
+		await withAbortPrefix("elementHandle.press", () => this.ownerPage.pressSelector(this.requireElement(), key, "elementHandle.press", options?.timeout, void 0, true, options?.signal, delay));
+	}
+	async selectText(options) {
+		rejectUnsupportedOptions("selectText", options, [
+			"force",
+			"signal",
+			"timeout"
+		]);
+		const force = validateForce("selectText", options?.force);
+		await withAbortPrefix("elementHandle.selectText", () => this.ownerPage.selectText(this.requireElement(), "elementHandle.selectText", options?.timeout, void 0, options?.signal, force));
+	}
+	async scrollIntoViewIfNeeded(options) {
+		rejectUnsupportedOptions("scrollIntoViewIfNeeded", options, ["signal", "timeout"]);
+		await withAbortPrefix("elementHandle.scrollIntoViewIfNeeded", () => this.ownerPage.scrollLocatorIntoView(this.requireElement(), "elementHandle.scrollIntoViewIfNeeded", options?.timeout, void 0, options?.signal));
+	}
 	async $(selector) {
 		return this.ownerPage.elementHandleFor(this.ownerPage.resolveWithinElement(this.requireElement(), selector, false));
 	}
@@ -534,6 +777,10 @@ var AdapterElementHandle = class {
 		assertEvaluationOptions(options);
 		return this.ownerPage.evaluation.byValue(pageFunction, typeof pageFunction === "function", arg, this.requireElement());
 	}
+	/** Kept here so releasing a node is attributed to ElementHandle. */
+	async dispose() {
+		await super.dispose();
+	}
 	async textContent() {
 		return this.requireElement().textContent;
 	}
@@ -554,6 +801,14 @@ var AdapterElementHandle = class {
 	asElement() {
 		return this;
 	}
+	/** Pinned dom.ts:135 previews a node through the injected script. */
+	computePreview() {
+		try {
+			return `JSHandle@${this.ownerPage.previewNode(this.requireElement())}`;
+		} catch {
+			return "JSHandle@node";
+		}
+	}
 	async isEnabled() {
 		return this.ownerPage.elementStateForHandle(this.requireElement(), "enabled");
 	}
@@ -578,43 +833,30 @@ var AdapterElementHandle = class {
 		return this.ownerPage.boundingBoxForElement(this.requireElement());
 	}
 	async waitForElementState(state, options = {}) {
-		await this.ownerPage.waitForElementState(this.requireElement(), state, options);
+		await withAbortPrefix("elementHandle.waitForElementState", () => this.ownerPage.waitForElementState(this.requireElement(), state, options));
 	}
 	async waitForSelector(selector, options = {}) {
 		return await this.ownerPage.waitForSelectorWithinElement(this.requireElement(), selector, options);
 	}
-	async dispose() {
-		this.disposed = true;
-		this.element = void 0;
-	}
-	/** Internal boundary used only by Page evaluation argument unwrapping. */
-	elementForEvaluation(ownerPage) {
-		if (ownerPage !== this.ownerPage) throw new Error("ElementHandle belongs to a different Page");
-		return this.requireElement();
-	}
 	requireElement() {
-		if (this.disposed) throw new Error("ElementHandle has been disposed");
-		if (!this.element) throw new Error("ElementHandle has been disposed");
-		return this.element;
+		return this.valueForEvaluation(this.ownerPage.evaluation);
 	}
 };
 //#endregion
 //#region src/evaluation.ts
-const invalidArguments = "Too many arguments. If you need to pass more than 1 argument to the function wrap them in an object.";
-function assertEvaluationOptions(options) {
-	if (options !== void 0 && (typeof options !== "object" || options === null || Array.isArray(options))) throw new Error(invalidArguments);
-	if (options?.exposeFunctions === true) throw new Error("Unsupported Playwright option: evaluate.exposeFunctions");
-	if (options?.exposeFunctions !== void 0 && typeof options.exposeFunctions !== "boolean") throw new Error("exposeFunctions must be a boolean");
-}
-function assertMaxArguments(count, maximum) {
-	if (count > maximum) throw new Error(invalidArguments);
-}
 /** Uses the pinned UtilityScript for by-value calls without a browser protocol. */
 var Evaluation = class {
 	page;
 	utility;
+	/**
+	* The pinned protocol reports a node as a remote-object subtype. In the
+	* document that test is `instanceof Node`, so the constructor is captured
+	* before a page script can delete the global.
+	*/
+	node;
 	constructor(page) {
 		this.page = page;
+		this.node = page.window.Node;
 	}
 	get script() {
 		return this.utility ??= new LiteUtilityScript(this.page.window, false);
@@ -622,7 +864,7 @@ var Evaluation = class {
 	argument(value) {
 		const references = [];
 		const protocolValue = serializeValue(value, (candidate) => {
-			if (candidate instanceof AdapterElementHandle || candidate instanceof AdapterJSHandle) {
+			if (candidate instanceof AdapterJSHandle) {
 				references.push(candidate);
 				return { h: references.length - 1 };
 			}
@@ -632,10 +874,6 @@ var Evaluation = class {
 		const handles = [];
 		return {
 			serialized: serializeAsCallArgument$1(copy, (candidate) => {
-				if (candidate instanceof AdapterElementHandle) {
-					handles.push(candidate.elementForEvaluation(this.page));
-					return { h: handles.length - 1 };
-				}
 				if (candidate instanceof AdapterJSHandle) {
 					handles.push(candidate.valueForEvaluation(this));
 					return { h: handles.length - 1 };
@@ -645,31 +883,57 @@ var Evaluation = class {
 			handles
 		};
 	}
+	/** Replaces the handles inside a protocol argument with their values. */
+	unwrapHandles(value) {
+		const { serialized, handles } = this.argument(value);
+		return parseEvaluationResultValue$1(serialized, handles);
+	}
+	/** Pinned crExecutionContext.ts:142 answers a node with an ElementHandle. */
+	handleFor(value) {
+		return value instanceof this.node ? new AdapterElementHandle(this.page, value) : new AdapterJSHandle(value, this);
+	}
 	async byValue(expression, isFunction, arg, target) {
+		return protocolResult(parseEvaluationResultValue$1(await this.run(expression, isFunction, true, arg, target)));
+	}
+	/**
+	* Pinned javascript.ts:249 evaluates with `returnByValue: false`, and the
+	* protocol's `awaitPromise` settles a returned promise before it hands back
+	* the handle.
+	*/
+	async byHandle(expression, isFunction, arg, target) {
+		return this.handleFor(await this.run(expression, isFunction, false, arg, target));
+	}
+	async run(expression, isFunction, returnByValue, arg, target) {
 		const normalized = normalizeExpression(String(expression), isFunction);
 		const { serialized, handles } = this.argument(arg);
 		const parameters = [serialized];
 		if (target !== void 0) {
-			handles.push(target);
+			handles.push(target instanceof AdapterJSHandle ? target.valueForEvaluation(this) : target);
 			parameters.unshift({ h: handles.length - 1 });
 		}
 		try {
-			return protocolResult(parseEvaluationResultValue$1(await this.script.evaluate(isFunction, true, normalized, parameters.length, ...parameters, ...handles)));
+			return await this.script.evaluate(isFunction, returnByValue, normalized, parameters.length, ...parameters, ...handles);
 		} catch (error) {
 			throw evaluationError(error);
 		}
 	}
-	/** Deserialize once, retaining predicate argument state across polls. */
+	/**
+	* Deserialize once, retaining predicate argument state across polls.
+	*
+	* The returned poll accepts the element a `Locator` predicate is called on,
+	* which the pinned element form passes ahead of the argument
+	* (`server/frames.ts` `waitForFunctionExpressionOnElement`).
+	*/
 	predicate(expression, isFunction, arg) {
 		const normalized = normalizeExpression(String(expression), isFunction);
 		const { serialized, handles } = this.argument(arg);
 		const argument = parseEvaluationResultValue$1(serialized, handles);
 		let callback;
-		return () => {
+		return (target) => {
 			try {
 				const result = callback ?? this.page.window.eval(normalized);
 				if (isFunction) callback = result;
-				const value = isFunction ? callback(argument) : result;
+				const value = isFunction ? callback(...target === void 0 ? [argument] : [target, argument]) : result;
 				if (value && typeof value.then === "function") return Promise.resolve(value).catch((error) => {
 					throw evaluationError(error);
 				});
@@ -704,28 +968,6 @@ function normalizeExpression(expression, isFunction) {
 function evaluationError(error) {
 	return new Error(error instanceof Error ? error.stack || String(error) : String(error));
 }
-/** The existing waitForFunction handle. Additional JSHandle methods are unsupported. */
-var AdapterJSHandle = class {
-	value;
-	evaluation;
-	disposed = false;
-	constructor(value, evaluation) {
-		this.value = value;
-		this.evaluation = evaluation;
-	}
-	valueForEvaluation(evaluation) {
-		if (this.evaluation !== evaluation) throw new Error("JSHandles can be evaluated only in the context they were created!");
-		if (this.disposed) throw new Error("JSHandle is disposed!");
-		return this.value;
-	}
-	async jsonValue() {
-		return this.evaluation.jsonValue(this.valueForEvaluation(this.evaluation));
-	}
-	async dispose() {
-		this.disposed = true;
-		this.value = void 0;
-	}
-};
 //#endregion
 //#region node_modules/.pnpm/yaml@2.9.0/node_modules/yaml/browser/dist/nodes/identity.js
 const ALIAS = Symbol.for("yaml.alias");
@@ -14743,58 +14985,23 @@ var AdapterTimeoutError = class extends Error {
 	}
 };
 //#endregion
-//#region src/protocolValidation.ts
-/**
-* Client-boundary checks from the pinned Playwright protocol semantics.
-* See packages/protocol/src/validatorPrimitives.ts and spec/frame.yml at
-* 26a9e470a7b3c7822084b09fb7f13902c5f37b51.
-*/
-function validateString(value, name) {
-	if (value instanceof String) return value.valueOf();
-	if (typeof value === "string") return value;
-	throw new Error(`${name}: expected string, got ${typeof value}`);
-}
-/**
-* `delay` is `float?` in the pinned protocol for press, type and the pointer
-* actions. Like the pointer options, a non-finite value is rejected instead of
-* reaching the input path as NaN, and a boxed `Number` is unwrapped for the
-* caller to forward instead of leaking an object into the input path.
-*/
-function validateDelay(value) {
-	if (value === void 0) return void 0;
-	const delay = value instanceof Number ? value.valueOf() : value;
-	if (typeof delay !== "number" || !Number.isFinite(delay)) throw new TypeError("delay: expected number");
-	return delay;
-}
-/**
-* `signal` is a client-side option in the pinned API: it never reaches the
-* protocol, so the adapter checks the value itself. `name` is the API member
-* or option group the message speaks for, such as `click` or `Query`.
-*/
-function validateSignal(name, value) {
-	if (value === void 0 || value instanceof AbortSignal) return;
-	throw new TypeError(`${name} signal must be an AbortSignal`);
-}
-function validateNoWaitAfter(method, value) {
-	if (method !== "click" && method !== "press") return;
-	if (value === void 0 || typeof value === "boolean" || value instanceof Boolean) return;
-	throw new Error(`noWaitAfter: expected boolean, got ${typeof value}`);
-}
-//#endregion
 //#region src/inputFiles.ts
 /**
 * Pinned 26a9e47 client/elementHandle.ts converts payloads before resolving the
 * input; server/fileUploadUtils.ts encodes the bytes for InjectedScript. Keep
 * that format without importing Node's Buffer or filesystem into the browser.
+*
+* `Locator.drop` carries the same converted payloads in the pinned client, so
+* `method` names the member whose message a rejected payload belongs to.
 */
-function inputFilePayloads(files) {
+function inputFilePayloads(files, method = "setInputFiles") {
 	const items = Array.isArray(files) ? files : [files];
-	if (items.some((item) => typeof item === "string")) throw new Error("setInputFiles: file paths are not supported; pass in-memory Playwright payloads.");
+	if (items.some((item) => typeof item === "string")) throw new Error(`${method}: file paths are not supported; pass in-memory Playwright payloads.`);
 	const payloads = items.map((item) => {
-		if (!item || typeof item === "string" || item instanceof Blob || typeof item.name !== "string" || typeof item.mimeType !== "string" || !item.mimeType || !(item.buffer instanceof Uint8Array)) throw new TypeError("setInputFiles: expected { name, mimeType, buffer } with a non-empty MIME type and byte buffer; File and Blob are not supported.");
+		if (!item || typeof item === "string" || item instanceof Blob || typeof item.name !== "string" || typeof item.mimeType !== "string" || !item.mimeType || !(item.buffer instanceof Uint8Array)) throw new TypeError(`${method}: expected { name, mimeType, buffer } with a non-empty MIME type and byte buffer; File and Blob are not supported.`);
 		return item;
 	});
-	if (payloads.reduce((size, item) => size + item.buffer.byteLength, 0) >= 52428800) throw new Error("setInputFiles: in-memory payloads must total less than 50Mb.");
+	if (payloads.reduce((size, item) => size + item.buffer.byteLength, 0) >= 52428800) throw new Error(`${method}: in-memory payloads must total less than 50Mb.`);
 	return payloads.map((item) => {
 		let binary = "";
 		for (let offset = 0; offset < item.buffer.byteLength; offset += 8192) binary += String.fromCharCode(...item.buffer.subarray(offset, offset + 8192));
@@ -15664,6 +15871,10 @@ var LocatorImpl = class LocatorImpl {
 		assertMaxArguments(arguments.length, 3);
 		return withAbortPrefix("locator.evaluate", () => this.ownerPage.locatorEvaluate(this.selector, this.label, pageFunction, arg, options));
 	}
+	async evaluateHandle(pageFunction, arg, options) {
+		assertMaxArguments(arguments.length, 3);
+		return withAbortPrefix("locator.evaluateHandle", () => this.ownerPage.locatorEvaluateHandle(this.selector, this.label, pageFunction, arg, options));
+	}
 	async evaluateAll(pageFunction, arg) {
 		assertMaxArguments(arguments.length, 2);
 		return this.ownerPage.$$eval(this.selector, pageFunction, arg);
@@ -15676,11 +15887,13 @@ var LocatorImpl = class LocatorImpl {
 	}
 	async fill(value, options) {
 		rejectUnsupportedOptions("fill", options, [
+			"force",
 			"noWaitAfter",
 			"signal",
 			"timeout"
 		]);
-		await withAbortPrefix("locator.fill", () => this.ownerPage.fillSelector(this.selector, value, this.label, options?.timeout, void 0, true, options?.signal));
+		const force = validateForce("fill", options?.force);
+		await withAbortPrefix("locator.fill", () => this.ownerPage.fillSelector(this.selector, value, this.label, options?.timeout, void 0, true, options?.signal, "fill", force));
 	}
 	async setInputFiles(files, options) {
 		rejectUnsupportedOptions("setInputFiles", options, [
@@ -15690,6 +15903,9 @@ var LocatorImpl = class LocatorImpl {
 		]);
 		await withAbortPrefix("locator.setInputFiles", () => this.ownerPage.setInputFilesSelector(this.selector, files, options, true));
 	}
+	async drop(payload, options) {
+		await this.ownerPage.dropSelector(this.selector, this.label, payload, options);
+	}
 	async press(key, options) {
 		const delay = rejectUnsupportedOptions("press", options, [
 			"delay",
@@ -15709,11 +15925,13 @@ var LocatorImpl = class LocatorImpl {
 	}
 	async clear(options) {
 		rejectUnsupportedOptions("clear", options, [
+			"force",
 			"noWaitAfter",
 			"signal",
 			"timeout"
 		]);
-		await withAbortPrefix("locator.clear", () => this.ownerPage.fillSelector(this.selector, "", this.label, options?.timeout, void 0, true, options?.signal));
+		const force = validateForce("clear", options?.force);
+		await withAbortPrefix("locator.clear", () => this.ownerPage.fillSelector(this.selector, "", this.label, options?.timeout, void 0, true, options?.signal, "clear", force));
 	}
 	async hover(options) {
 		await this.ownerPage.hoverSelector(this.selector, this.label, options?.timeout, void 0, {
@@ -15751,15 +15969,22 @@ var LocatorImpl = class LocatorImpl {
 	}
 	async selectOption(values, options) {
 		rejectUnsupportedOptions("selectOption", options, [
+			"force",
 			"noWaitAfter",
 			"signal",
 			"timeout"
 		]);
-		return withAbortPrefix("locator.selectOption", () => this.ownerPage.selectOptionSelector(this.selector, values, this.label, options?.timeout, void 0, true, options?.signal));
+		const force = validateForce("selectOption", options?.force);
+		return withAbortPrefix("locator.selectOption", () => this.ownerPage.selectOptionSelector(this.selector, values, this.label, options?.timeout, void 0, true, options?.signal, force));
 	}
 	async selectText(options) {
-		rejectUnsupportedOptions("selectText", options, ["signal", "timeout"]);
-		await withAbortPrefix("locator.selectText", () => this.ownerPage.selectText(this.selector, this.label, options?.timeout, void 0, options?.signal));
+		rejectUnsupportedOptions("selectText", options, [
+			"force",
+			"signal",
+			"timeout"
+		]);
+		const force = validateForce("selectText", options?.force);
+		await withAbortPrefix("locator.selectText", () => this.ownerPage.selectText(this.selector, this.label, options?.timeout, void 0, options?.signal, force));
 	}
 	async scrollIntoViewIfNeeded(options) {
 		rejectUnsupportedOptions("scrollIntoViewIfNeeded", options, ["signal", "timeout"]);
@@ -15793,6 +16018,10 @@ var LocatorImpl = class LocatorImpl {
 			timeout: options.timeout
 		}, this.label));
 	}
+	async waitForFunction(pageFunction, arg, options = {}) {
+		rejectUnsupportedOptions("waitForFunction", options, ["signal", "timeout"]);
+		await this.ownerPage.waitForFunctionOnSelector(this.selector, this.label, pageFunction, arg, options);
+	}
 };
 /**
 * Single validation helper for the structured brand payload.
@@ -15805,15 +16034,6 @@ function requireBrand(value, context) {
 	if (typeof payload !== "object" || payload === null || typeof payload.getSelector !== "function" || typeof payload.resolveElements !== "function") throw new TypeError(`${context}: expected an PlaywrightLite Locator, got incompatible branded object`);
 	return payload;
 }
-/** Returns the normalized `delay`, unwrapped like the pointer options. */
-function rejectUnsupportedOptions(method, options, supported = []) {
-	if (!options) return void 0;
-	const unsupported = Object.keys(options).filter((key) => options[key] !== void 0 && !supported.includes(key));
-	if (unsupported.length > 0) throw new Error(`${method}(): unsupported Playwright option(s): ${unsupported.join(", ")}.`);
-	validateSignal(method, options.signal);
-	if (supported.includes("noWaitAfter")) validateNoWaitAfter(method, options.noWaitAfter);
-	return supported.includes("delay") ? validateDelay(options.delay) : void 0;
-}
 function cssObjectToString(style) {
 	return Object.entries(style).map(([key, value]) => {
 		return `${key.startsWith("--") ? key : key.replace(/[A-Z]/g, (match) => `-${match.toLowerCase()}`)}: ${value}`;
@@ -15860,6 +16080,11 @@ var PageImpl = class PageImpl {
 	_injected;
 	_injectedTestIdAttributeName;
 	pointerTarget;
+	/** Pinned input.ts Mouse starts at the document origin and tracks its moves. */
+	pointerPosition = {
+		x: 0,
+		y: 0
+	};
 	defaultTimeout;
 	defaultNavigationTimeout;
 	constructor(browserWindow, testIdAttribute = DEFAULT_TEST_ID_ATTRIBUTE) {
@@ -15909,6 +16134,9 @@ var PageImpl = class PageImpl {
 	elementHandleFor(element) {
 		return element ? new AdapterElementHandle(this, element) : null;
 	}
+	previewNode(node) {
+		return this.injected.previewNode(node);
+	}
 	requireSingle(selector, label) {
 		const element = this.resolveLocatorElement(selector, true);
 		if (!element) throw new Error(`No elements found for locator ${label}`);
@@ -15964,7 +16192,7 @@ var PageImpl = class PageImpl {
 		return await withAbortPrefix("page.waitForSelector", () => this.waitForSelectorInRoot(this.document, selector, options));
 	}
 	async waitForSelectorWithinElement(root, selector, options = {}) {
-		return await this.waitForSelectorInRoot(root, selector, options, false);
+		return await withAbortPrefix("elementHandle.waitForSelector", () => this.waitForSelectorInRoot(root, selector, options, "elementHandle.waitForSelector", false));
 	}
 	/**
 	* Adapts the client Locator._expect protocol to InjectedScript.expect.
@@ -16057,7 +16285,7 @@ var PageImpl = class PageImpl {
 					try {
 						if (options.modifiers) await this.keyboard.ensureModifiers(options.modifiers, deadline);
 						this.assertActionDeadline(deadline, action);
-						await this.movePointer(target.point, deadline, action);
+						await this.movePointer(target.point, deadline, action, options.steps);
 						if (!options.trial && action !== "hover") await this.dispatchClick(target.element, target.point, action === "dblclick" ? 2 : options.clickCount ?? 1, options, deadline, action);
 					} finally {
 						interception = interceptor?.stop() ?? "done";
@@ -16092,15 +16320,21 @@ var PageImpl = class PageImpl {
 		if (!checked && "isRadio" in state && state.isRadio) throw new Error("Cannot uncheck radio button. Radio buttons can only be unchecked by selecting another radio button in the same group.");
 		return state.matches === checked;
 	}
-	async fillSelector(selector, value, label, timeout, deadline = this.createActionDeadline(timeout), strict = true, signal) {
+	async fillSelector(selector, value, label, timeout, deadline = this.createActionDeadline(timeout), strict = true, signal, apiMethod = "fill", force = false) {
+		value = validateString(value, "value");
 		this.attachActionSignal(deadline, signal);
 		const { element } = await this.retryActionability(selector, label, "fill", [
 			"visible",
 			"enabled",
 			"editable"
-		], false, deadline, void 0, void 0, strict);
+		], false, deadline, void 0, void 0, strict, force);
 		this.assertActionDeadline(deadline, "fill");
-		const result = this.actionableInjected.fill(element, value);
+		let result;
+		try {
+			result = this.actionableInjected.fill(element, value);
+		} catch (error) {
+			throw injectedFillError(asError(error), selector, label, apiMethod, force);
+		}
 		if (result === "error:notconnected") throw new Error(`Element is not connected for locator ${label}`);
 		if (result === "done") return;
 		if (result !== "needsinput") throw new Error(`Unexpected fill result for locator ${label}: ${result}`);
@@ -16110,10 +16344,10 @@ var PageImpl = class PageImpl {
 	}
 	async pressSelector(selector, key, label, timeout, deadline = this.createActionDeadline(timeout), strict = true, signal, delay) {
 		this.attachActionSignal(deadline, signal);
-		const element = await this.query(selector, label, {
+		const element = typeof selector === "string" ? await this.query(selector, label, {
 			signal,
 			timeout
-		}, strict, (candidate) => candidate, deadline);
+		}, strict, (candidate) => candidate, deadline) : this.resolvePointerElement(selector, label, strict);
 		this.assertActionDeadline(deadline, "press");
 		this.focusElement(element);
 		await this.keyboard.press(key, { delay }, deadline);
@@ -16133,21 +16367,21 @@ var PageImpl = class PageImpl {
 		await this.performPointerAction(selector, label, "hover", options, deadline);
 	}
 	async setCheckedSelector(selector, checked, label, options = {}, deadline = this.createActionDeadline(options.timeout), apiMethod = "setChecked") {
-		options = assertPointerActionOptions("setChecked", options);
+		options = assertPointerActionOptions(apiMethod, options);
 		if (typeof checked !== "boolean") throw new TypeError("checked must be a boolean");
 		await this.performPointerAction(selector, label, "click", options, deadline, checked, apiMethod);
 	}
-	async selectOptionSelector(selector, values, label, timeout, deadline = this.createActionDeadline(timeout), strict = true, signal) {
+	async selectOptionSelector(selector, values, label, timeout, deadline = this.createActionDeadline(timeout), strict = true, signal, force = false) {
+		const options = selectOptionValues(values, this.evaluation);
 		this.attachActionSignal(deadline, signal);
-		const options = (values === null ? [] : Array.isArray(values) ? values : [values]).map((value) => typeof value === "string" ? { valueOrLabel: value } : value);
 		let lastError;
 		while (true) {
 			if (Date.now() >= deadline.expiresAt) throw new AdapterTimeoutError(`select option: Timeout ${deadline.timeout}ms exceeded.${lastError ? ` ${lastError.message}` : ""}`, { cause: lastError });
-			const { element } = await this.retryActionability(selector, label, "select option", ["visible", "enabled"], false, deadline, void 0, void 0, strict);
+			const { element } = await this.retryActionability(selector, label, "select option", ["visible", "enabled"], false, deadline, void 0, void 0, strict, force);
 			this.assertActionDeadline(deadline, "select option");
 			const result = this.actionableInjected.selectOptions(element, options);
 			if (Array.isArray(result)) return result;
-			lastError = result === "error:optionnotenabled" ? /* @__PURE__ */ new Error("Element is not enabled") : result === "error:notconnected" ? /* @__PURE__ */ new Error(`Element is not connected for locator ${label}`) : /* @__PURE__ */ new Error("Options not found");
+			lastError = result === "error:optionnotenabled" ? /* @__PURE__ */ new Error("option being selected is not enabled") : result === "error:notconnected" ? /* @__PURE__ */ new Error(`Element is not connected for locator ${label}`) : /* @__PURE__ */ new Error("Options not found");
 			const remaining = deadline.expiresAt - Date.now();
 			if (remaining <= 0) throw new AdapterTimeoutError(`select option: Timeout ${deadline.timeout}ms exceeded. ${lastError.message}`, { cause: lastError });
 			try {
@@ -16158,15 +16392,15 @@ var PageImpl = class PageImpl {
 			}
 		}
 	}
-	async selectText(selector, label, timeout, deadline = this.createActionDeadline(timeout), signal) {
+	async selectText(selector, label, timeout, deadline = this.createActionDeadline(timeout), signal, force = false) {
 		this.attachActionSignal(deadline, signal);
-		const { element } = await this.retryActionability(selector, label, "select text", ["visible"], false, deadline);
+		const { element } = await this.retryActionability(selector, label, "select text", ["visible"], false, deadline, void 0, void 0, void 0, force);
 		this.assertActionDeadline(deadline, "select text");
 		if (this.actionableInjected.selectText(element) === "error:notconnected") throw new Error(`Element is not connected for locator ${label}`);
 	}
 	async scrollLocatorIntoView(selector, label, timeout, deadline = this.createActionDeadline(timeout), signal) {
 		this.attachActionSignal(deadline, signal);
-		const { element } = await this.retryActionability(selector, label, "scroll into view", ["stable"], false, deadline);
+		const { element } = await this.retryActionability(selector, label, "scroll into view", ["stable"], false, deadline, void 0, {});
 		this.assertActionDeadline(deadline, "scroll into view");
 		this.scrollIntoViewIfNeeded(element);
 	}
@@ -16184,13 +16418,13 @@ var PageImpl = class PageImpl {
 			throw new AdapterTimeoutError(`locator.waitFor: Timeout ${timeout}ms exceeded.\nCall log:\n  - waiting for ${formatLocator(selector)} to be ${options.state}\n  - Timed out waiting for ${label} to become ${options.state}.`, { cause: error });
 		}
 	}
-	async setInputFilesSelector(selector, files, options = {}, strict = false) {
+	async setInputFilesSelector(selector, files, options = {}, strict = false, label = typeof selector === "string" ? selector : "elementHandle") {
 		assertPageActionOptions("setInputFiles", options, ["noWaitAfter", "strict"]);
 		if (options.strict !== void 0 && typeof options.strict !== "boolean") throw new TypeError("setInputFiles strict must be a boolean");
 		const payloads = inputFilePayloads(files);
 		const deadline = this.createActionDeadline(options.timeout);
 		this.attachActionSignal(deadline, options.signal);
-		await this.query(selector, selector, {
+		await this.query(selector, label, {
 			signal: options.signal,
 			timeout: options.timeout
 		}, strict || options.strict === true, (element) => {
@@ -16205,6 +16439,148 @@ var PageImpl = class PageImpl {
 		}, deadline);
 	}
 	/**
+	* Simulates an external drag-and-drop onto the resolved element.
+	*
+	* Mirrors pinned 26a9e47 `server/dom.ts` ElementHandle._drop: the element is
+	* awaited visible and stable (never enabled), then one synthetic
+	* `DataTransfer` carries the payload through `dragenter`, `dragover` and
+	* `drop` at the action point. A `dragover` handler that does not call
+	* `preventDefault()` rejects the drop, which ends with `dragleave`.
+	*/
+	async dropSelector(selector, label, payload, options = {}, strict = true) {
+		assertPageActionOptions("drop", options, ["position"]);
+		const files = payload?.files === void 0 ? [] : inputFilePayloads(payload.files, "drop");
+		const data = Object.entries(payload?.data ?? {});
+		if (files.length === 0 && data.length === 0) throw new Error("At least one of \"files\" or \"data\" must be provided.");
+		const deadline = this.createActionDeadline(options.timeout);
+		this.attachActionSignal(deadline, options.signal);
+		const { element, point } = await this.retryActionability(selector, label, "drop", ["visible", "stable"], true, deadline, options.position, {
+			...options,
+			strict
+		});
+		this.assertActionDeadline(deadline, "drop");
+		this.dispatchDrop(element, point, files, data);
+	}
+	/** The page function of pinned `server/dom.ts` ElementHandle._drop. */
+	dispatchDrop(element, point, files, data) {
+		const transfer = new this.window.DataTransfer();
+		for (const file of files) {
+			const bytes = Uint8Array.from(this.window.atob(file.buffer), (character) => character.charCodeAt(0));
+			transfer.items.add(new this.window.File([bytes], file.name, { type: file.mimeType }));
+		}
+		for (const [mimeType, value] of data) transfer.setData(mimeType, value);
+		const dragEvent = (type) => new this.window.DragEvent(type, {
+			bubbles: true,
+			cancelable: true,
+			composed: true,
+			clientX: point.x,
+			clientY: point.y,
+			dataTransfer: transfer
+		});
+		element.dispatchEvent(dragEvent("dragenter"));
+		const over = dragEvent("dragover");
+		element.dispatchEvent(over);
+		if (!over.defaultPrevented) {
+			element.dispatchEvent(dragEvent("dragleave"));
+			throw new Error("Drop target did not accept the drop — its dragover handler did not call preventDefault()");
+		}
+		element.dispatchEvent(dragEvent("drop"));
+	}
+	/**
+	* Adds a `<script>` tag to the controlled document.
+	*
+	* Mirrors pinned 26a9e47 `server/frames.ts` Frame._addScriptTag and its
+	* `addScriptUrl`/`addScriptContent` page functions: a `url` script resolves
+	* on its load event and fails naming the source, while `content` is injected
+	* as `text/javascript` unless `type` says otherwise.
+	*/
+	async addScriptTag(options = {}) {
+		const { url = null, content = null, type = "" } = assertAddTagOptions("addScriptTag", options);
+		return await this.raceWithCSPError(async () => {
+			const script = this.document.createElement("script");
+			if (url !== null) {
+				script.src = url;
+				if (type) script.type = type;
+				await this.appendLoadedTag(script, () => `Failed to load script at ${script.src}`);
+				return this.elementHandleFor(script);
+			}
+			script.type = type || "text/javascript";
+			script.text = content;
+			let error = null;
+			script.onerror = (event) => error = event;
+			this.document.head.appendChild(script);
+			if (error) throw error;
+			await new Promise((resolve) => this.window.setTimeout(resolve));
+			return this.elementHandleFor(script);
+		});
+	}
+	/**
+	* Adds a `<link rel="stylesheet">` or `<style type="text/css">` tag to the
+	* controlled document.
+	*
+	* Mirrors pinned 26a9e47 `server/frames.ts` Frame._addStyleTag and its
+	* `addStyleUrl`/`addStyleContent` page functions, which resolve on the load
+	* event of the inserted tag. The pinned page functions reject with the raw
+	* error event; this names the stylesheet instead, as the pinned script tag
+	* does.
+	*/
+	async addStyleTag(options = {}) {
+		const { url = null, content = null } = assertAddTagOptions("addStyleTag", options);
+		return await this.raceWithCSPError(async () => {
+			if (url !== null) {
+				const link = this.document.createElement("link");
+				link.rel = "stylesheet";
+				link.href = url;
+				await this.appendLoadedTag(link, () => `Failed to load style at ${link.href}`);
+				return this.elementHandleFor(link);
+			}
+			const style = this.document.createElement("style");
+			style.type = "text/css";
+			style.appendChild(this.document.createTextNode(content));
+			await this.appendLoadedTag(style, () => "Failed to apply the injected style content");
+			return this.elementHandleFor(style);
+		});
+	}
+	/** Appends a tag to the document head and settles on its load event. */
+	appendLoadedTag(tag, failure) {
+		const loaded = new Promise((resolve, reject) => {
+			tag.onload = () => resolve();
+			tag.onerror = () => reject(new Error(failure()));
+		});
+		this.document.head.appendChild(tag);
+		return loaded;
+	}
+	/**
+	* Fails a tag insertion the document's Content Security Policy blocked.
+	*
+	* Mirrors pinned 26a9e47 `server/frames.ts` Frame._raceWithCSPError, which
+	* races the insertion against the browser's CSP report. That report reaches
+	* the pinned code as a console message; inside the document the browser
+	* reports the same violation as a `securitypolicyviolation` event.
+	*/
+	async raceWithCSPError(action) {
+		let violation;
+		let onViolation = () => {};
+		const violated = new Promise((resolve) => {
+			onViolation = (event) => {
+				violation = event;
+				resolve();
+			};
+		});
+		this.document.addEventListener("securitypolicyviolation", onViolation);
+		let result;
+		let error;
+		const completed = action().then((value) => void (result = value), (reason) => void (error = reason));
+		try {
+			await Promise.race([completed, violated]);
+		} finally {
+			this.document.removeEventListener("securitypolicyviolation", onViolation);
+		}
+		if (violation) throw new Error(`Content Security Policy directive "${violation.violatedDirective}" blocked ${violation.blockedURI || "an inline resource"}`);
+		if (error) throw error;
+		return result;
+	}
+	/**
 	* Serializes the controlled document.
 	*
 	* Mirrors pinned 26a9e47 `server/frames.ts` Frame._content: serialize the
@@ -16268,8 +16644,13 @@ var PageImpl = class PageImpl {
 		});
 	}
 	async fill(selector, value, options) {
-		assertPageActionOptions("fill", options, ["noWaitAfter", "strict"]);
-		await withAbortPrefix("page.fill", () => this.fillSelector(selector, value, `page.fill(${JSON.stringify(selector)})`, options?.timeout, void 0, options?.strict === true, options?.signal));
+		assertPageActionOptions("fill", options, [
+			"force",
+			"noWaitAfter",
+			"strict"
+		]);
+		const force = validateForce("fill", options?.force);
+		await withAbortPrefix("page.fill", () => this.fillSelector(selector, value, `page.fill(${JSON.stringify(selector)})`, options?.timeout, void 0, options?.strict === true, options?.signal, "fill", force));
 	}
 	async setInputFiles(selector, files, options) {
 		await withAbortPrefix("page.setInputFiles", () => this.setInputFilesSelector(selector, files, options));
@@ -16315,20 +16696,25 @@ var PageImpl = class PageImpl {
 		});
 	}
 	async selectOption(selector, values, options) {
-		assertPageActionOptions("selectOption", options, ["noWaitAfter", "strict"]);
-		return withAbortPrefix("page.selectOption", () => this.selectOptionSelector(selector, values, `page.selectOption(${JSON.stringify(selector)})`, options?.timeout, void 0, options?.strict === true, options?.signal));
+		assertPageActionOptions("selectOption", options, [
+			"force",
+			"noWaitAfter",
+			"strict"
+		]);
+		const force = validateForce("selectOption", options?.force);
+		return withAbortPrefix("page.selectOption", () => this.selectOptionSelector(selector, values, `page.selectOption(${JSON.stringify(selector)})`, options?.timeout, void 0, options?.strict === true, options?.signal, force));
 	}
 	async check(selector, options) {
 		await this.setCheckedSelector(selector, true, `page.check(${JSON.stringify(selector)})`, {
 			...options,
 			strict: options?.strict ?? false
-		});
+		}, void 0, "check");
 	}
 	async uncheck(selector, options) {
 		await this.setCheckedSelector(selector, false, `page.uncheck(${JSON.stringify(selector)})`, {
 			...options,
 			strict: options?.strict ?? false
-		});
+		}, void 0, "uncheck");
 	}
 	async setChecked(selector, checked, options) {
 		await this.setCheckedSelector(selector, checked, `page.setChecked(${JSON.stringify(selector)})`, {
@@ -16348,10 +16734,11 @@ var PageImpl = class PageImpl {
 	}
 	async dispatchEventSelector(selector, type, eventInit, label, timeout, deadline = this.createActionDeadline(timeout), strict = true, signal) {
 		this.attachActionSignal(deadline, signal);
+		const init = this.evaluation.unwrapHandles(eventInit);
 		await this.query(selector, label, {
 			signal,
 			timeout
-		}, strict, (element) => this.actionableInjected.dispatchEvent(element, type, eventInit), deadline);
+		}, strict, (element) => this.actionableInjected.dispatchEvent(element, type, init), deadline);
 	}
 	/**
 	* Pinned 26a9e47 client/frame.ts and server/frames.ts default to load,
@@ -16460,6 +16847,12 @@ var PageImpl = class PageImpl {
 		assertEvaluationOptions(options);
 		return this._evaluateExpression(pageFunction, typeof pageFunction === "function", arg);
 	}
+	/** Keeps the result in the document, referenced by a handle. */
+	async evaluateHandle(pageFunction, arg, options) {
+		assertMaxArguments(arguments.length, 3);
+		assertEvaluationOptions(options);
+		return this.evaluation.byHandle(pageFunction, typeof pageFunction === "function", arg);
+	}
 	/** Evaluates through the pinned Playwright UtilityScript. */
 	async $eval(selector, callback, arg) {
 		assertMaxArguments(arguments.length, 3);
@@ -16483,28 +16876,39 @@ var PageImpl = class PageImpl {
 	}
 	/**
 	* Polls a predicate in the controlled document until it returns a
-	* truthy value.
-	*
-	* Mirrors pinned 26a9e47 server/frames.ts:1626-1694:
-	*   - pollingInterval must be >0 (frames.ts:1628)
-	*   - expression is normalized (frames.ts:1629)
-	*   - isFunction=true  → eval once, call each poll (frames.ts:1640-1642)
-	*   - isFunction=false → re-eval each poll (frames.ts:1643-1644,
-	*     since evaledExpression is never cached)
-	*   - abort mechanism cleans up pending timers (frames.ts:1679-1681)
-	*   - timeout races independently (handles never-settling predicates)
+	* truthy value. Public API: derives isFunction from typeof pageFunction.
 	*
 	* Returns a minimal handle with `jsonValue()` and `dispose()`,
 	* mirroring pinned client JSHandle interface.
 	*/
-	/**
-	* Public API: derives isFunction from typeof pageFunction.
-	*/
 	async waitForFunction(pageFunction, arg, options) {
 		return this._waitForFunctionExpression(typeof pageFunction === "function" ? pageFunction : String(pageFunction), typeof pageFunction === "function", arg, options);
 	}
 	/**
 	* Internal: accepts explicit isFunction for bridge transport.
+	*/
+	async _waitForFunctionExpression(pageFunction, isFunction, arg, options) {
+		const value = await this.pollPredicate("page.waitForFunction", pageFunction, isFunction, arg, options);
+		return this.evaluation.handleFor(value);
+	}
+	/**
+	* The `Locator` form of the member. Mirrors pinned 26a9e47
+	* server/frames.ts:1696-1712 `waitForFunctionExpressionOnElement`: the
+	* selector is re-resolved strictly on every poll and its element is passed
+	* to the predicate ahead of `arg`, so a re-rendered element is tolerated.
+	* The pinned client discards the predicate's value (`client/locator.ts`
+	* `waitForFunction` awaits the channel call and returns nothing), and it
+	* sends neither `polling` nor a handle back.
+	*/
+	async waitForFunctionOnSelector(selector, label, pageFunction, arg, options) {
+		await this.pollPredicate("locator.waitForFunction", pageFunction, typeof pageFunction === "function", arg, options, {
+			selector,
+			label
+		});
+	}
+	/**
+	* Shared polling engine of both forms. Resolves with the first truthy
+	* predicate value.
 	*
 	* Mirrors pinned 26a9e47 server/frames.ts:1626-1694:
 	*   - pollingInterval must be >0 (frames.ts:1628)
@@ -16514,38 +16918,66 @@ var PageImpl = class PageImpl {
 	*     since evaledExpression is never cached)
 	*   - abort mechanism cleans up pending timers (frames.ts:1679-1681)
 	*   - timeout races independently (handles never-settling predicates)
+	*
+	* `target` names the locator of the element form: it is re-resolved
+	* strictly on every poll, so a locator that matches nothing yet keeps
+	* polling while a strict mode violation ends the wait.
 	*/
-	async _waitForFunctionExpression(pageFunction, isFunction, arg, options) {
+	async pollPredicate(apiName, pageFunction, isFunction, arg, options, target) {
 		const timeout = this.resolveTimeout(options?.timeout, 3e4);
+		validateSignal("waitForFunction", options?.signal);
+		const signal = options?.signal;
 		const predicate = this.evaluation.predicate(pageFunction, isFunction, arg);
 		const polling = options?.polling ?? "raf";
 		if (typeof polling === "string" && polling !== "raf") throw new Error("Unknown polling option: " + polling);
 		if (typeof polling === "number" && polling <= 0) throw new Error("Cannot poll with non-positive interval: " + polling);
-		return new Promise((resolve, reject) => {
+		return withAbortPrefix(apiName, () => new Promise((resolve, reject) => {
 			let aborted = false;
 			let timeoutId;
 			let pollTimerId;
 			let rafId;
+			if (signal?.aborted) {
+				reject(actionAborted(signal, false));
+				return;
+			}
 			if (timeout > 0) timeoutId = this.window.setTimeout(() => {
 				cleanup();
-				reject(new AdapterTimeoutError(`page.waitForFunction: Timeout ${timeout}ms exceeded.`));
+				reject(new AdapterTimeoutError(`${apiName}: Timeout ${timeout}ms exceeded.` + (target ? queryCallLog(target.selector) : "")));
 			}, timeout);
 			const cleanup = () => {
 				aborted = true;
+				signal?.removeEventListener("abort", onAbort);
 				if (timeoutId !== void 0) this.window.clearTimeout(timeoutId);
 				if (pollTimerId !== void 0) this.window.clearTimeout(pollTimerId);
 				if (rafId !== void 0) this.window.cancelAnimationFrame(rafId);
 			};
+			const onAbort = () => {
+				cleanup();
+				reject(actionAborted(signal, true));
+			};
+			signal?.addEventListener("abort", onAbort, { once: true });
 			const check = () => {
 				if (aborted) return;
+				let element;
+				if (target) try {
+					element = this.queryElement(target.selector, target.label, true);
+				} catch (e) {
+					if (!isRetryableQueryError(e)) {
+						cleanup();
+						reject(e);
+						return;
+					}
+					scheduleNext();
+					return;
+				}
 				try {
-					const result = predicate();
+					const result = predicate(element);
 					if (result && typeof result?.then === "function") {
 						result.then((v) => {
 							if (aborted) return;
 							if (v) {
 								cleanup();
-								resolve(new AdapterJSHandle(v, this.evaluation));
+								resolve(v);
 							} else scheduleNext();
 						}, (e) => {
 							if (aborted) return;
@@ -16556,7 +16988,7 @@ var PageImpl = class PageImpl {
 					}
 					if (result) {
 						cleanup();
-						resolve(new AdapterJSHandle(result, this.evaluation));
+						resolve(result);
 						return;
 					}
 				} catch (e) {
@@ -16572,7 +17004,7 @@ var PageImpl = class PageImpl {
 				else pollTimerId = this.window.setTimeout(check, polling);
 			};
 			check();
-		});
+		}));
 	}
 	getByRole(role, options = {}) {
 		const roleSelector = getByRoleSelector(role, options);
@@ -16693,10 +17125,16 @@ var PageImpl = class PageImpl {
 		}, true, (element) => this.injectedAriaSnapshot(element, options));
 	}
 	async locatorEvaluate(selector, label, pageFunction, arg, options) {
+		return this.evaluation.byValue(pageFunction, typeof pageFunction === "function", arg, await this.locatorEvaluationTarget(selector, label, options));
+	}
+	async locatorEvaluateHandle(selector, label, pageFunction, arg, options) {
+		return this.evaluation.byHandle(pageFunction, typeof pageFunction === "function", arg, await this.locatorEvaluationTarget(selector, label, options));
+	}
+	/** Pinned locator.ts resolves the element before it evaluates against it. */
+	async locatorEvaluationTarget(selector, label, options) {
 		assertEvaluationOptions(options);
 		const { exposeFunctions: _exposeFunctions, ...queryOptions } = options ?? {};
-		const element = await this.query(selector, label, queryOptions, true, (element) => element);
-		return this.evaluation.byValue(pageFunction, typeof pageFunction === "function", arg, element);
+		return this.query(selector, label, queryOptions, true, (element) => element);
 	}
 	async queryState(selector, state, options, strict, label = `page.is${state[0].toUpperCase()}${state.slice(1)}(${JSON.stringify(selector)})`) {
 		return this.query(selector, label, options, strict, (element) => {
@@ -16729,6 +17167,7 @@ var PageImpl = class PageImpl {
 	async waitForElementState(element, state, options = {}) {
 		assertElementHandleStateOptions(state, options);
 		const deadline = this.createActionDeadline(options.timeout);
+		this.attachActionSignal(deadline, options.signal);
 		const timeoutError = () => new AdapterTimeoutError(`elementHandle.waitForElementState: Timeout ${deadline.timeout}ms exceeded.`);
 		while (true) {
 			if (deadline.expiresAt !== Infinity && Date.now() >= deadline.expiresAt) throw timeoutError();
@@ -16737,7 +17176,7 @@ var PageImpl = class PageImpl {
 			await this.wait(deadline.expiresAt === Infinity ? 10 : Math.min(10, deadline.expiresAt - Date.now()));
 		}
 	}
-	async waitForSelectorInRoot(root, selector, options, allowsStrict = true) {
+	async waitForSelectorInRoot(root, selector, options, apiName = "page.waitForSelector", allowsStrict = true) {
 		assertWaitForSelectorOptions(options, allowsStrict);
 		const state = options.state ?? "visible";
 		const timeout = this.resolveTimeout(options.timeout, DEFAULT_ACTION_TIMEOUT);
@@ -16749,7 +17188,7 @@ var PageImpl = class PageImpl {
 			const visible = !!element && this.elementState(element, "visible").matches === true;
 			if (state === "attached" && element || state === "visible" && visible) return this.elementHandleFor(element);
 			if (state === "detached" && !element || state === "hidden" && !visible) return null;
-			if (Date.now() >= deadline) throw new AdapterTimeoutError(`page.waitForSelector: Timeout ${timeout}ms exceeded.\nCall log:\n  - waiting for ${formatLocator(selector)} to be ${state}`);
+			if (Date.now() >= deadline) throw new AdapterTimeoutError(`${apiName}: Timeout ${timeout}ms exceeded.\nCall log:\n  - waiting for ${formatLocator(selector)} to be ${state}`);
 			const delay = Math.min(QUERY_RETRY_DELAY, deadline - Date.now());
 			if (!await waitForExpectationRetry(this.window, delay, signal)) throw actionAborted(signal, true);
 		}
@@ -16778,11 +17217,11 @@ var PageImpl = class PageImpl {
 		if (signal?.aborted) throw actionAborted(signal, false);
 		const deadline = actionDeadline?.expiresAt ?? (timeout === 0 ? Infinity : Date.now() + timeout);
 		while (true) try {
-			return await evaluate(this.queryElement(selector, label, strict || options?.strict === true));
+			return await evaluate(this.resolvePointerElement(selector, label, strict || options?.strict === true));
 		} catch (error) {
 			if (!isRetryableQueryError(error)) throw error;
 			const remaining = deadline - Date.now();
-			if (remaining <= 0) throw new AdapterTimeoutError(`Timeout ${timeout}ms exceeded.\nCall log:\n  - waiting for ${formatLocator(selector)}`, { cause: error });
+			if (remaining <= 0) throw new AdapterTimeoutError(`Timeout ${timeout}ms exceeded.${queryCallLog(selector)}`, { cause: error });
 			const delay = Math.min(QUERY_RETRY_DELAY, remaining);
 			if (!await waitForExpectationRetry(this.window, delay, signal)) throw actionAborted(signal, true);
 		}
@@ -16838,7 +17277,7 @@ var PageImpl = class PageImpl {
 		}
 		return /* @__PURE__ */ new Error("Element is not stable");
 	}
-	async retryActionability(selector, label, actionName, states, checkHitTarget, deadline, position, pointerOptions, strict = pointerOptions?.strict ?? true) {
+	async retryActionability(selector, label, actionName, states, checkHitTarget, deadline, position, pointerOptions, strict = pointerOptions?.strict ?? true, force = pointerOptions?.force ?? false) {
 		let lastError;
 		let retry = 0;
 		const log = [];
@@ -16851,10 +17290,12 @@ var PageImpl = class PageImpl {
 			if (Date.now() >= deadline.expiresAt) throwTimeout();
 			try {
 				const element = this.resolvePointerElement(selector, label, strict);
-				if (pointerOptions && !pointerOptions.force) log.push(`  - waiting for element to be ${states.includes("enabled") ? "visible, enabled and stable" : "visible and stable"}`);
-				if (!pointerOptions?.force) await this.ensureActionable(element, states, deadline);
+				if (pointerOptions && !force) log.push(`  - waiting for element to be ${states.includes("enabled") ? "visible, enabled and stable" : "visible and stable"}`);
+				if (!force) await this.ensureActionable(element, states, deadline);
 				if (Date.now() >= deadline.expiresAt) throwTimeout();
-				if (actionName !== "scroll into view" && pointerOptions?.scroll !== "none") {
+				if (actionName === "scroll into view") {
+					if (!this.hasLayoutBox(element)) throw new Error("Element is not visible");
+				} else if (pointerOptions?.scroll !== "none") {
 					if (!pointerOptions || position) this.scrollIntoView(element, position);
 					else if (retry % 4 === 0) this.scrollIntoViewIfNeeded(element);
 					else element.scrollIntoView({
@@ -16871,8 +17312,8 @@ var PageImpl = class PageImpl {
 						behavior: "instant"
 					});
 				}
-				if (!pointerOptions?.force) await this.ensureActionable(element, states, deadline);
-				const point = checkHitTarget ? this.ensureReceivesEvents(element, position, !!pointerOptions?.force) : actionPoint(element, position, this.window);
+				if (!force) await this.ensureActionable(element, states, deadline);
+				const point = checkHitTarget ? this.ensureReceivesEvents(element, position, force) : actionPoint(element, position, this.window);
 				if (Date.now() >= deadline.expiresAt) throwTimeout();
 				return {
 					element,
@@ -16880,7 +17321,7 @@ var PageImpl = class PageImpl {
 				};
 			} catch (error) {
 				if (typeof selector !== "string" && !selector.isConnected) throw new Error("Element is not attached to the DOM", { cause: error });
-				if (!isRetryableActionError(error) || pointerOptions?.force && !asError(error).message.startsWith("No elements found for locator")) throw error;
+				if (!isRetryableActionError(error) || force && !asError(error).message.startsWith("No elements found for locator")) throw error;
 				lastError = asError(error);
 				const remaining = deadline.expiresAt - Date.now();
 				const delay = pointerOptions ? [
@@ -16906,6 +17347,17 @@ var PageImpl = class PageImpl {
 			}
 		}
 	}
+	/**
+	* Whether the element is rendered at all. `display: contents` has no box of
+	* its own, so its contents answer for it, exactly as the scroll below does.
+	*/
+	hasLayoutBox(element) {
+		if (element.getClientRects().length > 0) return true;
+		if (this.window.getComputedStyle(element).display !== "contents") return false;
+		const range = this.document.createRange();
+		range.selectNodeContents(element);
+		return range.getClientRects().length > 0;
+	}
 	scrollIntoView(element, position) {
 		if (typeof element.scrollIntoView !== "function") return;
 		element.scrollIntoView({
@@ -17006,7 +17458,20 @@ var PageImpl = class PageImpl {
 			}
 		}));
 	}
-	async movePointer(point, deadline, action) {
+	/**
+	* Mirrors pinned input.ts Mouse.move: `steps` interpolated positions between
+	* the pointer's previous location and `point`, the last landing exactly on
+	* it. `steps` defaults to 1, a single move to the destination.
+	*/
+	async movePointer(point, deadline, action, steps = 1) {
+		const from = this.pointerPosition;
+		this.pointerPosition = point;
+		for (let step = 1; step <= steps; step++) await this.movePointerTo({
+			x: from.x + (point.x - from.x) * (step / steps),
+			y: from.y + (point.y - from.y) * (step / steps)
+		}, deadline, action);
+	}
+	async movePointerTo(point, deadline, action) {
 		const target = this.eventTargetAtPoint(point);
 		const previous = this.pointerTarget;
 		if (previous !== target && previous?.isConnected) {
@@ -17081,6 +17546,7 @@ var PageImpl = class PageImpl {
 	insertPressedText(element, text, inputType = "insertText", eventData = text, deadline) {
 		this.assertActionDeadline(deadline, "press");
 		if (!isEditableElement(element, this.window)) return;
+		if (this.insertTextAtCaret(element, text, inputType)) return;
 		if (isFillableInputWithoutSelection(element, this.window)) {
 			element.value += text;
 			this.dispatchInputEvent(element, eventData, inputType);
@@ -17088,10 +17554,30 @@ var PageImpl = class PageImpl {
 		}
 		this.replaceSelectedText(element, text, inputType, eventData);
 	}
-	insertKeyboardText(element, text, inputType = "insertText", eventData = text, deadline) {
+	/**
+	* Inserts text at the caret the browser itself keeps, dispatching its own
+	* input event. Playwright types through the browser's editing engine; the
+	* pinned in-document input emulation reaches for this editing command for
+	* the same reason (coreBundle `_insertText`). It is the only script
+	* primitive that finds the caret in an input type that exposes no selection
+	* API, and in an editable host inside a shadow root, whose selection the
+	* document reports retargeted to the host.
+	*/
+	insertTextAtCaret(element, text, inputType) {
+		if (inputType !== "insertText") return false;
+		if (this.deepActiveElement() !== element) return false;
+		return this.document.execCommand("insertText", false, text);
+	}
+	deepActiveElement() {
+		let target = this.document.activeElement ?? this.document.body;
+		while (target.shadowRoot?.mode === "open" && target.shadowRoot.activeElement) target = target.shadowRoot.activeElement;
+		return target;
+	}
+	insertKeyboardText(element, text, inputType = "insertText", eventData = text, deadline, typedByKey = false) {
 		this.assertActionDeadline(deadline, "press");
 		if (!isEditableElement(element, this.window)) return;
 		if (!this.dispatchBeforeInput(element, eventData, inputType)) return;
+		if (typedByKey && !this.dispatchTextInput(element, text)) return;
 		this.assertActionDeadline(deadline, "press");
 		this.insertPressedText(element, text, inputType, eventData, deadline);
 	}
@@ -17172,6 +17658,11 @@ var PageImpl = class PageImpl {
 			inputType
 		}));
 	}
+	dispatchTextInput(element, text) {
+		const event = this.document.createEvent("TextEvent");
+		event.initTextEvent("textInput", true, true, this.window, text);
+		return element.dispatchEvent(event);
+	}
 	dispatchInputEvent(element, data = null, inputType = "insertText") {
 		const InputEvent = this.window.InputEvent;
 		element.dispatchEvent(InputEvent ? new InputEvent("input", {
@@ -17403,7 +17894,7 @@ var BrowserKeyboard = class {
 		if (dispatchKeyPress) await this.waitForKeyboardPhase(deadline);
 		if (keyPressAllowed && description.text && description.key !== "Enter") {
 			this.page.checkKeyboardActionDeadline(deadline);
-			this.page.insertKeyboardText(this.activeTarget(), description.text, "insertText", description.text, deadline);
+			this.page.insertKeyboardText(this.activeTarget(), description.text, "insertText", description.text, deadline, true);
 		}
 		if (keyPressAllowed && description.key === "Enter") {
 			this.page.checkKeyboardActionDeadline(deadline);
@@ -17423,9 +17914,7 @@ var BrowserKeyboard = class {
 		if (keyDownState?.allowed && keyUpAllowed && keyUpTarget === keyDownState.target && this.activeTarget() === keyDownState.target) this.page.applyKeyupDefault(keyDownState.target, description, this.pressedModifiers);
 	}
 	activeTarget() {
-		let target = this.page.document.activeElement ?? this.page.document.body;
-		while (target.shadowRoot?.mode === "open" && target.shadowRoot.activeElement) target = target.shadowRoot.activeElement;
-		return target;
+		return this.page.deepActiveElement();
 	}
 	descriptionFor(key) {
 		const resolved = resolveKeyboardKey(key, this.page.window);
@@ -17554,6 +18043,17 @@ function validateTimeout(timeout, name) {
 	if (typeof timeout !== "number" || timeout < 0 || !Number.isFinite(timeout)) throw new TypeError(`${name} must be a non-negative finite number`);
 	return timeout;
 }
+/**
+* Options of `addScriptTag` and `addStyleTag`. The pinned client reads `path`
+* from disk into `content` before the call leaves the process, which this
+* runtime cannot do; every other shape reaches the pinned server check for a
+* `url` or `content` property unexamined, including a non-object argument.
+*/
+function assertAddTagOptions(method, options) {
+	if (options?.path !== void 0) throw new Error(`${method}: the \`path\` option is not supported; pass \`url\` or \`content\`.`);
+	if (!options?.url && !options?.content) throw new Error("Provide an object with a `url`, `path` or `content` property");
+	return options;
+}
 /** Returns the normalized `delay`, unwrapped like the pointer options. */
 function assertPageActionOptions(method, options, supported = []) {
 	if (!options) return void 0;
@@ -17580,7 +18080,7 @@ function assertPointerActionOptions(method, options) {
 		"scroll",
 		"strict"
 	];
-	if (method === "click" || method === "dblclick") supported.push("button", "delay", "modifiers");
+	if (method === "click" || method === "dblclick") supported.push("button", "delay", "modifiers", "steps");
 	if (method === "click") supported.push("clickCount");
 	if (method === "hover") supported.push("modifiers");
 	if (!options) return {};
@@ -17593,7 +18093,11 @@ function assertPointerActionOptions(method, options) {
 		const value = options[key];
 		if (value instanceof Boolean) options[key] = value.valueOf();
 	}
-	for (const key of ["delay", "clickCount"]) {
+	for (const key of [
+		"delay",
+		"clickCount",
+		"steps"
+	]) {
 		const value = options[key];
 		if (value instanceof Number) options[key] = value.valueOf();
 	}
@@ -17611,8 +18115,12 @@ function assertPointerActionOptions(method, options) {
 		"right"
 	].includes(options.button)) throw new TypeError("button: expected one of (left|right|middle)");
 	if (options.scroll !== void 0 && !["auto", "none"].includes(options.scroll)) throw new TypeError("scroll: expected one of (auto|none)");
-	for (const key of ["delay", "clickCount"]) if (options[key] !== void 0 && (typeof options[key] !== "number" || !Number.isFinite(options[key]))) throw new TypeError(`${key}: expected number`);
-	if (options.clickCount !== void 0 && !Number.isInteger(options.clickCount)) throw new TypeError(`clickCount: expected integer, got float ${options.clickCount}`);
+	for (const key of [
+		"delay",
+		"clickCount",
+		"steps"
+	]) if (options[key] !== void 0 && (typeof options[key] !== "number" || !Number.isFinite(options[key]))) throw new TypeError(`${key}: expected number`);
+	for (const key of ["clickCount", "steps"]) if (options[key] !== void 0 && !Number.isInteger(options[key])) throw new TypeError(`${key}: expected integer, got float ${options[key]}`);
 	if (options.modifiers !== void 0 && (!Array.isArray(options.modifiers) || options.modifiers.some((value) => ![
 		"Alt",
 		"Control",
@@ -17659,7 +18167,8 @@ function assertElementHandleStateOptions(state, options) {
 		"disabled",
 		"editable"
 	].includes(state)) throw new Error(`Unsupported element state: ${state}`);
-	for (const key of Object.keys(options)) if (key !== "timeout") throw new Error(`Unsupported waitForElementState option: ${key}`);
+	for (const key of Object.keys(options)) if (key !== "signal" && key !== "timeout") throw new Error(`Unsupported waitForElementState option: ${key}`);
+	validateSignal("waitForElementState", options.signal);
 	if (options.timeout !== void 0) validateTimeout(options.timeout, "waitForElementState timeout");
 }
 /**
@@ -17681,9 +18190,56 @@ function isRetryableQueryError(error) {
 	const message = asError(error).message;
 	return message.startsWith("No elements found for locator") || message === "Element is not connected";
 }
+/**
+* Mirrors the pinned client's convertSelectOptionValues, which lets the first
+* entry decide whether the list is read as plain values/labels, followed by the
+* FrameSelectOptionParams protocol validation of every entry.
+*/
+function selectOptionValues(values, evaluation) {
+	if (values === null) return [];
+	const list = Array.isArray(values) ? values : [values];
+	list.forEach((value, index) => {
+		if (value === null) throw new Error(`options[${index}]: expected object, got null`);
+	});
+	if (list[0] instanceof AdapterElementHandle) return list.map((value) => value.valueForEvaluation(evaluation));
+	if (typeof list[0] === "string" || list[0] instanceof String) return list.map((value, index) => ({ valueOrLabel: validateString(value, `options[${index}].valueOrLabel`) }));
+	return list.map((value, index) => validateSelectOptionValue(value, `options[${index}]`));
+}
+function validateSelectOptionValue(value, name) {
+	if (typeof value !== "object") throw new Error(`${name}: expected object, got ${typeof value}`);
+	const source = value;
+	const option = {};
+	for (const key of [
+		"valueOrLabel",
+		"value",
+		"label"
+	]) if (source[key] !== void 0) option[key] = validateString(source[key], `${name}.${key}`);
+	if (source.index !== void 0) option.index = validateInteger(source.index, `${name}.index`);
+	return option;
+}
 function formatLocator(selector) {
 	return `locator('${selector.replace(/\\/g, "\\\\").replace(/'/g, "\\'")}')`;
 }
+/**
+* The call log line naming what a query waited for. A handle already holds its
+* element, so pinned ElementHandle diagnostics name no locator to wait for.
+*/
+function queryCallLog(selector) {
+	if (typeof selector !== "string") return "";
+	return `\nCall log:\n  - waiting for ${formatLocator(selector)}`;
+}
+/**
+* Pinned Playwright reports an InjectedScript fill rejection through the
+* calling member and the action's call log, not as the bare injected message:
+* `page.fill: Error: Element is not an <input>, <textarea> or [contenteditable]
+* element` followed by `Call log:`. `label` carries the Page form the way
+* performPointerAction derives its prefix.
+*/
+function injectedFillError(error, selector, label, apiMethod, force) {
+	const prefix = label.startsWith("page.fill(") ? "page.fill" : label.startsWith("elementHandle.") ? label : `locator.${apiMethod}`;
+	const waitingFor = typeof selector === "string" ? `\n  - waiting for ${formatLocator(selector)}` : "";
+	return new Error(`${prefix}: Error: ${error.message}\nCall log:${waitingFor}\n  - attempting fill action` + (force ? "" : "\n    - waiting for element to be visible, enabled and editable"), { cause: error });
+}
 function presentOriginalXPath(error, selector) {
 	const source = asError(error);
 	if (!selector.startsWith("//")) return source;