patchright-core 1.52.4 → 1.55.0

package/lib/client/elementHandle.js

@@ -40,6 +40,7 @@ class ElementHandle extends import_jsHandle.JSHandle {
   }
   constructor(parent, type, guid, initializer) {
     super(parent, type, guid, initializer);
+    this._frame = parent;
     this._elementChannel = this._channel;
   }
   asElement() {
@@ -51,10 +52,6 @@ class ElementHandle extends import_jsHandle.JSHandle {
   async contentFrame() {
     return import_frame.Frame.fromNullable((await this._elementChannel.contentFrame()).frame);
   }
-  async _generateLocatorString() {
-    const value = (await this._elementChannel.generateLocatorString()).value;
-    return value === void 0 ? null : value;
-  }
   async getAttribute(name) {
     const value = (await this._elementChannel.getAttribute({ name })).value;
     return value === void 0 ? null : value;
@@ -94,51 +91,51 @@ class ElementHandle extends import_jsHandle.JSHandle {
     await this._elementChannel.dispatchEvent({ type, eventInit: (0, import_jsHandle.serializeArgument)(eventInit) });
   }
   async scrollIntoViewIfNeeded(options = {}) {
-    await this._elementChannel.scrollIntoViewIfNeeded(options);
+    await this._elementChannel.scrollIntoViewIfNeeded({ ...options, timeout: this._frame._timeout(options) });
   }
   async hover(options = {}) {
-    await this._elementChannel.hover(options);
+    await this._elementChannel.hover({ ...options, timeout: this._frame._timeout(options) });
   }
   async click(options = {}) {
-    return await this._elementChannel.click(options);
+    return await this._elementChannel.click({ ...options, timeout: this._frame._timeout(options) });
   }
   async dblclick(options = {}) {
-    return await this._elementChannel.dblclick(options);
+    return await this._elementChannel.dblclick({ ...options, timeout: this._frame._timeout(options) });
   }
   async tap(options = {}) {
-    return await this._elementChannel.tap(options);
+    return await this._elementChannel.tap({ ...options, timeout: this._frame._timeout(options) });
   }
   async selectOption(values, options = {}) {
-    const result = await this._elementChannel.selectOption({ ...convertSelectOptionValues(values), ...options });
+    const result = await this._elementChannel.selectOption({ ...convertSelectOptionValues(values), ...options, timeout: this._frame._timeout(options) });
     return result.values;
   }
   async fill(value, options = {}) {
-    return await this._elementChannel.fill({ value, ...options });
+    return await this._elementChannel.fill({ value, ...options, timeout: this._frame._timeout(options) });
   }
   async selectText(options = {}) {
-    await this._elementChannel.selectText(options);
+    await this._elementChannel.selectText({ ...options, timeout: this._frame._timeout(options) });
   }
   async setInputFiles(files, options = {}) {
     const frame = await this.ownerFrame();
     if (!frame)
       throw new Error("Cannot set input files to detached element");
     const converted = await convertInputFiles(this._platform, files, frame.page().context());
-    await this._elementChannel.setInputFiles({ ...converted, ...options });
+    await this._elementChannel.setInputFiles({ ...converted, ...options, timeout: this._frame._timeout(options) });
   }
   async focus() {
     await this._elementChannel.focus();
   }
   async type(text, options = {}) {
-    await this._elementChannel.type({ text, ...options });
+    await this._elementChannel.type({ text, ...options, timeout: this._frame._timeout(options) });
   }
   async press(key, options = {}) {
-    await this._elementChannel.press({ key, ...options });
+    await this._elementChannel.press({ key, ...options, timeout: this._frame._timeout(options) });
   }
   async check(options = {}) {
-    return await this._elementChannel.check(options);
+    return await this._elementChannel.check({ ...options, timeout: this._frame._timeout(options) });
   }
   async uncheck(options = {}) {
-    return await this._elementChannel.uncheck(options);
+    return await this._elementChannel.uncheck({ ...options, timeout: this._frame._timeout(options) });
   }
   async setChecked(checked, options) {
     if (checked)
@@ -152,7 +149,7 @@ class ElementHandle extends import_jsHandle.JSHandle {
   }
   async screenshot(options = {}) {
     const mask = options.mask;
-    const copy = { ...options, mask: void 0 };
+    const copy = { ...options, mask: void 0, timeout: this._frame._timeout(options) };
     if (!copy.type)
       copy.type = determineScreenshotType(options);
     if (mask) {
@@ -184,10 +181,10 @@ class ElementHandle extends import_jsHandle.JSHandle {
     return (0, import_jsHandle.parseResult)(result.value);
   }
   async waitForElementState(state, options = {}) {
-    return await this._elementChannel.waitForElementState({ state, ...options });
+    return await this._elementChannel.waitForElementState({ state, ...options, timeout: this._frame._timeout(options) });
   }
   async waitForSelector(selector, options = {}) {
-    const result = await this._elementChannel.waitForSelector({ selector, ...options });
+    const result = await this._elementChannel.waitForSelector({ selector, ...options, timeout: this._frame._timeout(options) });
     return ElementHandle.fromNullable(result.element);
   }
 }
@@ -244,7 +241,7 @@ async function convertInputFiles(platform, files, context) {
             lastModifiedMs
           };
         }))
-      }), true);
+      }), { internal: true });
       for (let i = 0; i < files2.length; i++) {
         const writable = import_writableStream.WritableStream.from(writableStreams[i]);
         await platform.streamFile(files2[i], writable.stream());

package/lib/client/fetch.js

@@ -32,6 +32,7 @@ var import_assert = require("../utils/isomorphic/assert");
 var import_fileUtils = require("./fileUtils");
 var import_headers = require("../utils/isomorphic/headers");
 var import_rtti = require("../utils/isomorphic/rtti");
+var import_timeoutSettings = require("./timeoutSettings");
 class APIRequest {
   constructor(playwright) {
     this._contexts = /* @__PURE__ */ new Set();
@@ -40,7 +41,6 @@ class APIRequest {
   async newContext(options = {}) {
     options = {
       ...this._playwright._defaultContextOptions,
-      timeout: this._playwright._defaultContextTimeout,
       ...options
     };
     const storageState = typeof options.storageState === "string" ? JSON.parse(await this._playwright._platform.fs().promises.readFile(options.storageState, "utf8")) : options.storageState;
@@ -54,6 +54,7 @@ class APIRequest {
     })).request);
     this._contexts.add(context);
     context._request = this;
+    context._timeoutSettings.setDefaultTimeout(options.timeout ?? this._playwright._defaultContextTimeout);
     context._tracing._tracesDir = this._playwright._defaultLaunchOptions?.tracesDir;
     await context._instrumentation.runAfterCreateRequestContext(context);
     return context;
@@ -66,6 +67,7 @@ class APIRequestContext extends import_channelOwner.ChannelOwner {
   constructor(parent, type, guid, initializer) {
     super(parent, type, guid, initializer);
     this._tracing = import_tracing.Tracing.from(initializer.tracing);
+    this._timeoutSettings = new import_timeoutSettings.TimeoutSettings(this._platform);
   }
   async [Symbol.asyncDispose]() {
     await this.dispose();
@@ -205,7 +207,7 @@ class APIRequestContext extends import_channelOwner.ChannelOwner {
         jsonData,
         formData,
         multipartData,
-        timeout: options.timeout,
+        timeout: this._timeoutSettings.timeout(options),
         failOnStatusCode: options.failOnStatusCode,
         ignoreHTTPSErrors: options.ignoreHTTPSErrors,
         maxRedirects: options.maxRedirects,
@@ -288,7 +290,7 @@ class APIResponse {
           throw new Error("Response has been disposed");
         throw e;
       }
-    }, true);
+    }, { internal: true });
   }
   async text() {
     const content = await this.body();

package/lib/client/frame.js

@@ -45,6 +45,7 @@ var import_waiter = require("./waiter");
 var import_assert = require("../utils/isomorphic/assert");
 var import_locatorUtils = require("../utils/isomorphic/locatorUtils");
 var import_urlMatch = require("../utils/isomorphic/urlMatch");
+var import_timeoutSettings = require("./timeoutSettings");
 class Frame extends import_channelOwner.ChannelOwner {
   constructor(parent, type, guid, initializer) {
     super(parent, type, guid, initializer);
@@ -90,9 +91,17 @@ class Frame extends import_channelOwner.ChannelOwner {
   page() {
     return this._page;
   }
+  _timeout(options) {
+    const timeoutSettings = this._page?._timeoutSettings || new import_timeoutSettings.TimeoutSettings(this._platform);
+    return timeoutSettings.timeout(options || {});
+  }
+  _navigationTimeout(options) {
+    const timeoutSettings = this._page?._timeoutSettings || new import_timeoutSettings.TimeoutSettings(this._platform);
+    return timeoutSettings.navigationTimeout(options || {});
+  }
   async goto(url, options = {}) {
     const waitUntil = verifyLoadState("waitUntil", options.waitUntil === void 0 ? "load" : options.waitUntil);
-    return network.Response.fromNullable((await this._channel.goto({ url, ...options, waitUntil })).response);
+    return network.Response.fromNullable((await this._channel.goto({ url, ...options, waitUntil, timeout: this._navigationTimeout(options) })).response);
   }
   _setupNavigationWaiter(options) {
     const waiter = new import_waiter.Waiter(this._page, "");
@@ -132,7 +141,7 @@ class Frame extends import_channelOwner.ChannelOwner {
       const response = request ? await waiter.waitForPromise(request._finalRequest()._internalResponse()) : null;
       waiter.dispose();
       return response;
-    });
+    }, { title: "Wait for navigation" });
   }
   async waitForLoadState(state = "load", options = {}) {
     state = verifyLoadState("state", state);
@@ -147,7 +156,7 @@ class Frame extends import_channelOwner.ChannelOwner {
         });
       }
       waiter.dispose();
