@enekesabel/playwright-lite 0.4.0 → 0.5.0

package/dist/index.mjs

@@ -4505,7 +4505,6 @@ Resolved to value: ${printReceived(actual)}`;
 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) {
@@ -4540,12 +4539,12 @@ var AdapterJSHandle = class {
 	async evaluate(pageFunction, arg, options) {
 		assertMaxArguments(arguments.length, 3);
 		assertEvaluationOptions(options);
-		return this.evaluation.byValue(pageFunction, typeof pageFunction === "function", arg, this);
+		return this.evaluation.byValue(pageFunction, typeof pageFunction === "function", arg, this, options);
 	}
 	async evaluateHandle(pageFunction, arg, options) {
 		assertMaxArguments(arguments.length, 3);
 		assertEvaluationOptions(options);
-		return this.evaluation.byHandle(pageFunction, typeof pageFunction === "function", arg, this);
+		return this.evaluation.byHandle(pageFunction, typeof pageFunction === "function", arg, this, options);
 	}
 	/** Pinned javascript.ts:188 reads the property off the value itself. */
 	async getProperty(propertyName) {
@@ -4585,19 +4584,13 @@ var AdapterJSHandle = class {
 		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.
-*/
+/** Mirrors pinned crExecutionContext.ts `renderPreview` for a value with no remote object: `String(value)`, or a name for an object. Also used by `console.ts`'s argument previews. */
 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);
+	const tag = tagOf(value);
 	if (tag === "Date" || tag === "RegExp") return String(value);
 	if (tag === "Error") return value.stack || String(value);
 	const name = tag === "Object" ? constructorName(value) : tag;
@@ -4605,8 +4598,27 @@ function previewValue(value) {
 	if (tag === "Array" || ArrayBuffer.isView(value)) return `${name}(${value.length})`;
 	return name;
 }
+/**
+* V8 names an object without running page code, verified against real
+* Chromium: a `Symbol.toStringTag` or `constructor` accessor is never called.
+* These lookups read descriptors along the prototype chain instead; a Proxy's
+* traps still run, as nothing in the document can inspect one without them.
+*/
+function tagOf(value) {
+	const descriptor = findDescriptor(value, Symbol.toStringTag);
+	if (descriptor && !("value" in descriptor)) return "Object";
+	return Object.prototype.toString.call(value).slice(8, -1);
+}
 function constructorName(value) {
-	return value.constructor?.name || "Object";
+	const constructor = findDescriptor(value, "constructor")?.value;
+	const name = typeof constructor === "function" ? findDescriptor(constructor, "name")?.value : void 0;
+	return typeof name === "string" && name || "Object";
+}
+function findDescriptor(value, key) {
+	for (let owner = value; owner; owner = Object.getPrototypeOf(owner)) {
+		const descriptor = Object.getOwnPropertyDescriptor(owner, key);
+		if (descriptor) return descriptor;
+	}
 }
 //#endregion
 //#region src/protocolValidation.ts
@@ -4880,7 +4892,7 @@ __export$1(utilityScript_exports, { UtilityScript: () => UtilityScript$1 });
 module$2.exports = __toCommonJS$1(utilityScript_exports);
 var kFunctionBindingPrefix$1 = "__pw_fn_";
 var kBindingsControllerProperty$1 = "__playwright__binding__controller__";
-function isRegExp$3(obj) {
+function isRegExp$4(obj) {
 	try {
 		return obj instanceof RegExp || Object.prototype.toString.call(obj) === "[object RegExp]";
 	} catch (error) {
@@ -5038,7 +5050,7 @@ ${value.stack}`;
 	}
 	if (isDate$1(value)) return { d: value.toJSON() };
 	if (isURL$1(value)) return { u: value.toJSON() };
