@enekesabel/playwright-lite 0.1.0 → 0.2.1

package/dist/index.mjs

@@ -14754,6 +14754,27 @@ function validateString(value, name) {
 	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;
@@ -15571,16 +15592,16 @@ var LocatorImpl = class LocatorImpl {
 		return this.ownerPage.resolveAll(this.selector).map((element) => this.ownerPage.elementHandleFor(element));
 	}
 	async getAttribute(name, options) {
-		return this.ownerPage.locatorGetAttribute(this.selector, this.label, name, options);
+		return withAbortPrefix("locator.getAttribute", () => this.ownerPage.locatorGetAttribute(this.selector, this.label, name, options));
 	}
 	async textContent(options) {
-		return this.ownerPage.locatorTextContent(this.selector, this.label, options);
+		return withAbortPrefix("locator.textContent", () => this.ownerPage.locatorTextContent(this.selector, this.label, options));
 	}
 	async innerText(options) {
-		return this.ownerPage.locatorInnerText(this.selector, this.label, options);
+		return withAbortPrefix("locator.innerText", () => this.ownerPage.locatorInnerText(this.selector, this.label, options));
 	}
 	async innerHTML(options) {
-		return this.ownerPage.locatorInnerHTML(this.selector, this.label, options);
+		return withAbortPrefix("locator.innerHTML", () => this.ownerPage.locatorInnerHTML(this.selector, this.label, options));
 	}
 	async allInnerTexts() {
 		return this.ownerPage.locatorAllInnerTexts(this.selector);
@@ -15589,19 +15610,19 @@ var LocatorImpl = class LocatorImpl {
 		return this.ownerPage.locatorAllTextContents(this.selector);
 	}
 	async inputValue(options) {
-		return this.ownerPage.locatorInputValue(this.selector, this.label, options);
+		return withAbortPrefix("locator.inputValue", () => this.ownerPage.locatorInputValue(this.selector, this.label, options));
 	}
 	async isEnabled(options) {
-		return this.ownerPage.locatorIsEnabled(this.selector, this.label, options);
+		return withAbortPrefix("locator.isEnabled", () => this.ownerPage.locatorIsEnabled(this.selector, this.label, options));
 	}
 	async isDisabled(options) {
-		return this.ownerPage.locatorIsDisabled(this.selector, this.label, options);
+		return withAbortPrefix("locator.isDisabled", () => this.ownerPage.locatorIsDisabled(this.selector, this.label, options));
 	}
 	async isChecked(options) {
-		return this.ownerPage.locatorIsChecked(this.selector, this.label, options);
+		return withAbortPrefix("locator.isChecked", () => this.ownerPage.locatorIsChecked(this.selector, this.label, options));
 	}
 	async isEditable(options) {
-		return this.ownerPage.locatorIsEditable(this.selector, this.label, options);
+		return withAbortPrefix("locator.isEditable", () => this.ownerPage.locatorIsEditable(this.selector, this.label, options));
 	}
 	async isVisible(options) {
 		return this.ownerPage.locatorIsVisible(this.selector, this.label, options);
@@ -15610,7 +15631,7 @@ var LocatorImpl = class LocatorImpl {
 		return !this.ownerPage.locatorIsVisible(this.selector, this.label, options);
 	}
 	async boundingBox(options) {
-		return this.ownerPage.locatorBoundingBox(this.selector, this.label, options);
+		return withAbortPrefix("locator.boundingBox", () => this.ownerPage.locatorBoundingBox(this.selector, this.label, options));
 	}
 	/**
 	* Captures the accessibility snapshot rooted at this locator's sole element.
@@ -15620,7 +15641,7 @@ var LocatorImpl = class LocatorImpl {
 	* not add frame traversal or browser-process behavior.
 	*/
 	async ariaSnapshot(options = {}) {
-		return this.ownerPage.locatorAriaSnapshot(this.selector, this.label, options);
+		return withAbortPrefix("locator.ariaSnapshot", () => this.ownerPage.locatorAriaSnapshot(this.selector, this.label, options));
 	}
 	/**
 	* The public Playwright matcher implementation calls this private-shaped
@@ -15641,7 +15662,7 @@ var LocatorImpl = class LocatorImpl {
 	}
 	async evaluate(pageFunction, arg, options) {
 		assertMaxArguments(arguments.length, 3);
-		return this.ownerPage.locatorEvaluate(this.selector, this.label, pageFunction, arg, options);
+		return withAbortPrefix("locator.evaluate", () => this.ownerPage.locatorEvaluate(this.selector, this.label, pageFunction, arg, options));
 	}
 	async evaluateAll(pageFunction, arg) {
 		assertMaxArguments(arguments.length, 2);
@@ -15654,26 +15675,45 @@ var LocatorImpl = class LocatorImpl {
 		});
 	}
 	async fill(value, options) {
-		rejectUnsupportedOptions("fill", options, ["noWaitAfter", "timeout"]);
-		await this.ownerPage.fillSelector(this.selector, value, this.label, options?.timeout);
+		rejectUnsupportedOptions("fill", options, [
+			"noWaitAfter",
+			"signal",
+			"timeout"
+		]);
+		await withAbortPrefix("locator.fill", () => this.ownerPage.fillSelector(this.selector, value, this.label, options?.timeout, void 0, true, options?.signal));
 	}
 	async setInputFiles(files, options) {
-		rejectUnsupportedOptions("setInputFiles", options, ["noWaitAfter", "timeout"]);
-		await this.ownerPage.setInputFilesSelector(this.selector, files, options, true);
+		rejectUnsupportedOptions("setInputFiles", options, [
+			"noWaitAfter",
+			"signal",
+			"timeout"
+		]);
+		await withAbortPrefix("locator.setInputFiles", () => this.ownerPage.setInputFilesSelector(this.selector, files, options, true));
 	}
 	async press(key, options) {
-		rejectUnsupportedOptions("press", options, ["noWaitAfter", "timeout"]);
-		await this.ownerPage.pressSelector(this.selector, key, this.label, options?.timeout);
+		const delay = rejectUnsupportedOptions("press", options, [
+			"delay",
+			"noWaitAfter",
+			"signal",
+			"timeout"
+		]);
+		await withAbortPrefix("locator.press", () => this.ownerPage.pressSelector(this.selector, key, this.label, options?.timeout, void 0, true, options?.signal, delay));
 	}
 	async focus(options) {
-		await this.ownerPage.focusSelector(this.selector, this.label, options);
+		rejectUnsupportedOptions("focus", options, ["signal", "timeout"]);
+		await withAbortPrefix("locator.focus", () => this.ownerPage.focusSelector(this.selector, this.label, options));
 	}
 	async blur(options) {
-		await this.ownerPage.blurSelector(this.selector, this.label, options);
+		rejectUnsupportedOptions("blur", options, ["signal", "timeout"]);
+		await withAbortPrefix("locator.blur", () => this.ownerPage.blurSelector(this.selector, this.label, options));
 	}
 	async clear(options) {
-		rejectUnsupportedOptions("clear", options, ["noWaitAfter", "timeout"]);
-		await this.ownerPage.fillSelector(this.selector, "", this.label, options?.timeout);
+		rejectUnsupportedOptions("clear", options, [
+			"noWaitAfter",
+			"signal",
+			"timeout"
+		]);
+		await withAbortPrefix("locator.clear", () => this.ownerPage.fillSelector(this.selector, "", this.label, options?.timeout, void 0, true, options?.signal));
 	}
 	async hover(options) {
 		await this.ownerPage.hoverSelector(this.selector, this.label, options?.timeout, void 0, {
@@ -15706,39 +15746,52 @@ var LocatorImpl = class LocatorImpl {
 		});
 	}
 	async dispatchEvent(type, eventInit = {}, options) {
-		rejectUnsupportedOptions("dispatchEvent", options, ["timeout"]);
-		await this.ownerPage.dispatchEventSelector(this.selector, type, eventInit, this.label, options?.timeout);
+		rejectUnsupportedOptions("dispatchEvent", options, ["signal", "timeout"]);
+		await withAbortPrefix("locator.dispatchEvent", () => this.ownerPage.dispatchEventSelector(this.selector, type, eventInit, this.label, options?.timeout, void 0, true, options?.signal));
 	}
 	async selectOption(values, options) {
-		rejectUnsupportedOptions("selectOption", options, ["noWaitAfter", "timeout"]);
-		return this.ownerPage.selectOptionSelector(this.selector, values, this.label, options?.timeout);
+		rejectUnsupportedOptions("selectOption", options, [
+			"noWaitAfter",
+			"signal",
+			"timeout"
+		]);
+		return withAbortPrefix("locator.selectOption", () => this.ownerPage.selectOptionSelector(this.selector, values, this.label, options?.timeout, void 0, true, options?.signal));
 	}
 	async selectText(options) {
-		rejectUnsupportedOptions("selectText", options, ["timeout"]);
-		await this.ownerPage.selectText(this.selector, this.label, options?.timeout);
+		rejectUnsupportedOptions("selectText", options, ["signal", "timeout"]);
+		await withAbortPrefix("locator.selectText", () => this.ownerPage.selectText(this.selector, this.label, options?.timeout, void 0, options?.signal));
 	}
 	async scrollIntoViewIfNeeded(options) {
-		rejectUnsupportedOptions("scrollIntoViewIfNeeded", options, ["timeout"]);
-		await this.ownerPage.scrollLocatorIntoView(this.selector, this.label, options?.timeout);
+		rejectUnsupportedOptions("scrollIntoViewIfNeeded", options, ["signal", "timeout"]);
+		await withAbortPrefix("locator.scrollIntoViewIfNeeded", () => this.ownerPage.scrollLocatorIntoView(this.selector, this.label, options?.timeout, void 0, options?.signal));
 	}
 	async type(text, options = {}) {
+		await withAbortPrefix("locator.type", () => this.typeText(text, options));
+	}
+	async pressSequentially(text, options = {}) {
+		await withAbortPrefix("locator.pressSequentially", () => this.typeText(text, options));
+	}
+	async typeText(text, options) {
 		rejectUnsupportedOptions("type", options, [
 			"delay",
 			"noWaitAfter",
+			"signal",
 			"timeout"
 		]);
-		await this.ownerPage.type(this.selector, text, options, this.label);
-	}
-	async pressSequentially(text, options = {}) {
-		await this.type(text, options);
+		await this.ownerPage.typeSelector(this.selector, text, options, this.label, true);
 	}
 	async waitFor(options = {}) {
 		const state = options.state ?? "visible";
-		rejectUnsupportedOptions("waitFor", options, ["state", "timeout"]);
-		await this.ownerPage.waitForState(this.selector, {
+		rejectUnsupportedOptions("waitFor", options, [
+			"signal",
+			"state",
+			"timeout"
+		]);
+		await withAbortPrefix("locator.waitFor", () => this.ownerPage.waitForState(this.selector, {
+			signal: options.signal,
 			state,
 			timeout: options.timeout
-		}, this.label);
+		}, this.label));
 	}
 };
 /**
@@ -15752,11 +15805,14 @@ 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;
+	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]) => {
@@ -15880,22 +15936,22 @@ var PageImpl = class PageImpl {
 		this.injected.hideHighlight();
 	}
 	async getAttribute(selector, name, options) {
-		return this.query(selector, `page.getAttribute(${JSON.stringify(selector)}, ${JSON.stringify(name)})`, options, false, (element) => element.getAttribute(name));
+		return withAbortPrefix("page.getAttribute", () => this.query(selector, `page.getAttribute(${JSON.stringify(selector)}, ${JSON.stringify(name)})`, options, false, (element) => element.getAttribute(name)));
 	}
 	async textContent(selector, options) {
-		return this.query(selector, `page.textContent(${JSON.stringify(selector)})`, options, false, (element) => element.textContent);
+		return withAbortPrefix("page.textContent", () => this.query(selector, `page.textContent(${JSON.stringify(selector)})`, options, false, (element) => element.textContent));
 	}
 	async inputValue(selector, options) {
-		return this.query(selector, `page.inputValue(${JSON.stringify(selector)})`, options, false, (element) => this.inputValueForElement(element));
+		return withAbortPrefix("page.inputValue", () => this.query(selector, `page.inputValue(${JSON.stringify(selector)})`, options, false, (element) => this.inputValueForElement(element)));
 	}
 	async isEnabled(selector, options) {
-		return this.queryState(selector, "enabled", options, false);
+		return withAbortPrefix("page.isEnabled", () => this.queryState(selector, "enabled", options, false));
 	}
 	async isDisabled(selector, options) {
-		return this.queryState(selector, "disabled", options, false);
+		return withAbortPrefix("page.isDisabled", () => this.queryState(selector, "disabled", options, false));
 	}
 	async isChecked(selector, options) {
-		return this.queryState(selector, "checked", options, false);
+		return withAbortPrefix("page.isChecked", () => this.queryState(selector, "checked", options, false));
 	}
 	async $(selector, options = {}) {
 		assertDollarOptions(options);
@@ -15905,7 +15961,7 @@ var PageImpl = class PageImpl {
 		return this.resolveAll(selector).map((element) => this.elementHandleFor(element));
 	}
 	async waitForSelector(selector, options = {}) {
-		return await this.waitForSelectorInRoot(this.document, selector, options);
+		return await withAbortPrefix("page.waitForSelector", () => this.waitForSelectorInRoot(this.document, selector, options));
 	}
 	async waitForSelectorWithinElement(root, selector, options = {}) {
 		return await this.waitForSelectorInRoot(root, selector, options, false);
@@ -15950,7 +16006,7 @@ var PageImpl = class PageImpl {
 		const isArray = expression === "to.have.count" || expression.endsWith(".array");
 		const elements = this.resolveAll(selector);
 		if (!elements.length) return missingExpectationAttempt(expression, expectOptions);
-		if (!isArray && elements.length > 1) throw new Error(`strict mode violation: locator ${JSON.stringify(selector)} resolved to ${elements.length} elements`);
+		if (!isArray && elements.length > 1) throw presentOriginalXPath(this.injected.strictModeViolationError(this.injected.parseSelector(selector), elements), selector);
 		const injectedOptions = Object.fromEntries(Object.entries(options).filter(([key]) => key !== "timeout" && key !== "signal"));
 		if (expression === "to.match.aria" && typeof injectedOptions.expectedValue === "string") injectedOptions.expectedValue = parseAriaExpectation(injectedOptions.expectedValue);
 		const result = await this.injected.expect(elements[0], {
@@ -15976,6 +16032,7 @@ var PageImpl = class PageImpl {
 	*/
 	async performPointerAction(selector, label, action, options, deadline, checked, apiMethod = action) {
 		try {
+			this.attachActionSignal(deadline, options.signal);
 			while (true) {
 				this.assertActionDeadline(deadline, action);
 				try {
@@ -16035,12 +16092,13 @@ 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)) {
+	async fillSelector(selector, value, label, timeout, deadline = this.createActionDeadline(timeout), strict = true, signal) {
+		this.attachActionSignal(deadline, signal);
 		const { element } = await this.retryActionability(selector, label, "fill", [
 			"visible",
 			"enabled",
 			"editable"
-		], false, deadline);
+		], false, deadline, void 0, void 0, strict);
 		this.assertActionDeadline(deadline, "fill");
 		const result = this.actionableInjected.fill(element, value);
 		if (result === "error:notconnected") throw new Error(`Element is not connected for locator ${label}`);
@@ -16050,14 +16108,18 @@ var PageImpl = class PageImpl {
 		if (!inputTarget) throw new Error(`Element is not connected for locator ${label}`);
 		this.insertFilledText(inputTarget, value, deadline, "fill");
 	}
-	async pressSelector(selector, key, label, timeout, deadline = this.createActionDeadline(timeout)) {
-		const element = await this.query(selector, label, { timeout }, true, (candidate) => candidate, deadline);
+	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, {
+			signal,
+			timeout
+		}, strict, (candidate) => candidate, deadline);
 		this.assertActionDeadline(deadline, "press");
 		this.focusElement(element);
-		await this.keyboard.press(key, {}, deadline);
+		await this.keyboard.press(key, { delay }, deadline);
 	}
-	async focusSelector(selector, label, options) {
-		await this.query(selector, label, options, true, (element) => {
+	async focusSelector(selector, label, options, strict = true) {
+		await this.query(selector, label, options, strict, (element) => {
 			if (this.actionableInjected.focusNode(element) === "error:notconnected") throw new Error(`Element is not connected for locator ${label}`);
 		});
 	}
@@ -16075,27 +16137,35 @@ var PageImpl = class PageImpl {
 		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)) {
+	async selectOptionSelector(selector, values, label, timeout, deadline = this.createActionDeadline(timeout), strict = true, signal) {
+		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);
+			const { element } = await this.retryActionability(selector, label, "select option", ["visible", "enabled"], false, deadline, void 0, void 0, strict);
 			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");
 			const remaining = deadline.expiresAt - Date.now();
 			if (remaining <= 0) throw new AdapterTimeoutError(`select option: Timeout ${deadline.timeout}ms exceeded. ${lastError.message}`, { cause: lastError });
-			await this.wait(Math.min(ACTION_RETRY_DELAY, remaining));
+			try {
+				await this.waitWithinActionDeadline(Math.min(ACTION_RETRY_DELAY, remaining), deadline, "select option");
+			} catch (error) {
+				if (error instanceof AdapterTimeoutError) throw new AdapterTimeoutError(`select option: Timeout ${deadline.timeout}ms exceeded. ${lastError.message}`, { cause: lastError });
+				throw error;
+			}
 		}
 	}
-	async selectText(selector, label, timeout, deadline = this.createActionDeadline(timeout)) {
+	async selectText(selector, label, timeout, deadline = this.createActionDeadline(timeout), signal) {
+		this.attachActionSignal(deadline, signal);
 		const { element } = await this.retryActionability(selector, label, "select text", ["visible"], false, deadline);
 		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)) {
+	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);
 		this.assertActionDeadline(deadline, "scroll into view");
 		this.scrollIntoViewIfNeeded(element);
@@ -16105,6 +16175,7 @@ var PageImpl = class PageImpl {
 		try {
 			await this.waitForSelectorInRoot(this.document, selector, {
 				state: options.state,
+				signal: options.signal,
 				strict: true,
 				timeout: options.timeout
 			});
@@ -16118,7 +16189,11 @@ var PageImpl = class PageImpl {
 		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);
-		await this.query(selector, selector, { timeout: options.timeout }, strict || options.strict === true, (element) => {
+		this.attachActionSignal(deadline, options.signal);
+		await this.query(selector, selector, {
+			signal: options.signal,
+			timeout: options.timeout
+		}, strict || options.strict === true, (element) => {
 			this.assertActionDeadline(deadline, "setInputFiles");
 			const input = this.injected.retarget(element, "follow-label");
 			if (!input || !input.isConnected) throw new Error("Element is not connected");
@@ -16161,28 +16236,30 @@ var PageImpl = class PageImpl {
 		this.defaultNavigationTimeout = validateTimeout(timeout, "Default navigation timeout");
 	}
 	async innerText(selector, options) {
-		return this.query(selector, `page.innerText(${JSON.stringify(selector)})`, options, false, (element) => {
+		return withAbortPrefix("page.innerText", () => this.query(selector, `page.innerText(${JSON.stringify(selector)})`, options, false, (element) => {
 			if (element.namespaceURI !== "http://www.w3.org/1999/xhtml") throw new Error("Node is not an HTMLElement");
 			return element.innerText;
-		});
+		}));
 	}
 	async innerHTML(selector, options) {
-		return this.query(selector, `page.innerHTML(${JSON.stringify(selector)})`, options, false, (element) => element.innerHTML);
+		return withAbortPrefix("page.innerHTML", () => this.query(selector, `page.innerHTML(${JSON.stringify(selector)})`, options, false, (element) => element.innerHTML));
 	}
 	async isEditable(selector, options) {
-		return this.queryState(selector, "editable", options, false);
+		return withAbortPrefix("page.isEditable", () => this.queryState(selector, "editable", options, false));
 	}
 	async isVisible(selector, options) {
-		assertQueryOptions(options, true);
-		this.resolveTimeout(options?.timeout, DEFAULT_QUERY_TIMEOUT);
-		if (options?.signal?.aborted) throw queryAborted(options.signal);
+		return this.selectorIsVisible("isVisible", selector, options);
+	}
+	async isHidden(selector, options) {
+		return !this.selectorIsVisible("isHidden", selector, options);
+	}
+	selectorIsVisible(method, selector, options) {
+		assertQueryOptions(options, ["strict", "timeout"]);
+		if (options?.strict !== void 0 && typeof options.strict !== "boolean") throw new TypeError(`${method} strict must be a boolean`);
 		const element = options?.strict ? this.resolveLocatorElement(selector, true) : this.resolveAll(selector)[0];
 		if (!element) return false;
 		return this.elementState(element, "visible").matches;
 	}
-	async isHidden(selector, options) {
-		return !await this.isVisible(selector, options);
-	}
 	async click(selector, options) {
 		assertPointerActionOptions("click", options);
 		await this.clickSelector(selector, `page.click(${JSON.stringify(selector)})`, options?.timeout, void 0, {
@@ -16191,28 +16268,45 @@ var PageImpl = class PageImpl {
 		});
 	}
 	async fill(selector, value, options) {
-		assertPageActionOptions("fill", options, ["noWaitAfter"]);
-		await this.fillSelector(selector, value, `page.fill(${JSON.stringify(selector)})`, options?.timeout);
+		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));
 	}
 	async setInputFiles(selector, files, options) {
-		await this.setInputFilesSelector(selector, files, options);
+		await withAbortPrefix("page.setInputFiles", () => this.setInputFilesSelector(selector, files, options));
 	}
 	async press(selector, key, options) {
-		assertPageActionOptions("press", options, ["noWaitAfter"]);
-		await this.pressSelector(selector, key, `page.press(${JSON.stringify(selector)})`, options?.timeout);
+		const delay = assertPageActionOptions("press", options, [
+			"delay",
+			"noWaitAfter",
+			"strict"
+		]);
+		await withAbortPrefix("page.press", () => this.pressSelector(selector, key, `page.press(${JSON.stringify(selector)})`, options?.timeout, void 0, options?.strict === true, options?.signal, delay));
+	}
+	async type(selector, text, options) {
+		await withAbortPrefix("page.type", () => this.typeSelector(selector, text, options, `page.type(${JSON.stringify(selector)})`, options?.strict === true));
 	}
-	async type(selector, text, options, label = `page.type(${JSON.stringify(selector)})`) {
-		assertPageActionOptions("type", options, ["delay", "noWaitAfter"]);
+	async typeSelector(selector, text, options, label, strict) {
+		const delay = assertPageActionOptions("type", options, [
+			"delay",
+			"noWaitAfter",
+			"strict"
+		]);
 		const deadline = this.createActionDeadline(options?.timeout);
-		for (const character of text) {
-			if (keyboardLayout.has(character)) await this.pressSelector(selector, character, label, options?.timeout, deadline);
-			else await this.insertTextSelector(selector, character, label, deadline);
-			if (options?.delay && options.delay > 0) await this.waitWithinActionDeadline(options.delay, deadline, "press");
-		}
+		this.attachActionSignal(deadline, options?.signal);
+		await this.query(selector, label, {
+			signal: options?.signal,
+			timeout: options?.timeout
+		}, strict, (element) => {
+			if (this.actionableInjected.focusNode(element, true) === "error:notconnected") throw new Error("Element is not connected");
+		}, deadline);
+		await this.keyboard.type(text, { delay }, deadline);
 	}
 	async focus(selector, options) {
-		assertPageActionOptions("focus", options);
-		await this.focusSelector(selector, `page.focus(${JSON.stringify(selector)})`, options);
+		assertPageActionOptions("focus", options, ["strict"]);
+		await withAbortPrefix("page.focus", () => this.focusSelector(selector, `page.focus(${JSON.stringify(selector)})`, {
+			signal: options?.signal,
+			timeout: options?.timeout
+		}, options?.strict === true));
 	}
 	async hover(selector, options) {
 		await this.hoverSelector(selector, `page.hover(${JSON.stringify(selector)})`, options?.timeout, void 0, {
@@ -16221,8 +16315,8 @@ var PageImpl = class PageImpl {
 		});
 	}
 	async selectOption(selector, values, options) {
-		assertPageActionOptions("selectOption", options, ["noWaitAfter"]);
-		return this.selectOptionSelector(selector, values, `page.selectOption(${JSON.stringify(selector)})`, options?.timeout);
+		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));
 	}
 	async check(selector, options) {
 		await this.setCheckedSelector(selector, true, `page.check(${JSON.stringify(selector)})`, {
@@ -16250,10 +16344,14 @@ var PageImpl = class PageImpl {
 	}
 	async dispatchEvent(selector, type, eventInit = {}, options) {
 		assertPageDispatchEventOptions(options);
-		await this.dispatchEventSelector(selector, type, eventInit, `page.dispatchEvent(${JSON.stringify(selector)})`, options?.timeout, void 0, options?.strict === true);
+		await withAbortPrefix("page.dispatchEvent", () => this.dispatchEventSelector(selector, type, eventInit, `page.dispatchEvent(${JSON.stringify(selector)})`, options?.timeout, void 0, options?.strict === true, options?.signal));
 	}
-	async dispatchEventSelector(selector, type, eventInit, label, timeout, deadline = this.createActionDeadline(timeout), strict = true) {
-		await this.query(selector, label, { timeout }, strict, (element) => this.actionableInjected.dispatchEvent(element, type, eventInit), deadline);
+	async dispatchEventSelector(selector, type, eventInit, label, timeout, deadline = this.createActionDeadline(timeout), strict = true, signal) {
+		this.attachActionSignal(deadline, signal);
+		await this.query(selector, label, {
+			signal,
+			timeout
+		}, strict, (element) => this.actionableInjected.dispatchEvent(element, type, eventInit), deadline);
 	}
 	/**
 	* Pinned 26a9e47 client/frame.ts and server/frames.ts default to load,
@@ -16266,15 +16364,16 @@ var PageImpl = class PageImpl {
 	*/
 	async goto(url, options = {}) {
 		for (const [key, value] of Object.entries(options)) if (!["timeout", "waitUntil"].includes(key) && value !== void 0) throw new Error(`Unsupported Playwright option: goto.${key}`);
-		const waitUntil = options.waitUntil ?? "load";
-		if (![
-			"commit",
-			"domcontentloaded",
-			"load"
-		].includes(waitUntil)) throw new Error(`Unsupported waitUntil value: ${waitUntil}`);
+		const waitUntil = verifyLoadState("waitUntil", options.waitUntil === void 0 ? "load" : options.waitUntil);
+		if (waitUntil === "networkidle") throw new Error(`Unsupported waitUntil value: ${waitUntil}`);
 		const timeout = this.resolveTimeout(options.timeout, DEFAULT_NAVIGATION_TIMEOUT, true);
 		if (typeof url !== "string") throw new Error("goto URL must be a string");
-		const target = new URL(url, this.document.baseURI);
+		let target;
+		try {
+			target = new URL(url, this.document.baseURI);
+		} catch {
+			throw new Error("page.goto: Cannot navigate to invalid URL");
+		}
 		if (![
 			"http:",
 			"https:",
@@ -16321,10 +16420,12 @@ var PageImpl = class PageImpl {
 	* and rendering. There is no frame traversal or protocol transport here.
 	*/
 	async ariaSnapshot(options = {}) {
-		assertAriaSnapshotOptions(options);
-		if (options.signal?.aborted) throw queryAborted(options.signal);
-		await this.waitForDocumentParser(options);
-		return this.injectedAriaSnapshot(this.document.body ?? this.document.documentElement, options);
+		return withAbortPrefix("page.ariaSnapshot", async () => {
+			assertAriaSnapshotOptions(options);
+			if (options.signal?.aborted) throw actionAborted(options.signal, false);
+			await this.waitForDocumentParser(options);
+			return this.injectedAriaSnapshot(this.document.body ?? this.document.documentElement, options);
+		});
 	}
 	injectedAriaSnapshot(element, options = {}) {
 		return this.injected.ariaSnapshot(element, {
@@ -16346,7 +16447,7 @@ var PageImpl = class PageImpl {
 				else resolve();
 			};
 			const ready = () => settle();
-			const aborted = () => settle(queryAborted(options.signal));
+			const aborted = () => settle(actionAborted(options.signal, true));
 			this.window.addEventListener("DOMContentLoaded", ready, { once: true });
 			options.signal?.addEventListener("abort", aborted, { once: true });
 			if (timeout > 0) timeoutId = this.window.setTimeout(() => settle(new AdapterTimeoutError(`page.ariaSnapshot: Timeout ${timeout}ms exceeded.`)), timeout);
@@ -16512,17 +16613,25 @@ var PageImpl = class PageImpl {
 			expiresAt: effectiveTimeout === 0 ? Infinity : Date.now() + effectiveTimeout
 		};
 	}
+	attachActionSignal(deadline, signal) {
+		deadline.signal = signal;
+		if (signal?.aborted) throw actionAborted(signal, false);
+	}
 	assertActionDeadline(deadline, actionName) {
+		if (deadline?.signal?.aborted) throw actionAborted(deadline.signal, true);
 		if (deadline && Date.now() >= deadline.expiresAt) throw new AdapterTimeoutError(`${actionName}: Timeout ${deadline.timeout}ms exceeded.`);
 	}
 	checkKeyboardActionDeadline(deadline) {
 		this.assertActionDeadline(deadline, "press");
 	}
+	async waitKeyboardDelay(durationMs, deadline) {
+		await this.waitWithinActionDeadline(durationMs, deadline, "press");
+	}
 	async waitWithinActionDeadline(durationMs, deadline, actionName) {
 		this.assertActionDeadline(deadline, actionName);
 		if (!durationMs || durationMs <= 0) return;
 		const remaining = deadline ? deadline.expiresAt - Date.now() : durationMs;
-		await this.wait(Math.min(durationMs, remaining));
+		if (!await waitForExpectationRetry(this.window, Math.min(durationMs, remaining), deadline?.signal) && deadline?.signal) throw actionAborted(deadline.signal, true);
 		this.assertActionDeadline(deadline, actionName);
 	}
 	async wait(durationMs) {
@@ -16566,9 +16675,7 @@ var PageImpl = class PageImpl {
 		return this.queryState(selector, "editable", options, true, label);
 	}
 	locatorIsVisible(selector, label, options) {
-		assertQueryOptions(options, false);
-		this.resolveTimeout(options?.timeout, DEFAULT_QUERY_TIMEOUT);
-		if (options?.signal?.aborted) throw queryAborted(options.signal);
+		assertQueryOptions(options, ["timeout"]);
 		const element = this.resolveLocatorElement(selector, true);
 		if (!element) return false;
 		return this.elementState(element, "visible").matches;
@@ -16578,7 +16685,7 @@ var PageImpl = class PageImpl {
 	}
 	async locatorAriaSnapshot(selector, label, options = {}) {
 		assertAriaSnapshotOptions(options);
-		if (options.signal?.aborted) throw queryAborted(options.signal);
+		if (options.signal?.aborted) throw actionAborted(options.signal, false);
 		if (options.mode === "ai") return this.injectedAriaSnapshot(this.queryElement(selector, label, true), options);
 		return this.query(selector, label, {
 			signal: options.signal,
@@ -16635,13 +16742,16 @@ var PageImpl = class PageImpl {
 		const state = options.state ?? "visible";
 		const timeout = this.resolveTimeout(options.timeout, DEFAULT_ACTION_TIMEOUT);
 		const deadline = timeout === 0 ? Infinity : Date.now() + timeout;
+		const signal = options.signal;
+		if (signal?.aborted) throw actionAborted(signal, false);
 		while (true) {
 			const element = root instanceof this.window.Element ? this.resolveWithinElement(root, selector, options.strict === true) : this.resolveLocatorElement(selector, options.strict === true);
 			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}`);
-			await this.wait(Math.min(QUERY_RETRY_DELAY, deadline - Date.now()));
+			const delay = Math.min(QUERY_RETRY_DELAY, deadline - Date.now());
+			if (!await waitForExpectationRetry(this.window, delay, signal)) throw actionAborted(signal, true);
 		}
 	}
 	async elementMatchesState(element, state) {
@@ -16658,10 +16768,14 @@ var PageImpl = class PageImpl {
 		return result.matches;
 	}
 	async query(selector, label, options, strict, evaluate, actionDeadline) {
-		assertQueryOptions(options, !strict);
+		assertQueryOptions(options, strict ? ["signal", "timeout"] : [
+			"signal",
+			"strict",
+			"timeout"
+		]);
 		const timeout = actionDeadline?.timeout ?? this.resolveTimeout(options?.timeout, DEFAULT_QUERY_TIMEOUT);
 		const signal = options?.signal;
-		if (signal?.aborted) throw queryAborted(signal);
+		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));
@@ -16670,7 +16784,7 @@ var PageImpl = class PageImpl {
 			const remaining = deadline - Date.now();
 			if (remaining <= 0) throw new AdapterTimeoutError(`Timeout ${timeout}ms exceeded.\nCall log:\n  - waiting for ${formatLocator(selector)}`, { cause: error });
 			const delay = Math.min(QUERY_RETRY_DELAY, remaining);
-			if (!await waitForExpectationRetry(this.window, delay, signal)) throw queryAborted(signal);
+			if (!await waitForExpectationRetry(this.window, delay, signal)) throw actionAborted(signal, true);
 		}
 	}
 	queryElement(selector, label, strict) {
@@ -16693,16 +16807,23 @@ var PageImpl = class PageImpl {
 		throw new Error(`Element is not ${result.missingState}`);
 	}
 	async waitForActionDeadline(operation, deadline, timeoutError) {
-		if (!deadline || deadline.expiresAt === Infinity) return operation;
-		if (Date.now() >= deadline.expiresAt) throw timeoutError();
+		if (deadline?.signal?.aborted) throw actionAborted(deadline.signal, true);
+		if (deadline && Date.now() >= deadline.expiresAt) throw timeoutError();
+		if (!deadline) return operation;
 		let timeoutHandle;
+		let onAbort;
 		try {
 			return await new Promise((resolve, reject) => {
-				timeoutHandle = this.window.setTimeout(() => reject(timeoutError()), Math.max(0, deadline.expiresAt - Date.now()));
+				if (deadline.expiresAt !== Infinity) timeoutHandle = this.window.setTimeout(() => reject(timeoutError()), Math.max(0, deadline.expiresAt - Date.now()));
+				if (deadline.signal) {
+					onAbort = () => reject(actionAborted(deadline.signal, true));
+					deadline.signal.addEventListener("abort", onAbort, { once: true });
+				}
 				operation.then(resolve, reject);
 			});
 		} finally {
 			if (timeoutHandle !== void 0) this.window.clearTimeout(timeoutHandle);
+			if (onAbort) deadline.signal?.removeEventListener("abort", onAbort);
 		}
 	}
 	actionabilityDeadlineError(element, states) {
@@ -16717,7 +16838,7 @@ var PageImpl = class PageImpl {
 		}
 		return /* @__PURE__ */ new Error("Element is not stable");
 	}
-	async retryActionability(selector, label, actionName, states, checkHitTarget, deadline, position, pointerOptions) {
+	async retryActionability(selector, label, actionName, states, checkHitTarget, deadline, position, pointerOptions, strict = pointerOptions?.strict ?? true) {
 		let lastError;
 		let retry = 0;
 		const log = [];
@@ -16729,7 +16850,7 @@ var PageImpl = class PageImpl {
 		while (true) {
 			if (Date.now() >= deadline.expiresAt) throwTimeout();
 			try {
-				const element = this.resolvePointerElement(selector, label, pointerOptions?.strict ?? true);
+				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 (Date.now() >= deadline.expiresAt) throwTimeout();
@@ -16776,7 +16897,12 @@ var PageImpl = class PageImpl {
 					if (log.length > 60) log.splice(0, log.length - 60);
 				}
 				if (remaining <= 0) throw timeoutError();
-				await this.wait(Math.min(delay, remaining));
+				try {
+					await this.waitWithinActionDeadline(Math.min(delay, remaining), deadline, actionName);
+				} catch (error) {
+					if (error instanceof AdapterTimeoutError) throw timeoutError();
+					throw error;
+				}
 			}
 		}
 	}
@@ -16969,8 +17095,8 @@ var PageImpl = class PageImpl {
 		this.assertActionDeadline(deadline, "press");
 		this.insertPressedText(element, text, inputType, eventData, deadline);
 	}
-	async insertTextSelector(selector, text, label, deadline) {
-		const element = await this.query(selector, label, { timeout: deadline.timeout }, true, (candidate) => candidate, deadline);
+	async insertTextSelector(selector, text, label, deadline, strict = true) {
+		const element = await this.query(selector, label, { timeout: deadline.timeout }, strict, (candidate) => candidate, deadline);
 		this.assertActionDeadline(deadline, "press");
 		this.focusElement(element);
 		this.insertKeyboardText(element, text, "insertText", text, deadline);
@@ -17213,25 +17339,49 @@ var BrowserKeyboard = class {
 	async up(key, deadline) {
 		await this.upForTarget(key, deadline);
 	}
-	async insertText(text) {
-		this.page.insertKeyboardText(this.activeTarget(), text);
+	async insertText(text, deadline) {
+		this.page.insertKeyboardText(this.activeTarget(), text, "insertText", text, deadline);
 	}
-	async type(text, options = {}) {
+	async type(text, options = {}, deadline) {
 		const delay = options.delay || void 0;
-		for (const character of text) if (keyboardLayout.has(character)) await this.press(character, { delay });
+		for (const character of text) if (keyboardLayout.has(character)) await this.press(character, { delay }, deadline);
 		else {
-			if (delay) await this.wait(delay);
-			await this.insertText(character);
+			if (delay) await this.page.waitKeyboardDelay(delay, deadline);
+			await this.insertText(character, deadline);
 		}
 	}
 	async press(key, options = {}, deadline) {
 		const tokens = splitKeyboardShortcut(key);
 		const target = tokens.at(-1);
-		for (const modifier of tokens.slice(0, -1)) await this.down(modifier, deadline);
-		await this.down(target, deadline);
-		if (options.delay) await this.wait(options.delay, deadline);
-		await this.up(target, deadline);
-		for (const modifier of tokens.slice(0, -1).reverse()) await this.up(modifier, deadline);
+		const modifiers = tokens.slice(0, -1);
+		const held = /* @__PURE__ */ new Set();
+		try {
+			for (const modifier of modifiers) {
+				held.add(modifier);
+				await this.down(modifier, deadline);
+			}
+			held.add(target);
+			await this.down(target, deadline);
+			if (options.delay) await this.page.waitKeyboardDelay(options.delay, deadline);
+			await this.up(target, deadline);
+			held.delete(target);
+			for (const modifier of modifiers.reverse()) {
+				await this.up(modifier, deadline);
+				held.delete(modifier);
+			}
+		} catch (error) {
+			this.releaseKeys(held);
+			throw error;
+		}
+	}
+	releaseKeys(keys) {
+		for (const key of keys) {
+			const description = keyboardLayout.get(resolveKeyboardKey(key, this.page.window));
+			if (!description) continue;
+			this.pressedKeys.delete(description.code);
+			this.keydownState.delete(description.code);
+			if (isModifier(description.key)) this.pressedModifiers.delete(description.key);
+		}
 	}
 	async downForTarget(key, deadline) {
 		this.page.checkKeyboardActionDeadline(deadline);
@@ -17288,13 +17438,6 @@ var BrowserKeyboard = class {
 		};
 		return description;
 	}
-	async wait(delay, deadline) {
-		this.page.checkKeyboardActionDeadline(deadline);
-		const remaining = deadline ? Math.max(0, deadline.expiresAt - Date.now()) : delay;
-		if (deadline && remaining <= 0) this.page.checkKeyboardActionDeadline(deadline);
-		await new Promise((resolve) => this.page.window.setTimeout(resolve, Math.min(delay, remaining)));
-		this.page.checkKeyboardActionDeadline(deadline);
-	}
 	async waitForKeyboardPhase(deadline) {
 		this.page.checkKeyboardActionDeadline(deadline);
 		await new Promise((resolve) => this.page.window.setTimeout(resolve));
@@ -17411,12 +17554,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;
 }
+/** Returns the normalized `delay`, unwrapped like the pointer options. */
 function assertPageActionOptions(method, options, supported = []) {
-	if (!options) return;
-	const unsupported = Object.keys(options).filter((key) => options[key] !== void 0 && key !== "timeout" && !supported.includes(key));
+	if (!options) return void 0;
+	const unsupported = Object.keys(options).filter((key) => options[key] !== void 0 && key !== "signal" && key !== "timeout" && !supported.includes(key));
 	if (unsupported.length > 0) throw new Error(`${method}(): unsupported options: ${unsupported.join(", ")}. Unsupported Playwright option(s) are not supported by the single-document adapter.`);
+	validateSignal(method, options.signal);
 	if (options.timeout !== void 0) validateTimeout(options.timeout, `${method} timeout`);
 	if (supported.includes("noWaitAfter")) validateNoWaitAfter(method, options.noWaitAfter);
+	const delay = supported.includes("delay") ? validateDelay(options.delay) : void 0;
+	if (supported.includes("strict") && options.strict !== void 0 && typeof options.strict !== "boolean") throw new TypeError(`${method} strict must be a boolean`);
+	return delay;
 }
 function assertPageDispatchEventOptions(options) {
 	assertPageActionOptions("dispatchEvent", options, ["strict"]);
@@ -17424,6 +17572,7 @@ function assertPageDispatchEventOptions(options) {
 }
 function assertPointerActionOptions(method, options) {
 	const supported = [
+		"signal",
 		"noWaitAfter",
 		"position",
 		"trial",
@@ -17476,19 +17625,22 @@ function assertPointerActionOptions(method, options) {
 }
 function assertAriaSnapshotOptions(options) {
 	queryTimeout(options.timeout);
-	if (options.signal !== void 0 && !(options.signal instanceof AbortSignal)) throw new TypeError("ARIA snapshot signal must be an AbortSignal");
+	validateSignal("ARIA snapshot", options.signal);
 }
-function assertQueryOptions(options, allowsStrict) {
+function assertQueryOptions(options, allowed) {
 	if (!options) return;
-	for (const key of Object.keys(options)) if (key !== "signal" && key !== "timeout" && !(allowsStrict && key === "strict")) throw new Error(`Unsupported query option: ${key}`);
-	if (options.signal !== void 0 && !(options.signal instanceof AbortSignal)) throw new TypeError("Query signal must be an AbortSignal");
-	if (!allowsStrict && "strict" in options) throw new Error("Locator query options do not support strict");
+	for (const key of Object.keys(options)) {
+		if (key === "signal" && options.signal === void 0) continue;
+		if (!allowed.includes(key)) throw new Error(`Unsupported query option: ${key}`);
+	}
+	validateSignal("Query", options.signal);
 }
 function assertDollarOptions(options) {
 	for (const key of Object.keys(options)) if (key !== "strict") throw new Error(`Unsupported query option: ${key}`);
 }
 function assertWaitForSelectorOptions(options, allowsStrict) {
-	for (const key of Object.keys(options)) if (key !== "state" && key !== "timeout" && !(allowsStrict && key === "strict")) throw new Error(`Unsupported waitForSelector option: ${key}`);
+	for (const key of Object.keys(options)) if (key !== "signal" && key !== "state" && key !== "timeout" && !(allowsStrict && key === "strict")) throw new Error(`Unsupported waitForSelector option: ${key}`);
+	validateSignal("waitForSelector", options.signal);
 	if (!allowsStrict && "strict" in options) throw new Error("ElementHandle waitForSelector does not support strict");
 	if (options.state !== void 0 && ![
 		"attached",
@@ -17510,6 +17662,21 @@ function assertElementHandleStateOptions(state, options) {
 	for (const key of Object.keys(options)) if (key !== "timeout") throw new Error(`Unsupported waitForElementState option: ${key}`);
 	if (options.timeout !== void 0) validateTimeout(options.timeout, "waitForElementState timeout");
 }
+/**
+* Pinned 26a9e47 client/frame.ts `verifyLoadState`: accepts the four lifecycle
+* events, keeps the `networkidle0` alias, and rejects anything else with the
+* client's wording before the navigation is requested.
+*/
+function verifyLoadState(name, waitUntil) {
+	if (waitUntil === "networkidle0") waitUntil = "networkidle";
+	if (![
+		"load",
+		"domcontentloaded",
+		"networkidle",
+		"commit"
+	].includes(waitUntil)) throw new Error(`${name}: expected one of (load|domcontentloaded|networkidle|commit)`);
+	return waitUntil;
+}
 function isRetryableQueryError(error) {
 	const message = asError(error).message;
 	return message.startsWith("No elements found for locator") || message === "Element is not connected";
@@ -17525,8 +17692,24 @@ function presentOriginalXPath(error, selector) {
 	if (rewritten === source.message) return source;
 	return new Error(rewritten, { cause: source });
 }
-function queryAborted(signal) {
-	return /* @__PURE__ */ new Error(`Query was aborted: ${abortReason(signal)}`);
+function actionAborted(signal, inFlight) {
+	const reason = abortReason(signal);
+	const error = new Error(inFlight ? `${reason}\nCall log:\n  - operation was aborted: ${reason}` : "The operation was aborted", { cause: signal.reason });
+	error.name = "AbortError";
+	return error;
+}
+async function withAbortPrefix(apiName, run) {
+	try {
+		return await run();
+	} catch (error) {
+		throw prefixAbortError(error, apiName);
+	}
+}
+function prefixAbortError(error, apiName) {
+	const result = asError(error);
+	if (result.name !== "AbortError") return error;
+	result.message = `${apiName}: ${result.message}`;
+	return result;
 }
 function unknownKey(value) {
 	throw new Error(`Unknown key: "${value}"`);