-    });
+    }, { title: `Wait for load state "${state}"` });
   }
   async waitForURL(url, options = {}) {
     if ((0, import_urlMatch.urlMatches)(this._page?.context()._options.baseURL, this.url(), url))
@@ -167,6 +176,10 @@ class Frame extends import_channelOwner.ChannelOwner {
     const result = await this._channel.evaluateExpression({ expression: String(pageFunction), isFunction: typeof pageFunction === "function", arg: (0, import_jsHandle.serializeArgument)(arg), isolatedContext });
     return (0, import_jsHandle.parseResult)(result.value);
   }
+  async _evaluateFunction(functionDeclaration) {
+    const result = await this._channel.evaluateExpression({ expression: functionDeclaration, isFunction: true, arg: (0, import_jsHandle.serializeArgument)(void 0) });
+    return (0, import_jsHandle.parseResult)(result.value);
+  }
   async _evaluateExposeUtilityScript(pageFunction, arg) {
     (0, import_jsHandle.assertMaxArguments)(arguments.length, 2);
     const result = await this._channel.evaluateExpression({ expression: String(pageFunction), isFunction: typeof pageFunction === "function", arg: (0, import_jsHandle.serializeArgument)(arg) });
@@ -181,35 +194,35 @@ class Frame extends import_channelOwner.ChannelOwner {
       throw new Error("options.visibility is not supported, did you mean options.state?");
     if (options.waitFor && options.waitFor !== "visible")
       throw new Error("options.waitFor is not supported, did you mean options.state?");
-    const result = await this._channel.waitForSelector({ selector, ...options });
+    const result = await this._channel.waitForSelector({ selector, ...options, timeout: this._timeout(options) });
     return import_elementHandle.ElementHandle.fromNullable(result.element);
   }
   async dispatchEvent(selector, type, eventInit, options = {}) {
-    await this._channel.dispatchEvent({ selector, type, eventInit: (0, import_jsHandle.serializeArgument)(eventInit), ...options });
+    await this._channel.dispatchEvent({ selector, type, eventInit: (0, import_jsHandle.serializeArgument)(eventInit), ...options, timeout: this._timeout(options) });
   }
   async $eval(selector, pageFunction, arg) {
     (0, import_jsHandle.assertMaxArguments)(arguments.length, 3);
     const result = await this._channel.evalOnSelector({ selector, expression: String(pageFunction), isFunction: typeof pageFunction === "function", arg: (0, import_jsHandle.serializeArgument)(arg) });
     return (0, import_jsHandle.parseResult)(result.value);
   }
-  async $$eval(selector, pageFunction, arg) {
-    (0, import_jsHandle.assertMaxArguments)(arguments.length, 3);
-    const result = await this._channel.evalOnSelectorAll({ selector, expression: String(pageFunction), isFunction: typeof pageFunction === "function", arg: (0, import_jsHandle.serializeArgument)(arg) });
+  async $$eval(selector, pageFunction, arg, isolatedContext = true) {
+    (0, import_jsHandle.assertMaxArguments)(arguments.length, 4);
+    const result = await this._channel.evalOnSelectorAll({ selector, expression: String(pageFunction), isFunction: typeof pageFunction === "function", arg: (0, import_jsHandle.serializeArgument)(arg), isolatedContext });
     return (0, import_jsHandle.parseResult)(result.value);
   }
   async $$(selector) {
     const result = await this._channel.querySelectorAll({ selector });
     return result.elements.map((e) => import_elementHandle.ElementHandle.from(e));
   }
-  async _queryCount(selector) {
-    return (await this._channel.queryCount({ selector })).value;
+  async _queryCount(selector, options) {
+    return (await this._channel.queryCount({ selector, ...options })).value;
   }
   async content() {
     return (await this._channel.content()).value;
   }
   async setContent(html, options = {}) {
     const waitUntil = verifyLoadState("waitUntil", options.waitUntil === void 0 ? "load" : options.waitUntil);
-    await this._channel.setContent({ html, ...options, waitUntil });
+    await this._channel.setContent({ html, ...options, waitUntil, timeout: this._navigationTimeout(options) });
   }
   name() {
     return this._name || "";
@@ -243,19 +256,19 @@ class Frame extends import_channelOwner.ChannelOwner {
     return import_elementHandle.ElementHandle.from((await this._channel.addStyleTag({ ...copy })).element);
   }
   async click(selector, options = {}) {
-    return await this._channel.click({ selector, ...options });
+    return await this._channel.click({ selector, ...options, timeout: this._timeout(options) });
   }
   async dblclick(selector, options = {}) {
-    return await this._channel.dblclick({ selector, ...options });
+    return await this._channel.dblclick({ selector, ...options, timeout: this._timeout(options) });
   }
   async dragAndDrop(source, target, options = {}) {
-    return await this._channel.dragAndDrop({ source, target, ...options });
+    return await this._channel.dragAndDrop({ source, target, ...options, timeout: this._timeout(options) });
   }
   async tap(selector, options = {}) {
-    return await this._channel.tap({ selector, ...options });
+    return await this._channel.tap({ selector, ...options, timeout: this._timeout(options) });
   }
   async fill(selector, value, options = {}) {
-    return await this._channel.fill({ selector, value, ...options });
+    return await this._channel.fill({ selector, value, ...options, timeout: this._timeout(options) });
   }
   async _highlight(selector) {
     return await this._channel.highlight({ selector });
@@ -288,36 +301,36 @@ class Frame extends import_channelOwner.ChannelOwner {
     return new import_locator.FrameLocator(this, selector);
   }
   async focus(selector, options = {}) {
-    await this._channel.focus({ selector, ...options });
+    await this._channel.focus({ selector, ...options, timeout: this._timeout(options) });
   }
   async textContent(selector, options = {}) {
-    const value = (await this._channel.textContent({ selector, ...options })).value;
+    const value = (await this._channel.textContent({ selector, ...options, timeout: this._timeout(options) })).value;
     return value === void 0 ? null : value;
   }
   async innerText(selector, options = {}) {
-    return (await this._channel.innerText({ selector, ...options })).value;
+    return (await this._channel.innerText({ selector, ...options, timeout: this._timeout(options) })).value;
   }
   async innerHTML(selector, options = {}) {
-    return (await this._channel.innerHTML({ selector, ...options })).value;
+    return (await this._channel.innerHTML({ selector, ...options, timeout: this._timeout(options) })).value;
   }
   async getAttribute(selector, name, options = {}) {
-    const value = (await this._channel.getAttribute({ selector, name, ...options })).value;
+    const value = (await this._channel.getAttribute({ selector, name, ...options, timeout: this._timeout(options) })).value;
     return value === void 0 ? null : value;
   }
   async inputValue(selector, options = {}) {
-    return (await this._channel.inputValue({ selector, ...options })).value;
+    return (await this._channel.inputValue({ selector, ...options, timeout: this._timeout(options) })).value;
   }
   async isChecked(selector, options = {}) {
-    return (await this._channel.isChecked({ selector, ...options })).value;
+    return (await this._channel.isChecked({ selector, ...options, timeout: this._timeout(options) })).value;
   }
   async isDisabled(selector, options = {}) {
-    return (await this._channel.isDisabled({ selector, ...options })).value;
+    return (await this._channel.isDisabled({ selector, ...options, timeout: this._timeout(options) })).value;
   }
   async isEditable(selector, options = {}) {
-    return (await this._channel.isEditable({ selector, ...options })).value;
+    return (await this._channel.isEditable({ selector, ...options, timeout: this._timeout(options) })).value;
   }
   async isEnabled(selector, options = {}) {
-    return (await this._channel.isEnabled({ selector, ...options })).value;
+    return (await this._channel.isEnabled({ selector, ...options, timeout: this._timeout(options) })).value;
   }
   async isHidden(selector, options = {}) {
     return (await this._channel.isHidden({ selector, ...options })).value;
@@ -326,26 +339,26 @@ class Frame extends import_channelOwner.ChannelOwner {
     return (await this._channel.isVisible({ selector, ...options })).value;
   }
   async hover(selector, options = {}) {
-    await this._channel.hover({ selector, ...options });
+    await this._channel.hover({ selector, ...options, timeout: this._timeout(options) });
   }
   async selectOption(selector, values, options = {}) {
-    return (await this._channel.selectOption({ selector, ...(0, import_elementHandle.convertSelectOptionValues)(values), ...options })).values;
+    return (await this._channel.selectOption({ selector, ...(0, import_elementHandle.convertSelectOptionValues)(values), ...options, timeout: this._timeout(options) })).values;
   }
   async setInputFiles(selector, files, options = {}) {
     const converted = await (0, import_elementHandle.convertInputFiles)(this._platform, files, this.page().context());
-    await this._channel.setInputFiles({ selector, ...converted, ...options });
+    await this._channel.setInputFiles({ selector, ...converted, ...options, timeout: this._timeout(options) });
   }
   async type(selector, text, options = {}) {
-    await this._channel.type({ selector, text, ...options });
+    await this._channel.type({ selector, text, ...options, timeout: this._timeout(options) });
   }
   async press(selector, key, options = {}) {
-    await this._channel.press({ selector, key, ...options });
+    await this._channel.press({ selector, key, ...options, timeout: this._timeout(options) });
   }
   async check(selector, options = {}) {
-    await this._channel.check({ selector, ...options });
+    await this._channel.check({ selector, ...options, timeout: this._timeout(options) });
   }
   async uncheck(selector, options = {}) {
-    await this._channel.uncheck({ selector, ...options });
+    await this._channel.uncheck({ selector, ...options, timeout: this._timeout(options) });
   }
   async setChecked(selector, checked, options) {
     if (checked)
@@ -354,7 +367,7 @@ class Frame extends import_channelOwner.ChannelOwner {
       await this.uncheck(selector, options);
   }
   async waitForTimeout(timeout) {
-    await this._channel.waitForTimeout({ timeout });
+    await this._channel.waitForTimeout({ waitTimeout: timeout });
   }
   async waitForFunction(pageFunction, arg, options = {}) {
     if (typeof options.polling === "string")
@@ -364,13 +377,22 @@ class Frame extends import_channelOwner.ChannelOwner {
       pollingInterval: options.polling === "raf" ? void 0 : options.polling,
       expression: String(pageFunction),
       isFunction: typeof pageFunction === "function",
-      arg: (0, import_jsHandle.serializeArgument)(arg)
+      arg: (0, import_jsHandle.serializeArgument)(arg),
+      timeout: this._timeout(options)
     });
     return import_jsHandle.JSHandle.from(result.handle);
   }
   async title() {
     return (await this._channel.title()).value;
   }
+  async _expect(expression, options) {
+    const params = { expression, ...options, isNot: !!options.isNot };
+    params.expectedValue = (0, import_jsHandle.serializeArgument)(options.expectedValue);
+    const result = await this._channel.expect(params);
+    if (result.received !== void 0)
+      result.received = (0, import_jsHandle.parseResult)(result.received);
+    return result;
+  }
 }
 function verifyLoadState(name, waitUntil) {
   if (waitUntil === "networkidle0")

package/lib/client/input.js

@@ -60,7 +60,9 @@ class Mouse {
     await this._page._channel.mouseClick({ x, y, ...options });
   }
   async dblclick(x, y, options = {}) {
-    await this.click(x, y, { ...options, clickCount: 2 });
+    await this._page._wrapApiCall(async () => {
+      await this.click(x, y, { ...options, clickCount: 2 });
+    }, { title: "Double click" });
   }
   async wheel(deltaX, deltaY) {
     await this._page._channel.mouseWheel({ deltaX, deltaY });

package/lib/client/jsHandle.js

@@ -40,6 +40,10 @@ class JSHandle extends import_channelOwner.ChannelOwner {
     const result = await this._channel.evaluateExpression({ expression: String(pageFunction), isFunction: typeof pageFunction === "function", arg: serializeArgument(arg), isolatedContext });
     return parseResult(result.value);
   }
+  async _evaluateFunction(functionDeclaration) {
+    const result = await this._channel.evaluateExpression({ expression: functionDeclaration, isFunction: true, arg: serializeArgument(void 0) });
+    return parseResult(result.value);
+  }
   async evaluateHandle(pageFunction, arg, isolatedContext = true) {
     const result = await this._channel.evaluateExpressionHandle({ expression: String(pageFunction), isFunction: typeof pageFunction === "function", arg: serializeArgument(arg), isolatedContext });
     return JSHandle.from(result.handle);

package/lib/client/localUtils.js

@@ -25,7 +25,6 @@ var import_channelOwner = require("./channelOwner");
 class LocalUtils extends import_channelOwner.ChannelOwner {
   constructor(parent, type, guid, initializer) {
     super(parent, type, guid, initializer);
-    this.markAsInternalType();
     this.devices = {};
     for (const { name, descriptor } of initializer.deviceDescriptors)
       this.devices[name] = descriptor;

package/lib/client/locator.js

@@ -26,7 +26,6 @@ __export(locator_exports, {
 module.exports = __toCommonJS(locator_exports);
 var import_jsHandle = require("./jsHandle");
 var import_elementHandle = require("./elementHandle");
-var import_jsHandle2 = require("./jsHandle");
 var import_locatorGenerators = require("../utils/isomorphic/locatorGenerators");
 var import_locatorUtils = require("../utils/isomorphic/locatorUtils");
 var import_stringUtils = require("../utils/isomorphic/stringUtils");
@@ -57,8 +56,8 @@ class Locator {
     if (this._frame._platform.inspectCustom)
       this[this._frame._platform.inspectCustom] = () => this._inspect();
   }
-  async _withElement(task, timeout) {
-    timeout = this._frame.page()._timeoutSettings.timeout({ timeout });
+  async _withElement(task, options) {
+    const timeout = this._frame._timeout({ timeout: options.timeout });
     const deadline = timeout ? (0, import_time.monotonicTime)() + timeout : 0;
     return await this._frame._wrapApiCall(async () => {
       const result = await this._frame._channel.waitForSelector({ selector: this._selector, strict: true, state: "attached", timeout });
@@ -70,7 +69,7 @@ class Locator {
       } finally {
         await handle.dispose();
       }
-    });
+    }, { title: options.title, internal: options.internal });
   }
   _equals(locator) {
     return this._frame === locator._frame && this._selector === locator._selector;
@@ -79,7 +78,7 @@ class Locator {
     return this._frame.page();
   }
   async boundingBox(options) {
-    return await this._withElement((h) => h.boundingBox(), options?.timeout);
+    return await this._withElement((h) => h.boundingBox(), { title: "Bounding box", timeout: options?.timeout });
   }
   async check(options = {}) {
     return await this._frame.check(this._selector, { strict: true, ...options });
@@ -88,7 +87,7 @@ class Locator {
     return await this._frame.click(this._selector, { strict: true, ...options });
   }
   async dblclick(options = {}) {
-    return await this._frame.dblclick(this._selector, { strict: true, ...options });
+    await this._frame.dblclick(this._selector, { strict: true, ...options });
   }
   async dispatchEvent(type, eventInit = {}, options) {
     return await this._frame.dispatchEvent(this._selector, type, eventInit, { strict: true, ...options });
@@ -101,19 +100,22 @@ class Locator {
   }
   async evaluate(pageFunction, arg, options, isolatedContext = true) {
     return await this._withElement(
-      async (h) => (0, import_jsHandle2.parseResult)(
+      async (h) => parseResult(
         (await h._channel.evaluateExpression({
           expression: String(pageFunction),
           isFunction: typeof pageFunction === "function",
-          arg: (0, import_jsHandle2.serializeArgument)(arg),
+          arg: serializeArgument(arg),
           isolatedContext
         })).value
       ),
       options?.timeout
     );
   }
-  async evaluateAll(pageFunction, arg) {
-    return await this._frame.$$eval(this._selector, pageFunction, arg);
+  async _evaluateFunction(functionDeclaration, options) {
+    return await this._withElement((h) => h._evaluateFunction(functionDeclaration), { title: "Evaluate", timeout: options?.timeout });
+  }
+  async evaluateAll(pageFunction, arg, isolatedContext = true) {
+    return await this._frame.$$eval(this._selector, pageFunction, arg, isolatedContext);
   }
   async evaluateHandle(pageFunction, arg, options, isolatedContext = true) {
     return await this._withElement(
@@ -121,7 +123,7 @@ class Locator {
         (await h._channel.evaluateExpressionHandle({
           expression: String(pageFunction),
           isFunction: typeof pageFunction === "function",
-          arg: (0, import_jsHandle2.serializeArgument)(arg),
+          arg: serializeArgument(arg),
           isolatedContext
         })).handle
       ),
@@ -132,7 +134,7 @@ class Locator {
     return await this._frame.fill(this._selector, value, { strict: true, ...options });
   }
   async clear(options = {}) {
-    return await this.fill("", options);
+    await this._frame._wrapApiCall(() => this.fill("", options), { title: "Clear" });
   }
   async _highlight() {
     return await this._frame._highlight(this._selector);
@@ -183,6 +185,9 @@ class Locator {
   contentFrame() {
     return new FrameLocator(this._frame, this._selector);
   }
+  describe(description) {
+    return new Locator(this._frame, this._selector + " >> internal:describe=" + JSON.stringify(description));
+  }
   first() {
     return new Locator(this._frame, this._selector + " >> nth=0");
   }
@@ -206,13 +211,14 @@ class Locator {
     return await this._frame.focus(this._selector, { strict: true, ...options });
   }
   async blur(options) {
-    await this._frame._channel.blur({ selector: this._selector, strict: true, ...options });
+    await this._frame._channel.blur({ selector: this._selector, strict: true, ...options, timeout: this._frame._timeout(options) });
   }
-  async count() {
-    return await this._frame._queryCount(this._selector);
+  // options are only here for testing
+  async count(_options) {
+    return await this._frame._queryCount(this._selector, _options);
   }
-  async _generateLocatorString() {
-    return await this._withElement((h) => h._generateLocatorString());
+  async _resolveSelector() {
+    return await this._frame._channel.resolveSelector({ selector: this._selector });
   }
   async getAttribute(name, options) {
     return await this._frame.getAttribute(this._selector, name, { strict: true, ...options });
@@ -252,20 +258,20 @@ class Locator {
   }
   async screenshot(options = {}) {
     const mask = options.mask;
-    return await this._withElement((h, timeout) => h.screenshot({ ...options, mask, timeout }), options.timeout);
+    return await this._withElement((h, timeout) => h.screenshot({ ...options, mask, timeout }), { title: "Screenshot", timeout: options.timeout });
   }
   async ariaSnapshot(options) {
-    const result = await this._frame._channel.ariaSnapshot({ ...options, mode: options?._mode, selector: this._selector });
+    const result = await this._frame._channel.ariaSnapshot({ ...options, selector: this._selector, timeout: this._frame._timeout(options) });
     return result.snapshot;
   }
   async scrollIntoViewIfNeeded(options = {}) {
-    return await this._withElement((h, timeout) => h.scrollIntoViewIfNeeded({ ...options, timeout }), options.timeout);
+    return await this._withElement((h, timeout) => h.scrollIntoViewIfNeeded({ ...options, timeout }), { title: "Scroll into view", timeout: options.timeout });
   }
   async selectOption(values, options = {}) {
     return await this._frame.selectOption(this._selector, values, { strict: true, ...options });
   }
   async selectText(options = {}) {
-    return await this._withElement((h, timeout) => h.selectText({ ...options, timeout }), options.timeout);
+    return await this._withElement((h, timeout) => h.selectText({ ...options, timeout }), { title: "Select text", timeout: options.timeout });
   }
   async setChecked(checked, options) {
     if (checked)
@@ -301,15 +307,13 @@ class Locator {
     return await this._frame.$$eval(this._selector, (ee) => ee.map((e) => e.textContent || ""));
   }
   async waitFor(options) {
-    await this._frame._channel.waitForSelector({ selector: this._selector, strict: true, omitReturnValue: true, ...options });
+    await this._frame._channel.waitForSelector({ selector: this._selector, strict: true, omitReturnValue: true, ...options, timeout: this._frame._timeout(options) });
   }
   async _expect(expression, options) {
-    const params = { selector: this._selector, expression, ...options, isNot: !!options.isNot };
-    params.expectedValue = (0, import_jsHandle2.serializeArgument)(options.expectedValue);
-    const result = await this._frame._channel.expect(params);
-    if (result.received !== void 0)
-      result.received = (0, import_jsHandle2.parseResult)(result.received);
-    return result;
+    return this._frame._expect(expression, {
+      ...options,
+      selector: this._selector
+    });
   }
   _inspect() {
     return this.toString();