-	if (isRegExp$3(value)) return { r: {
+	if (isRegExp$4(value)) return { r: {
 		p: value.source,
 		f: value.flags
 	} };
@@ -5092,7 +5104,7 @@ ${value.stack}`;
 			id: id2
 		};
 	}
-	if (typeof value === "function" && value.name.startsWith(kFunctionBindingPrefix$1)) return { fn: value.name };
+	if (typeof value === "function" && value.name.startsWith("__pw_fn_")) return { fn: value.name };
 }
 var UtilityScript$1 = class {
 	constructor(global, isUnderTest) {
@@ -5263,15 +5275,6 @@ var AdapterElementHandle = class extends AdapterJSHandle {
 		assertMaxArguments(arguments.length, 3);
 		return this.ownerPage.evaluation.byValue(pageFunction, typeof pageFunction === "function", arg, this.ownerPage.resolveAllWithinElement(this.requireElement(), selector));
 	}
-	async evaluate(pageFunction, arg, options) {
-		assertMaxArguments(arguments.length, 3);
-		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;
 	}
@@ -5352,13 +5355,22 @@ var Evaluation = class {
 	get script() {
 		return this.utility ??= new LiteUtilityScript(this.page.window, false);
 	}
-	argument(value) {
+	/**
+	* `exposeFunctions` registers each function nested in `value` as a binding
+	* (pinned client/jsHandle.ts `serializeArgumentWithCallbacks`) instead of
+	* letting the protocol serializer reject it; its generated name survives
+	* the value copy and is what the pinned UtilityScript's own serializer
+	* (`serializeAsCallArgument`) recognizes to re-emit `{ fn }` for the
+	* reconstructed callable the page function receives.
+	*/
+	argument(value, exposeFunctions = false) {
 		const references = [];
 		const protocolValue = serializeValue(value, (candidate) => {
 			if (candidate instanceof AdapterJSHandle) {
 				references.push(candidate);
 				return { h: references.length - 1 };
 			}
+			if (exposeFunctions && typeof candidate === "function") return { fn: this.page.bindings.registerEvaluateCallback(this.page.bindingOwner, candidate) };
 			return { fallThrough: candidate };
 		});
 		const copy = parseSerializedValue(protocolValue, references);
@@ -5383,20 +5395,20 @@ var Evaluation = class {
 	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)));
+	async byValue(expression, isFunction, arg, target, options) {
+		return protocolResult(parseEvaluationResultValue$1(await this.run(expression, isFunction, true, arg, target, options?.exposeFunctions)));
 	}
 	/**
 	* 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 byHandle(expression, isFunction, arg, target, options) {
+		return this.handleFor(await this.run(expression, isFunction, false, arg, target, options?.exposeFunctions));
 	}
-	async run(expression, isFunction, returnByValue, arg, target) {
+	async run(expression, isFunction, returnByValue, arg, target, exposeFunctions) {
 		const normalized = normalizeExpression(String(expression), isFunction);
-		const { serialized, handles } = this.argument(arg);
+		const { serialized, handles } = this.argument(arg, exposeFunctions);
 		const parameters = [serialized];
 		if (target !== void 0) {
 			handles.push(target instanceof AdapterJSHandle ? target.valueForEvaluation(this) : target);
@@ -5437,6 +5449,27 @@ var Evaluation = class {
 	jsonValue(value) {
 		return protocolResult(parseEvaluationResultValue$1(this.script.jsonValue(true, value)));
 	}
+	/**
+	* One round trip through the pinned by-value call-argument serializer,
+	* resolving this page's handles to their referenced value. `exposeFunction`
+	* / `exposeBinding` cross their arguments and result this way: there is no
+	* Node/browser split to serialize across, so a binding call takes one hop
+	* (the pinned browser-side `serializeAsCallArgument` alone), not the two
+	* the pinned client and server each take. Unlike `unwrapHandles`, this
+	* skips the protocol-level pass, so a `Window`/`Document`/`Node` argument
+	* still aliases to the pinned `"ref: <Window>"`-style string instead of
+	* losing its identity to the protocol serializer's plain-object walk first.
+	*/
+	bindingValue(value) {
+		const handles = [];
+		return parseEvaluationResultValue$1(serializeAsCallArgument$1(value, (candidate) => {
+			if (candidate instanceof AdapterJSHandle) {
+				handles.push(candidate.valueForEvaluation(this));
+				return { h: handles.length - 1 };
+			}
+			return { fallThrough: candidate };
+		}), handles);
+	}
 };
 function protocolResult(value) {
 	return parseSerializedValue(serializeValue(value, (value) => ({ fallThrough: value })));
@@ -13396,7 +13429,7 @@ function trimString(input, cap, suffix = "") {
 	if (chars.length > cap) return chars.slice(0, cap - suffix.length).join("") + suffix;
 	return chars.join("");
 }
-function trimStringWithEllipsis(input, cap) {
+function trimStringWithEllipsis$1(input, cap) {
 	return trimString(input, cap, "…");
 }
 function truncateDataUrl(url) {
@@ -13632,9 +13665,9 @@ var JavaScriptLocatorFactory = class {
 			case "visible": return `filter({ visible: ${body === "true" ? "true" : "false"} })`;
 			case "role":
 				const attrs = [];
-				if (isRegExp$2(options.name)) attrs.push(`name: ${this.regexToSourceString(options.name)}`);
+				if (isRegExp$3(options.name)) attrs.push(`name: ${this.regexToSourceString(options.name)}`);
 				else if (typeof options.name === "string") attrs.push(`name: ${this.quote(options.name)}`);
-				if (isRegExp$2(options.description)) attrs.push(`description: ${this.regexToSourceString(options.description)}`);
+				if (isRegExp$3(options.description)) attrs.push(`description: ${this.regexToSourceString(options.description)}`);
 				else if (typeof options.description === "string") attrs.push(`description: ${this.quote(options.description)}`);
 				if (options.exact && (typeof options.name === "string" || typeof options.description === "string")) attrs.push(`exact: true`);
 				for (const { name, value } of options.attrs) attrs.push(`${name}: ${typeof value === "string" ? this.quote(value) : value}`);
@@ -13663,15 +13696,15 @@ var JavaScriptLocatorFactory = class {
 		return normalizeEscapedRegexQuotes(String(re));
 	}
 	toCallWithExact(method, body, exact) {
-		if (isRegExp$2(body)) return `${method}(${this.regexToSourceString(body)})`;
+		if (isRegExp$3(body)) return `${method}(${this.regexToSourceString(body)})`;
 		return exact ? `${method}(${this.quote(body)}, { exact: true })` : `${method}(${this.quote(body)})`;
 	}
 	toHasText(body) {
-		if (isRegExp$2(body)) return this.regexToSourceString(body);
+		if (isRegExp$3(body)) return this.regexToSourceString(body);
 		return this.quote(body);
 	}
 	toTestIdValue(value) {
-		if (isRegExp$2(value)) return this.regexToSourceString(value);
+		if (isRegExp$3(value)) return this.regexToSourceString(value);
 		return this.quote(value);
 	}
 	quote(text) {
@@ -13694,9 +13727,9 @@ var PythonLocatorFactory = class {
 			case "visible": return `filter(visible=${body === "true" ? "True" : "False"})`;
 			case "role":
 				const attrs = [];
-				if (isRegExp$2(options.name)) attrs.push(`name=${this.regexToString(options.name)}`);
+				if (isRegExp$3(options.name)) attrs.push(`name=${this.regexToString(options.name)}`);
 				else if (typeof options.name === "string") attrs.push(`name=${this.quote(options.name)}`);
-				if (isRegExp$2(options.description)) attrs.push(`description=${this.regexToString(options.description)}`);
+				if (isRegExp$3(options.description)) attrs.push(`description=${this.regexToString(options.description)}`);
 				else if (typeof options.description === "string") attrs.push(`description=${this.quote(options.description)}`);
 				if (options.exact && (typeof options.name === "string" || typeof options.description === "string")) attrs.push(`exact=True`);
 				for (const { name, value } of options.attrs) {
@@ -13730,16 +13763,16 @@ var PythonLocatorFactory = class {
 		return `re.compile(r"${normalizeEscapedRegexQuotes(body.source).replace(/\\\//, "/").replace(/"/g, "\\\"")}"${suffix})`;
 	}
 	toCallWithExact(method, body, exact) {
-		if (isRegExp$2(body)) return `${method}(${this.regexToString(body)})`;
+		if (isRegExp$3(body)) return `${method}(${this.regexToString(body)})`;
 		if (exact) return `${method}(${this.quote(body)}, exact=True)`;
 		return `${method}(${this.quote(body)})`;
 	}
 	toHasText(body) {
-		if (isRegExp$2(body)) return this.regexToString(body);
+		if (isRegExp$3(body)) return this.regexToString(body);
 		return `${this.quote(body)}`;
 	}
 	toTestIdValue(value) {
-		if (isRegExp$2(value)) return this.regexToString(value);
+		if (isRegExp$3(value)) return this.regexToString(value);
 		return this.quote(value);
 	}
 	quote(text) {
@@ -13771,9 +13804,9 @@ var JavaLocatorFactory = class {
 			case "visible": return `filter(new ${clazz}.FilterOptions().setVisible(${body === "true" ? "true" : "false"}))`;
 			case "role":
 				const attrs = [];
-				if (isRegExp$2(options.name)) attrs.push(`.setName(${this.regexToString(options.name)})`);
+				if (isRegExp$3(options.name)) attrs.push(`.setName(${this.regexToString(options.name)})`);
 				else if (typeof options.name === "string") attrs.push(`.setName(${this.quote(options.name)})`);
-				if (isRegExp$2(options.description)) attrs.push(`.setDescription(${this.regexToString(options.description)})`);
+				if (isRegExp$3(options.description)) attrs.push(`.setDescription(${this.regexToString(options.description)})`);
 				else if (typeof options.description === "string") attrs.push(`.setDescription(${this.quote(options.description)})`);
 				if (options.exact && (typeof options.name === "string" || typeof options.description === "string")) attrs.push(`.setExact(true)`);
 				for (const { name, value } of options.attrs) attrs.push(`.set${toTitleCase(name)}(${typeof value === "string" ? this.quote(value) : value})`);
@@ -13803,16 +13836,16 @@ var JavaLocatorFactory = class {
 		return `Pattern.compile(${this.quote(normalizeEscapedRegexQuotes(body.source))}${suffix})`;
 	}
 	toCallWithExact(clazz, method, body, exact) {
-		if (isRegExp$2(body)) return `${method}(${this.regexToString(body)})`;
+		if (isRegExp$3(body)) return `${method}(${this.regexToString(body)})`;
 		if (exact) return `${method}(${this.quote(body)}, new ${clazz}.${toTitleCase(method)}Options().setExact(true))`;
 		return `${method}(${this.quote(body)})`;
 	}
 	toHasText(body) {
-		if (isRegExp$2(body)) return this.regexToString(body);
+		if (isRegExp$3(body)) return this.regexToString(body);
 		return this.quote(body);
 	}
 	toTestIdValue(value) {
-		if (isRegExp$2(value)) return this.regexToString(value);
+		if (isRegExp$3(value)) return this.regexToString(value);
 		return this.quote(value);
 	}
 	quote(text) {
@@ -13834,9 +13867,9 @@ var CSharpLocatorFactory = class {
 			case "visible": return `Filter(new() { Visible = ${body === "true" ? "true" : "false"} })`;
 			case "role":
 				const attrs = [];
-				if (isRegExp$2(options.name)) attrs.push(`NameRegex = ${this.regexToString(options.name)}`);
+				if (isRegExp$3(options.name)) attrs.push(`NameRegex = ${this.regexToString(options.name)}`);
 				else if (typeof options.name === "string") attrs.push(`Name = ${this.quote(options.name)}`);
-				if (isRegExp$2(options.description)) attrs.push(`DescriptionRegex = ${this.regexToString(options.description)}`);
+				if (isRegExp$3(options.description)) attrs.push(`DescriptionRegex = ${this.regexToString(options.description)}`);
 				else if (typeof options.description === "string") attrs.push(`Description = ${this.quote(options.description)}`);
 				if (options.exact && (typeof options.name === "string" || typeof options.description === "string")) attrs.push(`Exact = true`);
 				for (const { name, value } of options.attrs) attrs.push(`${toTitleCase(name)} = ${typeof value === "string" ? this.quote(value) : value}`);
@@ -13866,20 +13899,20 @@ var CSharpLocatorFactory = class {
 		return `new Regex(${this.quote(normalizeEscapedRegexQuotes(body.source))}${suffix})`;
 	}
 	toCallWithExact(method, body, exact) {
-		if (isRegExp$2(body)) return `${method}(${this.regexToString(body)})`;
+		if (isRegExp$3(body)) return `${method}(${this.regexToString(body)})`;
 		if (exact) return `${method}(${this.quote(body)}, new() { Exact = true })`;
 		return `${method}(${this.quote(body)})`;
 	}
 	toHasText(body) {
-		if (isRegExp$2(body)) return `HasTextRegex = ${this.regexToString(body)}`;
+		if (isRegExp$3(body)) return `HasTextRegex = ${this.regexToString(body)}`;
 		return `HasText = ${this.quote(body)}`;
 	}
 	toTestIdValue(value) {
-		if (isRegExp$2(value)) return this.regexToString(value);
+		if (isRegExp$3(value)) return this.regexToString(value);
 		return this.quote(value);
 	}
 	toHasNotText(body) {
-		if (isRegExp$2(body)) return `HasNotTextRegex = ${this.regexToString(body)}`;
+		if (isRegExp$3(body)) return `HasNotTextRegex = ${this.regexToString(body)}`;
 		return `HasNotText = ${this.quote(body)}`;
 	}
 	quote(text) {
@@ -13911,7 +13944,7 @@ var generators = {
 	csharp: CSharpLocatorFactory,
 	jsonl: JsonlLocatorFactory
 };
-function isRegExp$2(obj) {
+function isRegExp$3(obj) {
 	return obj instanceof RegExp;
 }
 function getByAttributeTextSelector(attrName, text, options) {
@@ -18915,7 +18948,7 @@ var InjectedScript = class {
 			else attrs.push(` ${name}="${value}"`);
 		}
 		attrs.sort((a, b) => a.length - b.length);
-		const attrText = trimStringWithEllipsis(attrs.join(""), 500);
+		const attrText = trimStringWithEllipsis$1(attrs.join(""), 500);
 		if (this._autoClosingTags.has(element.nodeName)) return oneLine(`<${element.nodeName.toLowerCase()}${attrText}/>`);
 		const children = element.childNodes;
 		let onlyText = false;
@@ -18924,7 +18957,7 @@ var InjectedScript = class {
 			for (let i = 0; i < children.length; i++) onlyText = onlyText && children[i].nodeType === Node.TEXT_NODE;
 		}
 		const text = onlyText ? element.textContent || "" : children.length ? "…" : "";
-		return oneLine(`<${element.nodeName.toLowerCase()}${attrText}>${trimStringWithEllipsis(text, 50)}</${element.nodeName.toLowerCase()}>`);
+		return oneLine(`<${element.nodeName.toLowerCase()}${attrText}>${trimStringWithEllipsis$1(text, 50)}</${element.nodeName.toLowerCase()}>`);
 	}
 	_generateSelectors(elements) {
 		this._evaluator.begin();
@@ -19476,6 +19509,997 @@ var AdapterTimeoutError = class extends Error {
 	}
 };
 //#endregion
+//#region src/hostGlobals.ts
+/**
+* One instance per window, created by `create` on first use and shared by
+* every later caller for the same window.
+*/
+function perWindow(create) {
+	const instances = /* @__PURE__ */ new WeakMap();
+	return (browserWindow) => {
+		let instance = instances.get(browserWindow);
+		if (instance === void 0) instances.set(browserWindow, instance = create(browserWindow));
+		return instance;
+	};
+}
+/**
+* A host function replaced by a callable `Proxy` between `install` and
+* `restore`.
+*
+* The proxy traps only `apply`, so `name`, `length` and
+* `Function.prototype.toString` keep answering for the original function, and
+* `this` and the arguments reach it untouched: a call with a receiver the
+* platform object rejects still throws the same `TypeError`. While nothing
+* is installed, every proxy this object made forwards calls to its original
+* untouched, so a Site's wrapper that closed over one keeps working
+* unobserved.
+*/
+var WrappedHostFunction = class {
+	member;
+	original;
+	proxy;
+	constructor(member) {
+		this.member = member;
+	}
+	install() {
+		const { holder, name } = this.member;
+		const original = holder[name];
+		const proxy = new Proxy(original, { apply: (target, thisArg, args) => this.proxy !== void 0 ? this.member.intercept(target, thisArg, args) : Reflect.apply(target, thisArg, args) });
+		this.original = original;
+		this.proxy = proxy;
+		holder[name] = proxy;
+	}
+	restore() {
+		const { holder, name } = this.member;
+		if (holder[name] === this.proxy) holder[name] = this.original;
+		this.proxy = void 0;
+		this.original = void 0;
+	}
+};
+/**
+* Host functions replaced together as one subscription, and the reporters
+* subscribed to them. Every wrapper is installed when the first reporter
+* subscribes and restored when the last one releases.
+*
+* This is the only subscription count: a reporter subscribed n times is
+* reported to once per call, until its n-th release.
+*/
+var HostObservation = class {
+	options;
+	wrappers;
+	reporters = /* @__PURE__ */ new Map();
+	constructor(members, options = {}) {
+		this.options = options;
+		this.wrappers = members.map((member) => new WrappedHostFunction(member));
+	}
+	/** Reports to `report` until the returned release is called. The release is idempotent. */
+	subscribe(report) {
+		const first = this.reporters.size === 0;
+		this.reporters.set(report, (this.reporters.get(report) ?? 0) + 1);
+		if (first) for (const wrapper of this.wrappers) wrapper.install();
+		let released = false;
+		return () => {
+			if (released) return;
+			released = true;
+			const held = this.reporters.get(report) - 1;
+			if (held > 0) {
+				this.reporters.set(report, held);
+				return;
+			}
+			this.reporters.delete(report);
+			if (this.reporters.size > 0) return;
+			for (const wrapper of this.wrappers) wrapper.restore();
+			this.options.onLastRelease?.();
+		};
+	}
+	/**
+	* Calls every subscribed reporter once, synchronously, over a snapshot
+	* taken now. A reporter's throw is not caught: it reaches the caller and
+	* skips the reporters after it.
+	*/
+	report(...args) {
+		for (const reporter of [...this.reporters.keys()]) reporter(...args);
+	}
+};
+//#endregion
+//#region src/bindings.ts
+/**
+* Pinned server/page.ts `_pageBindings`: one registry per window, since the
+* pinned UtilityScript bundle calls back into a single `window[name]`.
+*/
+var PageBindings = class {
+	window;
+	bindings = /* @__PURE__ */ new Map();
+	controllerInstalled = false;
+	nextCallbackId = 0;
+	constructor(window) {
+		this.window = window;
+	}
+	/**
+	* Pinned server/page.ts `exposeBinding`'s duplicate-name error. Installs
+	* `window[name]` and returns its idempotent removal, pinned
+	* `removeExposedBinding`: the registration goes, so `name` can be exposed
+	* again, and so does `window[name]` unless the Site has since replaced it.
+	*/
+	expose(owner, name, handler) {
+		if (this.bindings.has(name)) throw new Error(`Function "${name}" has been already registered`);
+		const entry = {
+			owner,
+			handler
+		};
+		this.install(name, entry);
+		const holder = this.window;
+		const exposed = (...args) => this.callBinding(name, ...args);
+		holder[name] = exposed;
+		return () => {
+			if (this.bindings.get(name) !== entry) return;
+			this.bindings.delete(name);
+			if (holder[name] === exposed) delete holder[name];
+		};
+	}
+	/**
+	* Registers the callback a function nested in an `evaluate(..., {
+	* exposeFunctions: true })` argument becomes, under a fresh generated name.
+	* Mirrors pinned client/jsHandle.ts `serializeArgumentWithCallbacks` /
+	* `page._exposeEvaluateCallback`: the binding ignores `source` (there is no
+	* caller frame to report), forwards the call's own arguments, and (pinned
+	* `noGlobal: true`) never installs on `window`.
+	*/
+	registerEvaluateCallback(owner, fn) {
+		const name = kFunctionBindingPrefix$1 + this.nextCallbackId++;
+		this.install(name, {
+			owner,
+			handler: (_source, ...args) => fn(...args)
+		});
+		return name;
+	}
+	/** Installs the controller the first time anything is registered. */
+	install(name, entry) {
+		if (!this.controllerInstalled) {
+			this.controllerInstalled = true;
+			this.window[kBindingsControllerProperty$1] = { callBinding: (name, ...args) => this.callBinding(name, ...args) };
+		}
+		this.bindings.set(name, entry);
+	}
+	/** Pinned server/page.ts `PageBinding.dispatch`: the result or the thrown
+	* error both cross back through the owning page's by-value round trip
+	* (`serializeError`/`parseError`'s pinned equivalent). */
+	async callBinding(name, ...args) {
+		const entry = this.bindings.get(name);
+		if (!entry) throw new Error(`Function "${name}" is not exposed`);
+		const { owner, handler } = entry;
+		try {
+			const result = await handler(owner.source, ...args.map((arg) => owner.toByValue(arg)));
+			return owner.toByValue(result);
+		} catch (error) {
+			throw owner.toByValue(error);
+		}
+	}
+};
+/** The one binding registry of a window, created for its first subscriber. */
+const bindingsFor = perWindow((browserWindow) => new PageBindings(browserWindow));
+//#endregion
+//#region src/network.ts
+/** Pinned client/events.ts Page events this observation emits. */
+const NETWORK_EVENTS = [
+	"request",
+	"response",
+	"requestfinished",
+	"requestfailed"
+];
+/** Pinned server/frames.ts `_startNetworkIdleTimer`: the quiet period. */
+const NETWORK_IDLE_TIMEOUT = 500;
+/** Pinned server/page.ts `addNetworkRequest`: the recent-request bound. */
+const REQUEST_LOG_LIMIT = 100;
+function deferred() {
+	let resolve;
+	return {
+		promise: new Promise((settle) => resolve = settle),
+		resolve
+	};
+}
+/** Pinned server/network.ts `stripFragmentFromUrl`. */
+function stripFragmentFromUrl(url) {
+	if (!url.includes("#")) return url;
+	return url.substring(0, url.indexOf("#"));
+}
+/** `XMLHttpRequest.open` uppercases these method names before they go out. */
+function normalizeXhrMethod(method) {
+	return /^(delete|get|head|options|post|put)$/i.test(method) ? method.toUpperCase() : method;
+}
+/** Parses `getAllResponseHeaders()`, whose names the browser has lowercased. */
+function parseRawHeaders(raw) {
+	const headers = {};
+	for (const line of raw.split("\r\n")) {
+		const separator = line.indexOf(":");
+		if (separator < 0) continue;
+		headers[line.slice(0, separator).trim().toLowerCase()] = line.slice(separator + 1).trim();
+	}
+	return headers;
+}
+/**
+* The bytes an `XMLHttpRequest` kept. A `responseType` of `"json"` or
+* `"document"` leaves only the value the browser parsed from the body, so the
+* body itself is gone and reading it reports that instead of inventing bytes.
+*/
+async function xhrResponseBody(xhr) {
+	if (xhr.responseType === "json" || xhr.responseType === "document") throw new Error(`Response body is not available: the request set responseType "${xhr.responseType}".`);
+	const body = xhr.response;
+	if (typeof body === "string") return new TextEncoder().encode(body);
+	if (body === null) return /* @__PURE__ */ new Uint8Array();
+	if (body instanceof ArrayBuffer) return new Uint8Array(body);
+	if (body instanceof Blob) return new Uint8Array(await body.arrayBuffer());
+	throw new Error(`Response body is not available: the request set responseType "${xhr.responseType}".`);
+}
+function headersObject(headers) {
+	const result = {};
+	headers.forEach((value, name) => {
+		result[name.toLowerCase()] = value;
+	});
+	return result;
+}
+/**
+* The request body a `fetch` init or an `XMLHttpRequest.send` argument
+* carries, in the forms the caller can hand over synchronously. `postData()`
+* answers without waiting, as the pinned client's does, and the call must be
+* forwarded in the same turn; a `Blob`, `FormData` or `ReadableStream` body,
+* and a body carried by a `Request` argument, can only be read
+* asynchronously, so those report `null`.
+*/
+function readableBody(body) {
+	if (typeof body === "string") return new TextEncoder().encode(body);
+	if (body instanceof URLSearchParams) return new TextEncoder().encode(body.toString());
+	if (body instanceof ArrayBuffer) return new Uint8Array(body.slice(0));
+	if (ArrayBuffer.isView(body)) return new Uint8Array(body.buffer.slice(body.byteOffset, body.byteOffset + body.byteLength));
+	return null;
+}
+var ObservedRequest = class {
+	_init;
+	_response = deferred();
+	_failureText = null;
+	constructor(_init) {
+		this._init = _init;
+	}
+	url() {
+		return stripFragmentFromUrl(this._init.url);
+	}
+	resourceType() {
+		return this._init.resourceType;
+	}
+	method() {
+		return this._init.method;
+	}
+	headers() {
+		return { ...this._init.headers };
+	}
+	async headerValue(name) {
+		return this._init.headers[name.toLowerCase()] ?? null;
+	}
+	postData() {
+		return this._init.postData === null ? null : new TextDecoder().decode(this._init.postData);
+	}
+	postDataBuffer() {
+		return this._init.postData;
+	}
+	/** Pinned client/network.ts Request.postDataJSON. */
+	postDataJSON() {
+		const postData = this.postData();
+		if (!postData) return null;
+		if (this.headers()["content-type"]?.includes("application/x-www-form-urlencoded")) {
+			const entries = {};
+			for (const [key, value] of new URLSearchParams(postData).entries()) entries[key] = value;
+			return entries;
+		}
+		try {
+			return JSON.parse(postData);
+		} catch {
+			throw new Error("POST data is not a valid JSON object: " + postData);
+		}
+	}
+	isNavigationRequest() {
+		return false;
+	}
+	failure() {
+		return this._failureText === null ? null : { errorText: this._failureText };
+	}
+	async response() {
+		return await this._response.promise;
+	}
+	setResponse(response) {
+		this._response.resolve(response);
+	}
+	setFailure(errorText) {
+		this._failureText = errorText;
+		this._response.resolve(null);
+	}
+};
+var ObservedResponse = class {
+	_request;
+	_init;
+	_finished = deferred();
+	_body;
+	constructor(_request, _init) {
+		this._request = _request;
+		this._init = _init;
+	}
+	url() {
+		return this._init.url;
+	}
+	status() {
+		return this._init.status;
+	}
+	statusText() {
+		return this._init.statusText;
+	}
+	/** Pinned client/network.ts Response.ok, which also counts status 0. */
+	ok() {
+		return this._init.status === 0 || this._init.status >= 200 && this._init.status <= 299;
+	}
+	headers() {
+		return { ...this._init.headers };
+	}
+	async headerValue(name) {
+		return this._init.headers[name.toLowerCase()] ?? null;
+	}
+	async body() {
+		this._body ??= this._init.readBody();
+		return await this._body;
+	}
+	async text() {
+		return new TextDecoder().decode(await this.body());
+	}
+	async json() {
+		return JSON.parse(await this.text());
+	}
+	async finished() {
+		return await this._finished.promise;
+	}
+	request() {
+		return this._request;
+	}
+	/** Reports that the body has ended, which is what `finished()` waits for. */
+	markFinished() {
+		this._finished.resolve(null);
+	}
+};
+/**
+* The one observation of a window's `fetch` and `XMLHttpRequest`. Every `Page`
+* created for the same window shares it: a second wrapper would wrap the first
+* one's proxy, and unsubscribing in the order they were installed would then
+* leave that proxy behind for good.
+*/
+const networkObservationFor = perWindow((browserWindow) => new NetworkObservation(browserWindow));
+/**
+* Reports the `fetch` and `XMLHttpRequest` calls the document makes as
+* Playwright's four network events, for as long as something is subscribed.
+*
+* Playwright observes requests in the browser process, so it sees every
+* resource and every realm. This observation replaces `window.fetch` and
+* `XMLHttpRequest.prototype.open`, `setRequestHeader` and `send`, so it sees
+* this realm's `fetch` calls made after the wrappers were installed and its
+* `XMLHttpRequest`s opened after that, and nothing else. A call is intercepted
+* once and reported to every subscriber.
+*/
+var NetworkObservation = class {
+	window;
+	/**
+	* The host functions this observation replaces. They are installed and
+	* restored together, so one subscription is one decision about the document.
+	*/
+	host;
+	/** What `open` recorded for an `XMLHttpRequest` this observation saw. */
+	openedRequests = /* @__PURE__ */ new WeakMap();
+	/**
+	* The reported requests that count for network idle and have not ended.
+	* Kept while anything is subscribed, so a `networkidle` wait also sees the
+	* requests reported to an earlier subscriber; emptied with the last one.
+	*/
+	inflight = /* @__PURE__ */ new Set();
+	constructor(window) {
+		this.window = window;
+		const xhr = window.XMLHttpRequest.prototype;
+		this.host = new HostObservation([
+			{
+				holder: window,
+				name: "fetch",
+				intercept: (original, thisArg, args) => this.observeFetch(original, thisArg, args)
+			},
+			{
+				holder: xhr,
+				name: "open",
+				intercept: (original, thisArg, args) => this.observeOpen(original, thisArg, args)
+			},
+			{
+				holder: xhr,
+				name: "setRequestHeader",
+				intercept: (original, thisArg, args) => this.observeSetRequestHeader(original, thisArg, args)
+			},
+			{
+				holder: xhr,
+				name: "send",
+				intercept: (original, thisArg, args) => this.observeSend(original, thisArg, args)
+			}
+		], { onLastRelease: () => this.inflight.clear() });
+	}
+	/** Reports to `report` until the returned release is called. */
+	subscribe(report) {
+		return this.host.subscribe(report);
+	}
+	/**
+	* Calls `onIdle` after 500 ms with no observed request in flight, as pinned
+	* server/frames.ts fires `networkidle`. Subscribes until the release is called.
+	*/
+	observeIdle(onIdle) {
+		let timer;
+		const stopTimer = () => {
+			this.window.clearTimeout(timer);
+			timer = void 0;
+		};
+		const startTimer = () => {
+			timer = this.window.setTimeout(() => {
+				timer = void 0;
+				onIdle();
+			}, NETWORK_IDLE_TIMEOUT);
+		};
+		const resources = new this.window.PerformanceObserver((list) => {
+			if (!list.getEntriesByType("resource").some((entry) => !["fetch", "xmlhttprequest"].includes(entry.initiatorType)) || timer === void 0) return;
+			stopTimer();
+			startTimer();
+		});
+		const release = this.subscribe(() => {
+			if (this.inflight.size > 0) stopTimer();
+			else if (timer === void 0) startTimer();
+		});
+		resources.observe({ type: "resource" });
+		if (this.inflight.size === 0) startTimer();
+		return () => {
+			resources.disconnect();
+			stopTimer();
+			release();
+		};
+	}
+	emit(event, payload) {
+		if (event === "request") {
+			const request = payload;
+			if (!request.url().endsWith("/favicon.ico")) this.inflight.add(request);
+		} else if (event === "requestfinished" || event === "requestfailed") this.inflight.delete(payload);
+		this.host.report(event, payload);
+	}
+	observeFetch(original, thisArg, args) {
+		let request;
+		try {
+			request = new this.window.Request(args[0], args[1]);
+		} catch {
+			return Reflect.apply(original, thisArg, args);
+		}
+		const postData = readableBody(args[1]?.body);
+		const result = Reflect.apply(original, thisArg, [request]);
+		const observed = new ObservedRequest({
+			url: request.url,
+			method: request.method,
+			headers: headersObject(request.headers),
+			resourceType: "fetch",
+			postData
+		});
+		this.emit("request", observed);
+		this.follow(observed, result);
+		return result;
+	}
+	async follow(request, result) {
+		let response;
+		try {
+			const native = await result;
+			const recording = native.clone();
+			response = new ObservedResponse(request, {
+				url: native.url,
+				status: native.status,
+				statusText: native.statusText,
+				headers: headersObject(native.headers),
+				readBody: async () => new Uint8Array(await recording.arrayBuffer())
+			});
+		} catch (error) {
+			request.setFailure(failureText(error));
+			this.emit("requestfailed", request);
+			return;
+		}
+		request.setResponse(response);
+		this.emit("response", response);
+		try {
+			await response.body();
+			response.markFinished();
+		} catch (error) {
+			request.setFailure(failureText(error));
+			this.emit("requestfailed", request);
+			return;
+		}
+		this.emit("requestfinished", request);
+	}
+	/**
+	* Records what `open` accepted. Once the original has returned, the receiver
+	* is an `XMLHttpRequest` and the URL resolves against the document base;
+	* `open` has just discarded the headers set before it, which is why the
+	* record starts with none.
+	*/
+	observeOpen(original, thisArg, args) {
+		const previous = this.openedRequests.get(thisArg)?.sent;
+		previous?.settleIfDone();
+		const result = Reflect.apply(original, thisArg, args);
+		previous?.cancel();
+		this.openedRequests.set(thisArg, {
+			method: normalizeXhrMethod(String(args[0])),
+			url: new URL(String(args[1]), this.window.document.baseURI).href,
+			headers: new this.window.Headers()
+		});
+		return result;
+	}
+	/** Records a header the original accepted, for `Request.headers`. */
+	observeSetRequestHeader(original, thisArg, args) {
+		const result = Reflect.apply(original, thisArg, args);
+		this.openedRequests.get(thisArg)?.headers.append(String(args[0]), String(args[1]));
+		return result;
+	}
+	/**
+	* Reports the request this `send` starts and the events it produces.
+	*
+	* The `request` event is emitted before the original runs: a synchronous
+	* `XMLHttpRequest` delivers its `load` while `send` is still on the stack,
+	* so waiting for the original to return would report the response first.
+	*
+	* A `send` the platform is about to reject with `InvalidStateError`, and one
+	* on an `XMLHttpRequest` opened before the wrappers were installed, is
+	* forwarded untouched and reports nothing, so a call that never starts a
+	* request leaves nothing of this observation behind.
+	*/
+	observeSend(original, thisArg, args) {
+		const opened = this.openedRequests.get(thisArg);
+		const xhr = thisArg;
+		if (!opened || opened.sent || xhr.readyState !== xhr.OPENED) return Reflect.apply(original, thisArg, args);
+		const request = new ObservedRequest({
+			url: opened.url,
+			method: opened.method,
+			headers: headersObject(new this.window.Request(this.window.document.baseURI, {
+				method: opened.method,
+				headers: opened.headers
+			}).headers),
+			resourceType: "xhr",
+			postData: opened.method === "GET" || opened.method === "HEAD" ? null : readableBody(args[0])
+		});
+		let response;
+		let ended = false;
+		const body = Promise.withResolvers();
+		body.promise.catch(() => {});
+		const respond = () => {
+			if (!response) {
+				response = new ObservedResponse(request, {
+					url: xhr.responseURL,
+					status: xhr.status,
+					statusText: xhr.statusText,
+					headers: parseRawHeaders(xhr.getAllResponseHeaders()),
+					readBody: () => body.promise
+				});
+				request.setResponse(response);
+				this.emit("response", response);
+			}
+			return response;
+		};
+		const listeners = new AbortController();
+		const fail = (errorText) => {
+			if (ended) return;
+			ended = true;
+			listeners.abort();
+			body.reject(new Error(errorText));
+			request.setFailure(errorText);
+			this.emit("requestfailed", request);
+		};
+		const finish = () => {
+			if (ended) return;
+			ended = true;
+			listeners.abort();
+			body.resolve(xhrResponseBody(xhr));
+			respond().markFinished();
+			this.emit("requestfinished", request);
+		};
+		opened.sent = {
+			settleIfDone: () => {
+				if (xhr.readyState !== xhr.DONE) return;
+				if (xhr.status === 0) fail("XMLHttpRequest: error");
+				else finish();
+			},
+			cancel: () => fail("XMLHttpRequest: abort")
+		};
+		const { signal } = listeners;
+		xhr.addEventListener("readystatechange", () => {
+			if (xhr.readyState === xhr.HEADERS_RECEIVED) respond();
+			if (xhr.readyState === xhr.DONE && xhr.status !== 0) finish();
+		}, { signal });
+		xhr.addEventListener("load", finish, { signal });
+		for (const event of [
+			"error",
+			"timeout",
+			"abort"
+		]) xhr.addEventListener(event, () => fail(`XMLHttpRequest: ${event}`), { signal });
+		this.emit("request", request);
+		try {
+			return Reflect.apply(original, thisArg, args);
+		} catch (error) {
+			fail(failureText(error));
+			throw error;
+		}
+	}
+};
+/**
+* Appends to a `Page`'s recent-request log, bounded as pinned server/page.ts
+* `addNetworkRequest` bounds it with `ensureArrayLimit`: once the log passes
+* the limit, its oldest tenth is dropped.
+*/
+function recordRequest(log, request) {
+	log.push(request);
+	if (log.length > REQUEST_LOG_LIMIT) log.splice(0, REQUEST_LOG_LIMIT / 10);
+}
+/**
+* Pinned client/page.ts: a string or `RegExp` matches the observed URL, a
+* function is awaited with the `Request`/`Response` itself.
+*/
+function networkPredicate(urlOrPredicate, urlMatches) {
+	return async (payload) => {
+		const target = payload;
+		if (typeof urlOrPredicate === "function") return await urlOrPredicate(target);
+		return urlMatches(target.url(), urlOrPredicate);
+	};
+}
+/** Pinned client/page.ts `trimUrl`, for the line the timeout reports. */
+function logLineFor(event, match) {
+	if (isRegExp$2(match)) return `waiting for ${event} /${trimStringWithEllipsis(match.source, 50)}/${match.flags}`;
+	if (typeof match === "string") return `waiting for ${event} "${trimStringWithEllipsis(match, 50)}"`;
+	return `waiting for event "${event}"`;
+}
+function isRegExp$2(value) {
+	return value instanceof RegExp || Object.prototype.toString.call(value) === "[object RegExp]";
+}
+/** Pinned isomorphic/stringUtils.ts `trimStringWithEllipsis`. */
+function trimStringWithEllipsis(input, cap) {
+	if (input.length <= cap) return input;
+	const chars = [...input];
+	if (chars.length > cap) return chars.slice(0, cap - 1).join("") + "…";
+	return chars.join("");
+}
+/**
+* Playwright's `failure().errorText` is the browser's `net::ERR_*` code. A
+* page only sees what `fetch` rejected with: a `TypeError` whose message the
+* browser chooses, or the reason an `AbortSignal` carried. An
+* `XMLHttpRequest` carries no error at all, so it reports the name of the
+* event that ended it instead.
+*/
+function failureText(error) {
+	return error instanceof Error ? `${error.name}: ${error.message}` : String(error);
+}
+//#endregion
+//#region src/dialog.ts
+/** One `alert`/`confirm`/`prompt` call, built per subscribed page around a settlement its siblings share. */
+var Dialog = class {
+	_type;
+	_message;
+	_defaultValue;
+	box;
+	_page;
+	constructor(_type, _message, _defaultValue, box, _page) {
+		this._type = _type;
+		this._message = _message;
+		this._defaultValue = _defaultValue;
+		this.box = box;
+		this._page = _page;
+	}
+	type() {
+		return this._type;
+	}
+	message() {
+		return this._message;
+	}
+	defaultValue() {
+		return this._defaultValue;
+	}
+	page() {
+		return this._page();
+	}
+	async accept(promptText) {
+		if (promptText !== void 0) try {
+			promptText = validateString(promptText, "promptText");
+		} catch (error) {
+			throw new TypeError(`dialog.accept: ${error.message}`, { cause: error });
+		}
+		this.settle(true, promptText);
+	}
+	async dismiss() {
+		this.settle(false, void 0);
+	}
+	settle(accepted, value) {
+		if (this.box.result !== void 0) throw new Error(`dialog.${accepted ? "accept" : "dismiss"}: Cannot ${accepted ? "accept" : "dismiss"} dialog which is already handled!`);
+		this.box.result = {
+			accepted,
+			value
+		};
+	}
+};
+/** A `message`/`default` argument, coerced the way the platform coerces it: omitted becomes `""`, a `Symbol` throws. */
+function stringArg(value) {
+	return value === void 0 ? "" : `${value}`;
+}
+/** `undefined` for `alert`, the accepted boolean for `confirm`, the accepted string (or `null`) for `prompt`. */
+function nativeReturnValue(type, defaultValue, result) {
+	if (type === "alert") return void 0;
+	if (type === "confirm") return result.accepted;
+	if (!result.accepted) return null;
+	return result.value ?? defaultValue;
+}
+/** The one observation of a window's dialogs, shared by every `Page` created for it (see `networkObservationFor`). */
+const dialogObservationFor = perWindow((browserWindow) => new DialogObservation(browserWindow));
+const DIALOG_HOST_MEMBERS = [
+	"alert",
+	"confirm",
+	"prompt"
+];
+/** Reports `window.alert`/`confirm`/`prompt` as Playwright's `dialog` event for as long as something is subscribed. */
+var DialogObservation = class {
+	window;
+	host;
+	constructor(window) {
+		this.window = window;
+		const holder = window;
+		this.host = new HostObservation(DIALOG_HOST_MEMBERS.map((type) => ({
+			holder,
+			name: type,
+			intercept: (original, thisArg, args) => this.observe(type, original, thisArg, args)
+		})));
+	}
+	/** Reports to `report` until the returned release is called. */
+	subscribe(report) {
+		return this.host.subscribe(report);
+	}
+	observe(type, original, thisArg, args) {
+		if (thisArg !== void 0 && thisArg !== null && thisArg !== this.window) return Reflect.apply(original, thisArg, args);
+		const message = stringArg(args[0]);
+		const defaultValue = type === "prompt" ? stringArg(args[1]) : "";
+		const box = {};
+		this.host.report(type, message, defaultValue, box);
+		box.result ??= { accepted: false };
+		return nativeReturnValue(type, defaultValue, box.result);
+	}
+};
+//#endregion
+//#region src/console.ts
+/** Pinned client/events.ts Page event this observation emits. */
+const CONSOLE_EVENT = "console";
+/**
+* Builds a `ConsoleMessage`, this package's own `JSHandle`s cast to
+* Playwright's public `JSHandle` the way `createPage`'s `Page` types every
+* other adapter handle it returns. Built per subscribing `Page`, not inside
+* `ConsoleObservation`: `args()` must hold that page's own handles, which
+* only its `Evaluation` can create, and `page()` must return that same page.
+*/
+function buildConsoleMessage(page, type, args, text, location, timestamp) {
+	return {
+		args: () => args,
+		location: () => ({
+			url: location.url,
+			line: location.lineNumber,
+			column: location.columnNumber,
+			lineNumber: location.lineNumber,
+			columnNumber: location.columnNumber
+		}),
+		page: () => page,
+		text: () => text,
+		timestamp: () => timestamp,
+		type: () => type,
+		worker: () => null
+	};
+}
+/**
+* Pinned server/chromium/crPage.ts `_onConsoleAPI`: the native `console.*`
+* method name each pinned `ConsoleMessage.type()` value comes from. `time` is
+* never wrapped: the browser's own `Runtime.consoleAPICalled` never fires for
+* it, only for `timeLog` and the paired `timeEnd`. `timeLog` reports as type
+* `log`, verified against real Chromium; the pinned public `type()` union has
+* no separate `timeLog` value.
+*/
+const CONSOLE_METHOD_TYPES = {
+	log: "log",
+	debug: "debug",
+	info: "info",
+	error: "error",
+	warn: "warning",
+	dir: "dir",
+	dirxml: "dirxml",
+	table: "table",
+	trace: "trace",
+	clear: "clear",
+	group: "startGroup",
+	groupCollapsed: "startGroupCollapsed",
+	groupEnd: "endGroup",
+	assert: "assert",
+	profile: "profile",
+	profileEnd: "profileEnd",
+	count: "count",
+	timeEnd: "timeEnd",
+	timeLog: "log"
+};
+/**
+* Verified against real Chromium, not documented in the pinned TypeScript
+* source (the CDP protocol formats console text in the browser process,
+* which the pinned client only receives already formatted): `group()`,
+* `groupCollapsed()`, `groupEnd()`, `clear()` and `trace()` always report,
+* falling back to `console.<method>` when called with no message argument
+* (`groupEnd()`/`clear()` take none at all, so this is their only text).
+* That fallback is the call's one argument, in `args()` as well as `text()`,
+* as V8's `reportCallWithDefaultArgument` passes it. `assert` falls back the
+* same way in `observe`, once its condition argument is dropped.
+*/
+const FALLBACK_TEXT_METHODS = /* @__PURE__ */ new Set([
+	"group",
+	"groupCollapsed",
+	"groupEnd",
+	"clear",
+	"trace",
+	"assert"
+]);
+/**
+* Verified against real Chromium: a bare call (no arguments) to any of these
+* is never reported at all, unlike the `FALLBACK_TEXT_METHODS` above.
+*/
+const SUPPRESSED_WHEN_EMPTY = /* @__PURE__ */ new Set([
+	"log",
+	"debug",
+	"info",
+	"error",
+	"warn",
+	"dir",
+	"dirxml",
+	"table"
+]);
+const STACK_FRAME = /\(?([^()\s]+):(\d+):(\d+)\)?$/;
+/**
+* Pinned server/chromium/crProtocolHelper.ts `stackTraceToLocation`: the
+* console call's own frame, not the interceptor's. No CDP stack trace is
+* available inside the document, so this is reconstructed from a captured
+* `Error` stack and named best-effort in the ledger: unlike the pinned
+* CDP-sourced location, engine stack-formatting differences and inlining can
+* shift or drop a frame.
+*/
+function captureLocation() {
+	const stack = (/* @__PURE__ */ new Error()).stack;
+	if (!stack) return {
+		url: "",
+		lineNumber: 0,
+		columnNumber: 0
+	};
+	for (const line of stack.split("\n").slice(5)) {
+		const match = STACK_FRAME.exec(line.trim());
+		if (!match) continue;
+		const lineNumber = Number(match[2]) - 1;
+		const columnNumber = Number(match[3]) - 1;
+		if (Number.isNaN(lineNumber) || Number.isNaN(columnNumber)) continue;
+		return {
+			url: match[1],
+			lineNumber,
+			columnNumber
+		};
+	}
+	return {
+		url: "",
+		lineNumber: 0,
+		columnNumber: 0
+	};
+}
+/**
+* A shallow, best-effort stand-in for the pinned CDP object-preview
+* algorithm: a string renders bare; a plain object or array lists its own
+* entries one level deep, each through `previewValue`; anything else is
+* `previewValue` itself. This follows this package's own `JSHandle`
+* description, not V8's preview: no truncation, no sparse-array markers, and
+* a class instance passed directly lists its own members (`{a: 1}`) where
+* Playwright prints its constructor name (`Foo`).
+*
+* Like V8's preview, verified against real Chromium, it never calls the
+* Site's code: entries are read from property descriptors, an accessor
+* renders as `undefined` without being called, and a setter-only property
+* is left out.
+*/
+function formatConsoleArg(value) {
+	if (typeof value === "string") return value;
+	if (Array.isArray(value)) return `[${Array.from({ length: value.length }, (_, index) => previewEntry(Object.getOwnPropertyDescriptor(value, index))).join(", ")}]`;
+	if (value !== null && typeof value === "object" && tagOf(value) === "Object") return `{${Object.keys(value).map((key) => [key, Object.getOwnPropertyDescriptor(value, key)]).filter(([, descriptor]) => descriptor && !isSetterOnly(descriptor)).map(([key, descriptor]) => `${key}: ${previewEntry(descriptor)}`).join(", ")}}`;
+	return previewValue(value);
+}
+/** An array hole renders empty, as `Array.prototype.join` renders it. */
+function previewEntry(descriptor) {
+	if (!descriptor) return "";
+	return "value" in descriptor ? previewValue(descriptor.value) : "undefined";
+}
+function isSetterOnly(descriptor) {
+	return !("value" in descriptor) && !descriptor.get;
+}
+/**
+* Pinned client/consoleMessage.ts `text()`: argument previews joined by a
+* space. The preview never calls Site code, but a Proxy's traps can still
+* throw; that argument then renders as `Object` rather than failing the
+* report.
+*/
+function formatConsoleText(args) {
+	return args.map((arg) => {
+		try {
+			return formatConsoleArg(arg);
+		} catch {
+			return "Object";
+		}
+	}).join(" ");
+}
+/** The one observation of a window's `console`, shared by every `Page` of it. */
+const consoleObservationFor = perWindow((browserWindow) => new ConsoleObservation(browserWindow));
+/**
+* Reports the document's `console.*` calls as Playwright's `console` event,
+* for as long as something is subscribed. Every wrapped method is installed
+* and restored together as one subscription.
+*/
+var ConsoleObservation = class {
+	window;
+	host;
+	constructor(window) {
+		this.window = window;
+		const holder = window.console;
+		this.host = new HostObservation(Object.entries(CONSOLE_METHOD_TYPES).filter(([method]) => typeof holder[method] === "function").map(([method, type]) => ({
+			holder,
+			name: method,
+			intercept: (original, thisArg, args) => this.observe(type, method, original, thisArg, args)
+		})));
+	}
+	/** Reports to `report` until the returned release is called. */
+	subscribe(report) {
+		return this.host.subscribe(report);
+	}
+	/** Guards one report against the reentrancy `observe` documents. */
+	emitting = false;
+	/**
+	* Pinned `console.assert`: reports only when the asserted condition is
+	* falsy, and drops the condition from the reported arguments. Every
+	* synthesized-fallback and bare-call-suppression rule is verified against
+	* real Chromium; see `FALLBACK_TEXT_METHODS`/`SUPPRESSED_WHEN_EMPTY`.
+	*
+	* Observing never changes the Site's call: it returns the native method's
+	* own result, and nothing that fails while building or emitting the report
+	* reaches the caller; such a report is dropped instead.
+	*
+	* A subscriber runs inside this document, unlike the pinned client's
+	* Node-side listener, so one that itself calls a wrapped method (including
+	* indirectly, through this observation's own listener-failure logging)
+	* would otherwise re-enter this method without end; `emitting` guards one
+	* report against that, forwarding to the original method regardless.
+	*/
+	observe(type, method, original, thisArg, args) {
+		const result = Reflect.apply(original, thisArg, args);
+		if (this.emitting) return result;
+		this.emitting = true;
+		try {
+			if (method === "assert") {
+				if (args[0]) return result;
+				args = args.slice(1);
+			}
+			if (args.length === 0) {
+				if (SUPPRESSED_WHEN_EMPTY.has(method)) return result;
+				if (FALLBACK_TEXT_METHODS.has(method)) args = [`console.${method}`];
+			}
+			this.host.report({
+				type,
+				args,
+				text: formatConsoleText(args),
+				location: captureLocation(),
+				timestamp: Date.now()
+			});
+		} catch {} finally {
+			this.emitting = false;
+		}
+		return result;
+	}
+};
+//#endregion
 //#region src/inputFiles.ts
 /**
 * Pinned 26a9e47 client/elementHandle.ts converts payloads before resolving the
@@ -20161,6 +21185,41 @@ const CURRENT_DOCUMENT_WAIT_POLL_DELAY = 20;
 /** Cross-realm brand symbol used to identify this package's Page instances. */
 const PAGE_BRAND = Symbol.for("playwright-lite:page");
 const PAGE_BRAND_TOKEN = Object.freeze({});
+/**
+* One page's use of a host source. `start` subscribes this page and returns
+* the release; the feed holds a subscription while a listener wants the
+* source, and another for good once `retain` is called. For a host observation,
+* `start` always subscribes the page's one stable reporter, which the
+* observation counts once per call, so holding both never reports a call twice.
+*/
+var PageFeed = class {
+	start;
+	stopListening;
+	retained = false;
+	constructor(start) {
+		this.start = start;
+	}
+	/** Starts or stops the listened subscription to match `wanted`. */
+	listen(wanted) {
+		if (wanted === (this.stopListening !== void 0)) return;
+		if (wanted) {
+			this.stopListening = this.start();
+			return;
+		}
+		this.stopListening();
+		this.stopListening = void 0;
+	}
+	/**
+	* Holds a subscription that is never released, as the pinned dispatcher
+	* keeps the subscription a log read adds: a log nobody observes cannot be
+	* filled later.
+	*/
+	retain() {
+		if (this.retained) return;
+		this.retained = true;
+		this.start();
+	}
+};
 var PageImpl = class PageImpl {
 	testIdAttribute;
 	[PAGE_BRAND] = PAGE_BRAND_TOKEN;
@@ -20180,6 +21239,35 @@ var PageImpl = class PageImpl {
 	};
 	defaultTimeout;
 	defaultNavigationTimeout;
+	listeners = /* @__PURE__ */ new Map();
+	pendingListeners = /* @__PURE__ */ new Map();
+	network;
+	dialogs;
+	/** Pinned server/page.ts `_pageBindings`, shared per window like `network`. */
+	bindings;
+	/** This page's identity and by-value round trip for its own bindings. */
+	bindingOwner = {
+		source: {
+			page: this,
+			frame: this
+		},
+		toByValue: (value) => this.evaluation.bindingValue(value)
+	};
+	/** Pinned server/page.ts keeps the recent requests per page, not per realm. */
+	requestLog = [];
+	documentObservers = /* @__PURE__ */ new Set();
+	unobserveDocument;
+	pageErrorsBuffer = [];
+	consoleObservation;
+	consoleMessagesBuffer = [];
+	/**
+	* This page's feed from each host source, started while a listener wants
+	* it and, for the ones with a log, for good once the log has been read.
+	*/
+	navigationFeed;
+	networkFeed;
+	dialogFeed;
+	consoleFeed;
 	constructor(browserWindow, testIdAttribute = DEFAULT_TEST_ID_ATTRIBUTE) {
 		this.testIdAttribute = testIdAttribute;
 		this.window = browserWindow;
@@ -20188,6 +21276,28 @@ var PageImpl = class PageImpl {
 		this.evaluation = new Evaluation(this);
 		this.localStorage = new PageWebStorage(this, "local");
 		this.sessionStorage = new PageWebStorage(this, "session");
+		this.network = networkObservationFor(browserWindow);
+		this.dialogs = dialogObservationFor(browserWindow);
+		this.bindings = bindingsFor(browserWindow);
+		this.consoleObservation = consoleObservationFor(browserWindow);
+		this.navigationFeed = new PageFeed(() => this.observeNavigation());
+		const reportNetwork = (event, payload) => {
+			if (event === "request") recordRequest(this.requestLog, payload);
+			this.emit(event, payload);
+		};
+		this.networkFeed = new PageFeed(() => this.network.subscribe(reportNetwork));
+		const reportDialog = (type, message, defaultValue, box) => {
+			this.emit("dialog", new Dialog(type, message, defaultValue, box, () => this));
+		};
+		this.dialogFeed = new PageFeed(() => this.dialogs.subscribe(reportDialog));
+		const reportConsole = (call) => {
+			const message = buildConsoleMessage(this, call.type, call.args.map((arg) => this.evaluation.handleFor(arg)), call.text, call.location, call.timestamp);
+			this.consoleMessagesBuffer.push(message);
+			ensureArrayLimit(this.consoleMessagesBuffer, 200);
+			this.emit(CONSOLE_EVENT, message);
+		};
+		this.consoleFeed = new PageFeed(() => this.consoleObservation.subscribe(reportConsole));
+		this.startPageErrorCollection();
 	}
 	get injected() {
 		const testIdAttributeName = this.testIdAttribute;
@@ -20769,10 +21879,278 @@ var PageImpl = class PageImpl {
 	mainFrame() {
 		return this;
 	}
+	/**
+	* Pinned client/eventEmitter.ts is a Node EventEmitter: any event name is
+	* accepted, `once` unsubscribes before it fires, and `removeListener` drops
+	* the most recently added copy of a listener.
+	*/
+	on(event, listener) {
+		return this.addListener(event, listener);
+	}
+	addListener(event, listener) {
+		return this.subscribe(event, {
+			listener,
+			once: false
+		}, false);
+	}
+	prependListener(event, listener) {
+		return this.subscribe(event, {
+			listener,
+			once: false
+		}, true);
+	}
+	once(event, listener) {
+		return this.subscribe(event, {
+			listener,
+			once: true
+		}, false);
+	}
+	off(event, listener) {
+		return this.removeListener(event, listener);
+	}
+	removeListener(event, listener) {
+		const entry = this.listeners.get(event)?.findLast((entry) => entry.listener === listener);
+		if (entry) this.unsubscribe(event, entry);
+		return this;
+	}
+	/**
+	* Pinned client/eventEmitter.ts: without options the listeners are dropped
+	* synchronously. With options, `wait` awaits the listener promises still
+	* pending at removal and rethrows the first listener error, `ignoreErrors`
+	* swallows those errors, and `default` removes without waiting. The pinned
+	* emitter replaces its rejection handler for good; here the choice applies
+	* to the listeners pending at removal, and later failures are logged again.
+	*/
+	removeAllListeners(event, options) {
+		if (event === void 0) this.listeners.clear();
+		else this.listeners.delete(event);
+		this.observeHost();
+		if (!options) return this;
+		const pending = event === void 0 ? [...this.pendingListeners.values()].flatMap((set) => [...set]) : [...this.pendingListeners.get(event) ?? []];
+		return this.settlePendingListeners(pending, options);
+	}
+	async settlePendingListeners(pending, options) {
+		rejectUnsupportedOptions("removeAllListeners", options, ["behavior"]);
+		const behavior = options.behavior ?? "default";
+		if (![
+			"wait",
+			"ignoreErrors",
+			"default"
+		].includes(behavior)) throw new TypeError("behavior: expected one of (wait|ignoreErrors|default)");
+		if (behavior === "default") return;
+		const errors = [];
+		for (const listener of pending) listener.onError = behavior === "wait" ? (error) => errors.push(error) : () => {};
+		if (behavior !== "wait") return;
+		await Promise.all(pending.map((listener) => listener.settled));
+		if (errors.length) throw errors[0];
+	}
+	/**
+	* Pinned client/page.ts `_waitForEvent`: a predicate or options argument,
+	* the action timeout, and the listener removed however the wait ends. There
+	* is no browser process here, so no crash or close rejects the wait.
+	*/
+	async waitForEvent(event, optionsOrPredicate = {}) {
+		const options = typeof optionsOrPredicate === "function" ? { predicate: optionsOrPredicate } : optionsOrPredicate;
+		rejectUnsupportedOptions("waitForEvent", options, [
+			"predicate",
+			"signal",
+			"timeout"
+		]);
+		return await this.waitForPageEvent(event, options, "page.waitForEvent", `waiting for event "${event}"`);
+	}
+	/**
+	* Pinned client/page.ts `waitForRequest`: a string or `RegExp` is matched
+	* with the same `urlMatches` `waitForURL` uses, and a function is awaited as
+	* a predicate on the `Request` itself.
+	*/
+	async waitForRequest(urlOrPredicate, options = {}) {
+		rejectUnsupportedOptions("waitForRequest", options, ["signal", "timeout"]);
+		return await this.waitForPageEvent("request", {
+			...options,
+			predicate: networkPredicate(urlOrPredicate, urlMatches)
+		}, "page.waitForRequest", logLineFor("request", urlOrPredicate));
+	}
+	/** Pinned client/page.ts `waitForResponse`, matched like `waitForRequest`. */
+	async waitForResponse(urlOrPredicate, options = {}) {
+		rejectUnsupportedOptions("waitForResponse", options, ["signal", "timeout"]);
+		return await this.waitForPageEvent("response", {
+			...options,
+			predicate: networkPredicate(urlOrPredicate, urlMatches)
+		}, "page.waitForResponse", logLineFor("response", urlOrPredicate));
+	}
+	/**
+	* Pinned client/page.ts `requests`, which also starts the `request`
+	* subscription so the log keeps filling once it has been read.
+	*/
+	async requests() {
+		this.networkFeed.retain();
+		return [...this.requestLog];
+	}
+	async waitForPageEvent(event, options, apiName, logLine) {
+		const timeout = this.resolveTimeout(options.timeout, DEFAULT_ACTION_TIMEOUT);
+		const { predicate, signal } = options;
+		return withAbortPrefix(apiName, () => new Promise((resolve, reject) => {
+			if (signal?.aborted) throw actionAborted(signal, false);
+			let timer;
+			const finish = (done) => {
+				this.removeListener(event, listener);
+				signal?.removeEventListener("abort", onAbort);
+				this.window.clearTimeout(timer);
+				done();
+			};
+			const listener = async (payload) => {
+				try {
+					if (predicate && !await predicate(payload)) return;
+					finish(() => resolve(payload));
+				} catch (error) {
+					finish(() => reject(error));
+				}
+			};
+			const onAbort = () => finish(() => reject(actionAborted(signal, true)));
+			this.addListener(event, listener);
+			signal?.addEventListener("abort", onAbort, { once: true });
+			if (timeout > 0) timer = this.window.setTimeout(() => finish(() => reject(new AdapterTimeoutError(`${apiName}: Timeout ${timeout}ms exceeded while ${logLine}`))), timeout);
+		}));
+	}
+	subscribe(event, entry, prepend) {
+		let entries = this.listeners.get(event);
+		if (!entries) this.listeners.set(event, entries = []);
+		if (prepend) entries.unshift(entry);
+		else entries.push(entry);
+		this.observeHost();
+		return this;
+	}
+	unsubscribe(event, entry) {
+		const entries = this.listeners.get(event);
+		const index = entries?.indexOf(entry) ?? -1;
+		if (index !== -1) entries.splice(index, 1);
+		this.observeHost();
+	}
+	/**
+	* Playwright raises a throwing or rejecting listener as an unhandled
+	* exception in Node. Here the listener runs inside the page, where escaping
+	* would report it as another page error, so it is logged instead. Listeners
+	* are not awaited, as in the pinned emitter; a returned thenable stays
+	* pending for `removeAllListeners` to settle.
+	*/
+	emit(event, payload) {
+		const log = (error) => this.window.console.error(`page.on("${event}"): listener failed`, error);
+		for (const entry of [...this.listeners.get(event) ?? []]) {
+			if (entry.once) this.unsubscribe(event, entry);
+			try {
+				const result = entry.listener(payload);
+				if (typeof result?.then === "function") this.trackPendingListener(event, Promise.resolve(result), log);
+			} catch (error) {
+				log(error);
+			}
+		}
+	}
+	trackPendingListener(event, promise, onError) {
+		let set = this.pendingListeners.get(event);
+		if (!set) this.pendingListeners.set(event, set = /* @__PURE__ */ new Set());
+		const pending = {
+			settled: promise,
+			onError
+		};
+		pending.settled = promise.catch((error) => pending.onError(error)).finally(() => set.delete(pending));
+		set.add(pending);
+	}
+	/**
+	* `framenavigated` is observed on the host only while a listener for it
+	* exists, so the page leaves no trace once it is unsubscribed. Page errors
+	* are collected from page creation regardless of `pageerror` subscribers;
+	* see `startPageErrorCollection`.
+	*/
+	observeHost() {
+		this.navigationFeed.listen(this.isListened("framenavigated"));
+		this.networkFeed.listen(this.isListened(...NETWORK_EVENTS));
+		this.dialogFeed.listen(this.isListened("dialog"));
+		this.consoleFeed.listen(this.isListened(CONSOLE_EVENT));
+	}
+	isListened(...events) {
+		return events.some((event) => (this.listeners.get(event)?.length ?? 0) > 0);
+	}
+	/**
+	* Playwright receives same-document navigations as a browser push
+	* (`Page.navigatedWithinDocument`); here they come from the current-document
+	* observation `waitForURL` uses. Ceiling: the event can arrive up to one
+	* poll tick late, and URL changes within one tick collapse into one event
+	* (none when the URL is back at its previous value).
+	*/
+	observeNavigation() {
+		let url = this.window.location.href;
+		return this.observeDocument(() => {
+			if (this.window.location.href === url) return;
+			url = this.window.location.href;
+			this.emit("framenavigated", this);
+		});
+	}
+	/**
+	* Pinned server/page.ts registers its `error`/`unhandledrejection`
+	* listeners for the page's whole lifetime, not only while a `pageerror`
+	* consumer is subscribed: `pageErrors()` must see errors raised before any
+	* listener existed. These are page-scoped `window` listeners, not a patch
+	* of a host global, so the last-resort rule for patching globals does not
+	* apply. This package has no `Page` dispose/close lifecycle yet (see
+	* `close` in the ledger), so there is nothing to remove them on; they live
+	* for the window's lifetime, same as the page itself.
+	*/
+	startPageErrorCollection() {
+		const onError = (event) => this.addPageError(pageError(event.error));
+		const onRejection = (event) => this.addPageError(pageError(event.reason));
+		this.window.addEventListener("error", onError);
+		this.window.addEventListener("unhandledrejection", onRejection);
+	}
+	/**
+	* Pinned server/page.ts `addPageError`: push, then trim to the pinned
+	* limit, then emit. `emit` is a no-op without `pageerror` subscribers.
+	*/
+	addPageError(error) {
+		this.pageErrorsBuffer.push(error);
+		ensureArrayLimit(this.pageErrorsBuffer, 200);
+		this.emit("pageerror", error);
+	}
 	/** Mirrors pinned Page.title by reading the controlled document title. */
 	async title() {
 		return this.document.title;
 	}
+	/**
+	* Pinned Page.pageErrors: up to the last 200 uncaught errors, wrapped the
+	* same way as the `pageerror` event payload. Pinned server/page.ts marks
+	* the buffer at the last cross-document navigation and, without `filter:
+	* "all"`, returns only errors after that mark; this single-document
+	* adapter never crosses documents within one page's lifetime (a `goto` to
+	* another document replaces it), so no mark is ever set and both `filter`
+	* values return the same errors, in order, since the page was created.
+	*/
+	async pageErrors(options) {
+		rejectUnsupportedOptions("pageErrors", options, ["filter"]);
+		validateHistoryFilter(options?.filter);
+		return this.pageErrorsBuffer.slice();
+	}
+	/** Pinned Page.clearPageErrors: empties the buffer `pageErrors()` reads. */
+	async clearPageErrors() {
+		this.pageErrorsBuffer.length = 0;
+	}
+	/**
+	* Pinned Page.consoleMessages: up to the last 200 `console.*` calls,
+	* wrapped the same way as the `console` event payload. Starts the
+	* `console` subscription so the buffer keeps filling once it has been
+	* read, like `requests()`. Reads the same `since-navigation` equivalence
+	* as `pageErrors`: this single-document adapter never crosses documents
+	* within one page's lifetime, so both `filter` values return the same
+	* messages, in order, since the subscription began.
+	*/
+	async consoleMessages(options) {
+		rejectUnsupportedOptions("consoleMessages", options, ["filter"]);
+		validateHistoryFilter(options?.filter);
+		this.consoleFeed.retain();
+		return this.consoleMessagesBuffer.slice();
+	}
+	/** Pinned Page.clearConsoleMessages: empties the buffer `consoleMessages()` reads. */
+	async clearConsoleMessages() {
+		this.consoleMessagesBuffer.length = 0;
+	}
 	setDefaultTimeout(timeout) {
 		this.defaultTimeout = validateTimeout(timeout, "Default timeout");
 	}
@@ -20914,13 +22292,13 @@ var PageImpl = class PageImpl {
 	* navigation. Location supplies the browser-side navigation here.
 	* Full-document navigation ends this execution; it never resolves with a
 	* fabricated Response or destination-ready result in the old document.
-	* Relative URLs use document.baseURI. Custom referer, AbortSignal, and
-	* networkidle are unsupported and rejected before navigation starts.
+	* Relative URLs use document.baseURI. Custom referer and AbortSignal are
+	* unsupported and rejected before navigation starts. networkidle is
+	* observed from the call on, over the document's fetch and XMLHttpRequest.
 	*/
 	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 = 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");
 		let target;
@@ -20940,8 +22318,10 @@ var PageImpl = class PageImpl {
 		const sameDocument = target.href.includes("#") && target.href.split("#", 1)[0] === current.href.split("#", 1)[0];
 		return new Promise((resolve, reject) => {
 			let timer;
+			const loadState = this.watchLoadState(waitUntil, () => check());
 			const settle = (error) => {
 				this.window.clearTimeout(timer);
+				loadState.release();
 				this.window.removeEventListener("hashchange", check);
 				this.window.removeEventListener("load", check);
 				this.document.removeEventListener("readystatechange", check);
@@ -20950,7 +22330,7 @@ var PageImpl = class PageImpl {
 			};
 			const check = () => {
 				if (!sameDocument || this.window.location.href !== target.href) return;
-				if (waitUntil === "commit" || this.document.readyState === "complete" || waitUntil === "domcontentloaded" && this.document.readyState === "interactive") settle();
+				if (loadState.reached()) settle();
 			};
 			if (sameDocument) {
 				this.window.addEventListener("hashchange", check);
@@ -20973,7 +22353,7 @@ var PageImpl = class PageImpl {
 	* fabricating a cross-document result.
 	*/
 	async waitForLoadState(state = "load", options = {}) {
-		const waitUntil = this.currentDocumentLoadState("state", state);
+		const waitUntil = verifyLoadState("state", state);
 		rejectUnsupportedOptions("waitForLoadState", options, ["signal", "timeout"]);
 		assertCurrentDocumentWaitTimeout("waitForLoadState", options.timeout);
 		await this.waitForCurrentDocument("page.waitForLoadState", waitUntil, void 0, options);
@@ -20991,7 +22371,7 @@ var PageImpl = class PageImpl {
 			"waitUntil"
 		]);
 		assertCurrentDocumentWaitTimeout("waitForURL", options.timeout);
-		const waitUntil = this.currentDocumentLoadState("waitUntil", options.waitUntil ?? "load");
+		const waitUntil = verifyLoadState("waitUntil", options.waitUntil ?? "load");
 		await this.waitForCurrentDocument("page.waitForURL", waitUntil, url, options);
 	}
 	/**
@@ -21041,13 +22421,45 @@ var PageImpl = class PageImpl {
 	async evaluate(pageFunction, arg, options) {
 		assertMaxArguments(arguments.length, 3);
 		assertEvaluationOptions(options);
-		return this._evaluateExpression(pageFunction, typeof pageFunction === "function", arg);
+		return this._evaluateExpression(pageFunction, typeof pageFunction === "function", arg, options);
 	}
 	/** 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);
+		return this.evaluation.byHandle(pageFunction, typeof pageFunction === "function", arg, void 0, options);
+	}
+	/** Pinned client/page.ts `exposeFunction`: defines `name` on `window`,
+	* forwarding the pinned by-value round trip both ways. */
+	async exposeFunction(name, callback) {
+		return this.installBinding("page.exposeFunction", name, (_source, ...args) => callback(...args));
+	}
+	/** Pinned client/page.ts `exposeBinding` / server/page.ts `exposeBinding`:
+	* defines `name` on `window` with the pinned duplicate-name error; the
+	* callback receives `{ page, frame: page }` as `source` (no `context`: this
+	* package has no `BrowserContext`). */
+	async exposeBinding(name, callback) {
+		return this.installBinding("page.exposeBinding", name, callback);
+	}
+	/**
+	* Pinned client methods prefix a thrown error with their own API name. The
+	* returned `Disposable`'s `dispose()` (and `Symbol.asyncDispose`) removes
+	* the binding, per pinned server/page.ts `PageBinding.dispose`.
+	*/
+	async installBinding(apiName, name, callback) {
+		let remove;
+		try {
+			remove = this.bindings.expose(this.bindingOwner, name, callback);
+		} catch (error) {
+			const result = asError(error);
+			result.message = `${apiName}: ${result.message}`;
+			throw result;
+		}
+		const dispose = async () => remove();
+		return {
+			dispose,
+			[Symbol.asyncDispose]: dispose
+		};
 	}
 	/** Evaluates through the pinned Playwright UtilityScript. */
 	async $eval(selector, callback, arg) {
@@ -21067,8 +22479,8 @@ var PageImpl = class PageImpl {
 		await this.wait(timeout);
 	}
 	/** Evaluates through the pinned Playwright UtilityScript. */
-	async _evaluateExpression(expression, isFunction, arg) {
-		return this.evaluation.byValue(expression, isFunction, arg);
+	async _evaluateExpression(expression, isFunction, arg, options) {
+		return this.evaluation.byValue(expression, isFunction, arg, void 0, options);
 	}
 	/**
 	* Polls a predicate in the controlled document until it returns a
@@ -21240,10 +22652,11 @@ var PageImpl = class PageImpl {
 		const signal = options.signal;
 		await withAbortPrefix(apiName, async () => {
 			let urlMatched = url === void 0;
+			const loadState = this.watchLoadState(waitUntil);
 			const observation = await this.observeCurrentDocument(() => {
 				if (!urlMatched) urlMatched = urlMatches(this.window.location.href, url);
-				return urlMatched && this.currentDocumentHasLoadState(waitUntil);
-			}, timeout, signal);
+				return urlMatched && loadState.reached();
+			}, timeout, signal).finally(loadState.release);
 			if ("completed" in observation) return;
 			if ("aborted" in observation) throw observation.aborted;
 			if ("error" in observation) throw observation.error;
@@ -21255,15 +22668,11 @@ var PageImpl = class PageImpl {
 		return new Promise((resolve) => {
 			let settled = false;
 			let timeoutId;
-			let pollId;
+			let unobserve = () => {};
 			const cleanup = () => {
-				this.window.removeEventListener("hashchange", checkDocument);
-				this.window.removeEventListener("popstate", checkDocument);
-				this.window.removeEventListener("load", checkDocument);
-				this.document.removeEventListener("readystatechange", checkDocument);
+				unobserve();
 				signal?.removeEventListener("abort", onAbort);
 				if (timeoutId !== void 0) this.window.clearTimeout(timeoutId);
-				if (pollId !== void 0) this.window.clearTimeout(pollId);
 			};
 			const settle = (result) => {
 				if (settled) return;
@@ -21274,25 +22683,16 @@ var PageImpl = class PageImpl {
 			const runCheck = () => {
 				try {
 					if (check()) settle({ completed: true });
-					return true;
 				} catch (error) {
 					settle({ error });
-					return false;
 				}
 			};
 			const onAbort = () => {
 				runCheck();
 				if (!settled) settle({ aborted: actionAborted(signal, true) });
 			};
-			const schedulePoll = () => {
-				if (!settled && pollId === void 0) pollId = this.window.setTimeout(() => {
-					pollId = void 0;
-					checkDocument();
-				}, CURRENT_DOCUMENT_WAIT_POLL_DELAY);
-			};
 			const checkDocument = () => {
-				if (settled) return;
-				if (runCheck()) schedulePoll();
+				if (!settled) runCheck();
 			};
 			const onTimeout = () => {
 				runCheck();
@@ -21303,22 +22703,63 @@ var PageImpl = class PageImpl {
 				return;
 			}
 			signal?.addEventListener("abort", onAbort, { once: true });
-			this.window.addEventListener("hashchange", checkDocument);
-			this.window.addEventListener("popstate", checkDocument);
-			this.window.addEventListener("load", checkDocument);
-			this.document.addEventListener("readystatechange", checkDocument);
+			unobserve = this.observeDocument(checkDocument);
 			if (timeout > 0) timeoutId = this.window.setTimeout(onTimeout, timeout);
 			checkDocument();
 		});
 	}
-	currentDocumentLoadState(name, state) {
-		const waitUntil = verifyLoadState(name, state);
-		if (waitUntil === "networkidle") throw new Error(`Unsupported ${name} value: ${waitUntil}`);
-		return waitUntil;
+	/**
+	* One set of `hashchange`/`popstate`/`load`/`readystatechange` listeners
+	* plus one 20 ms poll, shared by every current-document consumer
+	* (`waitForURL`, `waitForLoadState`, `expect(page).toHaveURL`,
+	* `expect(page).toHaveTitle`, `framenavigated`) and running only while at
+	* least one observes.
+	*/
+	observeDocument(observer) {
+		this.documentObservers.add(observer);
+		if (this.documentObservers.size === 1) {
+			const notify = () => {
+				for (const observer of [...this.documentObservers]) observer();
+			};
+			const pollId = this.window.setInterval(notify, CURRENT_DOCUMENT_WAIT_POLL_DELAY);
+			this.window.addEventListener("hashchange", notify);
+			this.window.addEventListener("popstate", notify);
+			this.window.addEventListener("load", notify);
+			this.document.addEventListener("readystatechange", notify);
+			this.unobserveDocument = () => {
+				this.window.clearInterval(pollId);
+				this.window.removeEventListener("hashchange", notify);
+				this.window.removeEventListener("popstate", notify);
+				this.window.removeEventListener("load", notify);
+				this.document.removeEventListener("readystatechange", notify);
+			};
+		}
+		return () => {
+			if (!this.documentObservers.delete(observer) || this.documentObservers.size) return;
+			this.unobserveDocument();
+			this.unobserveDocument = void 0;
+		};
 	}
-	currentDocumentHasLoadState(waitUntil) {
-		if (waitUntil === "commit") return true;
-		return this.document.readyState === "complete" || waitUntil === "domcontentloaded" && this.document.readyState === "interactive";
+	/**
+	* Whether the document reached `waitUntil`. `networkidle` subscribes to the
+	* network observation until `release`, and calls `onIdle` once reached;
+	* the other states are read from the document's ready state.
+	*/
+	watchLoadState(waitUntil, onIdle = () => {}) {
+		if (waitUntil === "networkidle") {
+			let idle = false;
+			return {
+				reached: () => idle,
+				release: this.network.observeIdle(() => {
+					idle = true;
+					onIdle();
+				})
+			};
+		}
+		return {
+			reached: () => waitUntil === "commit" || this.document.readyState === "complete" || waitUntil === "domcontentloaded" && this.document.readyState === "interactive",
+			release: () => {}
+		};
 	}
 	createActionDeadline(timeout) {
 		const effectiveTimeout = this.resolveTimeout(timeout, DEFAULT_ACTION_TIMEOUT);
@@ -21407,10 +22848,10 @@ 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));
+		return this.evaluation.byValue(pageFunction, typeof pageFunction === "function", arg, await this.locatorEvaluationTarget(selector, label, options), options);
 	}
 	async locatorEvaluateHandle(selector, label, pageFunction, arg, options) {
-		return this.evaluation.byHandle(pageFunction, typeof pageFunction === "function", arg, await this.locatorEvaluationTarget(selector, label, options));
+		return this.evaluation.byHandle(pageFunction, typeof pageFunction === "function", arg, await this.locatorEvaluationTarget(selector, label, options), options);
 	}
 	/** Pinned locator.ts resolves the element before it evaluates against it. */
 	async locatorEvaluationTarget(selector, label, options) {
@@ -22321,6 +23762,39 @@ function actionPoint(element, position, browserWindow) {
 function asError(error) {
 	return error instanceof Error ? error : new Error(String(error));
 }
+/**
+* Pinned crProtocolHelper.ts `exceptionToError` receives a thrown non-Error
+* value as its protocol description (the class name of an object, otherwise
+* `String(value)`), splits it at the first `:` into name and message with
+* `splitErrorMessage`, has no stack for it, and takes the name from the
+* value's own `name` property when the protocol preview shows one. A thrown
+* Error already is the error Playwright would rebuild from its name, message
+* and stack.
+*/
+function pageError(thrown) {
+	if (thrown instanceof Error) return thrown;
+	const description = thrown !== null && typeof thrown === "object" ? thrown.constructor?.name ?? "Object" : String(thrown);
+	const separator = description.indexOf(":");
+	const error = new Error(separator !== -1 && separator + 2 <= description.length ? description.slice(separator + 2) : description);
+	const named = thrown !== null && typeof thrown === "object" && Object.hasOwn(thrown, "name") ? thrown.name : void 0;
+	error.name = named !== void 0 ? typeof named === "object" || typeof named === "function" ? "Error" : String(named) : separator !== -1 ? description.slice(0, separator) : "";
+	error.stack = "";
+	return error;
+}
+/**
+* Pinned server/page.ts `ensureArrayLimit`: once an array exceeds `limit`,
+* drop the oldest tenth rather than trimming on every push. The pinned
+* function returns the spliced-off elements; nothing here reads that
+* return value, so this copy returns void.
+*/
+function ensureArrayLimit(array, limit) {
+	if (array.length > limit) array.splice(0, limit / 10);
+}
+/** Shared by `pageErrors` and `consoleMessages`, whose `filter` is identical. */
+function validateHistoryFilter(value) {
+	if (value === void 0 || value === "all" || value === "since-navigation") return;
+	throw new TypeError("filter: expected one of (all|since-navigation)");
+}
 function isRetryableActionError(error) {
 	const message = asError(error).message;
 	return message.startsWith("No elements found for locator") || message === "Element is not connected" || message.startsWith("Element is not ") || message === "Element is outside of the viewport" || message.startsWith("Element does not receive pointer events");