patchright-core 1.52.5 → 1.55.1

package/lib/server/dispatchers/elementHandlerDispatcher.js

@@ -22,10 +22,8 @@ __export(elementHandlerDispatcher_exports, {
 });
 module.exports = __toCommonJS(elementHandlerDispatcher_exports);
 var import_browserContextDispatcher = require("./browserContextDispatcher");
-var import_dispatcher = require("./dispatcher");
 var import_frameDispatcher = require("./frameDispatcher");
 var import_jsHandleDispatcher = require("./jsHandleDispatcher");
-var import_pageDispatcher = require("./pageDispatcher");
 class ElementHandleDispatcher extends import_jsHandleDispatcher.JSHandleDispatcher {
   constructor(scope, elementHandle) {
     super(scope, elementHandle);
@@ -33,156 +31,148 @@ class ElementHandleDispatcher extends import_jsHandleDispatcher.JSHandleDispatch
     this._elementHandle = elementHandle;
   }
   static from(scope, handle) {
-    return (0, import_dispatcher.existingDispatcher)(handle) || new ElementHandleDispatcher(scope, handle);
+    return scope.connection.existingDispatcher(handle) || new ElementHandleDispatcher(scope, handle);
   }
   static fromNullable(scope, handle) {
     if (!handle)
       return void 0;
-    return (0, import_dispatcher.existingDispatcher)(handle) || new ElementHandleDispatcher(scope, handle);
+    return scope.connection.existingDispatcher(handle) || new ElementHandleDispatcher(scope, handle);
   }
-  static fromJSHandle(scope, handle) {
-    const result = (0, import_dispatcher.existingDispatcher)(handle);
+  static fromJSOrElementHandle(scope, handle) {
+    const result = scope.connection.existingDispatcher(handle);
     if (result)
       return result;
-    return handle.asElement() ? new ElementHandleDispatcher(scope, handle.asElement()) : new import_jsHandleDispatcher.JSHandleDispatcher(scope, handle);
+    const elementHandle = handle.asElement();
+    if (!elementHandle)
+      return new import_jsHandleDispatcher.JSHandleDispatcher(scope, handle);
+    return new ElementHandleDispatcher(scope, elementHandle);
   }
-  async ownerFrame(params, metadata) {
+  async ownerFrame(params, progress) {
     const frame = await this._elementHandle.ownerFrame();
     return { frame: frame ? import_frameDispatcher.FrameDispatcher.from(this._browserContextDispatcher(), frame) : void 0 };
   }
-  async contentFrame(params, metadata) {
-    const frame = await this._elementHandle.contentFrame();
+  async contentFrame(params, progress) {
+    const frame = await progress.race(this._elementHandle.contentFrame());
     return { frame: frame ? import_frameDispatcher.FrameDispatcher.from(this._browserContextDispatcher(), frame) : void 0 };
   }
-  async generateLocatorString(params, metadata) {
-    return { value: await this._elementHandle.generateLocatorString() };
-  }
-  async getAttribute(params, metadata) {
-    const value = await this._elementHandle.getAttribute(metadata, params.name);
+  async getAttribute(params, progress) {
+    const value = await this._elementHandle.getAttribute(progress, params.name);
     return { value: value === null ? void 0 : value };
   }
-  async inputValue(params, metadata) {
-    const value = await this._elementHandle.inputValue(metadata);
+  async inputValue(params, progress) {
+    const value = await this._elementHandle.inputValue(progress);
     return { value };
   }
-  async textContent(params, metadata) {
-    const value = await this._elementHandle.textContent(metadata);
+  async textContent(params, progress) {
+    const value = await this._elementHandle.textContent(progress);
     return { value: value === null ? void 0 : value };
   }
-  async innerText(params, metadata) {
-    return { value: await this._elementHandle.innerText(metadata) };
+  async innerText(params, progress) {
+    return { value: await this._elementHandle.innerText(progress) };
   }
-  async innerHTML(params, metadata) {
-    return { value: await this._elementHandle.innerHTML(metadata) };
+  async innerHTML(params, progress) {
+    return { value: await this._elementHandle.innerHTML(progress) };
   }
-  async isChecked(params, metadata) {
-    return { value: await this._elementHandle.isChecked(metadata) };
+  async isChecked(params, progress) {
+    return { value: await this._elementHandle.isChecked(progress) };
   }
-  async isDisabled(params, metadata) {
-    return { value: await this._elementHandle.isDisabled(metadata) };
+  async isDisabled(params, progress) {
+    return { value: await this._elementHandle.isDisabled(progress) };
   }
-  async isEditable(params, metadata) {
-    return { value: await this._elementHandle.isEditable(metadata) };
+  async isEditable(params, progress) {
+    return { value: await this._elementHandle.isEditable(progress) };
   }
-  async isEnabled(params, metadata) {
-    return { value: await this._elementHandle.isEnabled(metadata) };
+  async isEnabled(params, progress) {
+    return { value: await this._elementHandle.isEnabled(progress) };
   }
-  async isHidden(params, metadata) {
-    return { value: await this._elementHandle.isHidden(metadata) };
+  async isHidden(params, progress) {
+    return { value: await this._elementHandle.isHidden(progress) };
   }
-  async isVisible(params, metadata) {
-    return { value: await this._elementHandle.isVisible(metadata) };
+  async isVisible(params, progress) {
+    return { value: await this._elementHandle.isVisible(progress) };
   }
-  async dispatchEvent(params, metadata) {
-    await this._elementHandle.dispatchEvent(metadata, params.type, (0, import_jsHandleDispatcher.parseArgument)(params.eventInit));
+  async dispatchEvent(params, progress) {
+    await this._elementHandle.dispatchEvent(progress, params.type, (0, import_jsHandleDispatcher.parseArgument)(params.eventInit));
   }
-  async scrollIntoViewIfNeeded(params, metadata) {
-    await this._elementHandle.scrollIntoViewIfNeeded(metadata, params);
+  async scrollIntoViewIfNeeded(params, progress) {
+    await this._elementHandle.scrollIntoViewIfNeeded(progress);
   }
-  async hover(params, metadata) {
-    return await this._elementHandle.hover(metadata, params);
+  async hover(params, progress) {
+    return await this._elementHandle.hover(progress, params);
   }
-  async click(params, metadata) {
-    return await this._elementHandle.click(metadata, params);
+  async click(params, progress) {
+    return await this._elementHandle.click(progress, params);
   }
-  async dblclick(params, metadata) {
-    return await this._elementHandle.dblclick(metadata, params);
+  async dblclick(params, progress) {
+    return await this._elementHandle.dblclick(progress, params);
   }
-  async tap(params, metadata) {
-    return await this._elementHandle.tap(metadata, params);
+  async tap(params, progress) {
+    return await this._elementHandle.tap(progress, params);
   }
-  async selectOption(params, metadata) {
+  async selectOption(params, progress) {
     const elements = (params.elements || []).map((e) => e._elementHandle);
-    return { values: await this._elementHandle.selectOption(metadata, elements, params.options || [], params) };
+    return { values: await this._elementHandle.selectOption(progress, elements, params.options || [], params) };
   }
-  async fill(params, metadata) {
-    return await this._elementHandle.fill(metadata, params.value, params);
+  async fill(params, progress) {
+    return await this._elementHandle.fill(progress, params.value, params);
   }
-  async selectText(params, metadata) {
-    await this._elementHandle.selectText(metadata, params);
+  async selectText(params, progress) {
+    await this._elementHandle.selectText(progress, params);
   }
-  async setInputFiles(params, metadata) {
-    return await this._elementHandle.setInputFiles(metadata, params);
+  async setInputFiles(params, progress) {
+    return await this._elementHandle.setInputFiles(progress, params);
   }
-  async focus(params, metadata) {
-    await this._elementHandle.focus(metadata);
+  async focus(params, progress) {
+    await this._elementHandle.focus(progress);
   }
-  async type(params, metadata) {
-    return await this._elementHandle.type(metadata, params.text, params);
+  async type(params, progress) {
+    return await this._elementHandle.type(progress, params.text, params);
   }
-  async press(params, metadata) {
-    return await this._elementHandle.press(metadata, params.key, params);
+  async press(params, progress) {
+    return await this._elementHandle.press(progress, params.key, params);
   }
-  async check(params, metadata) {
-    return await this._elementHandle.check(metadata, params);
+  async check(params, progress) {
+    return await this._elementHandle.check(progress, params);
   }
-  async uncheck(params, metadata) {
-    return await this._elementHandle.uncheck(metadata, params);
+  async uncheck(params, progress) {
+    return await this._elementHandle.uncheck(progress, params);
   }
-  async boundingBox(params, metadata) {
-    const value = await this._elementHandle.boundingBox();
+  async boundingBox(params, progress) {
+    const value = await progress.race(this._elementHandle.boundingBox());
     return { value: value || void 0 };
   }
-  async screenshot(params, metadata) {
+  async screenshot(params, progress) {
     const mask = (params.mask || []).map(({ frame, selector }) => ({
       frame: frame._object,
       selector
     }));
-    return { binary: await this._elementHandle.screenshot(metadata, { ...params, mask }) };
+    return { binary: await this._elementHandle.screenshot(progress, { ...params, mask }) };
   }
-  async querySelector(params, metadata) {
-    const handle = await this._elementHandle.querySelector(params.selector, params);
+  async querySelector(params, progress) {
+    const handle = await progress.race(this._elementHandle.querySelector(params.selector, params));
     return { element: ElementHandleDispatcher.fromNullable(this.parentScope(), handle) };
   }
-  async querySelectorAll(params, metadata) {
-    const elements = await this._elementHandle.querySelectorAll(params.selector);
+  async querySelectorAll(params, progress) {
+    const elements = await progress.race(this._elementHandle.querySelectorAll(params.selector));
     return { elements: elements.map((e) => ElementHandleDispatcher.from(this.parentScope(), e)) };
   }
-  async evalOnSelector(params, metadata) {
-    return { value: (0, import_jsHandleDispatcher.serializeResult)(await this._elementHandle.evalOnSelector(params.selector, !!params.strict, params.expression, params.isFunction, (0, import_jsHandleDispatcher.parseArgument)(params.arg))) };
+  async evalOnSelector(params, progress) {
+    return { value: (0, import_jsHandleDispatcher.serializeResult)(await progress.race(this._elementHandle.evalOnSelector(params.selector, !!params.strict, params.expression, params.isFunction, (0, import_jsHandleDispatcher.parseArgument)(params.arg)))) };
   }
-  async evalOnSelectorAll(params, metadata) {
-    return { value: (0, import_jsHandleDispatcher.serializeResult)(await this._elementHandle.evalOnSelectorAll(params.selector, params.expression, params.isFunction, (0, import_jsHandleDispatcher.parseArgument)(params.arg))) };
+  async evalOnSelectorAll(params, progress) {
+    return { value: (0, import_jsHandleDispatcher.serializeResult)(await progress.race(this._elementHandle.evalOnSelectorAll(params.selector, params.expression, params.isFunction, (0, import_jsHandleDispatcher.parseArgument)(params.arg)))) };
   }
-  async waitForElementState(params, metadata) {
-    await this._elementHandle.waitForElementState(metadata, params.state, params);
+  async waitForElementState(params, progress) {
+    await this._elementHandle.waitForElementState(progress, params.state);
   }
-  async waitForSelector(params, metadata) {
-    return { element: ElementHandleDispatcher.fromNullable(this.parentScope(), await this._elementHandle.waitForSelector(metadata, params.selector, params)) };
+  async waitForSelector(params, progress) {
+    return { element: ElementHandleDispatcher.fromNullable(this.parentScope(), await this._elementHandle.waitForSelector(progress, params.selector, params)) };
   }
   _browserContextDispatcher() {
-    const scope = this.parentScope();
-    if (scope instanceof import_browserContextDispatcher.BrowserContextDispatcher)
-      return scope;
-    if (scope instanceof import_pageDispatcher.PageDispatcher)
-      return scope.parentScope();
-    if (scope instanceof import_pageDispatcher.WorkerDispatcher || scope instanceof import_frameDispatcher.FrameDispatcher) {
-      const parentScope = scope.parentScope();
-      if (parentScope instanceof import_browserContextDispatcher.BrowserContextDispatcher)
-        return parentScope;
-      return parentScope.parentScope();
-    }
-    throw new Error("ElementHandle belongs to unexpected scope");
+    const parentScope = this.parentScope().parentScope();
+    if (parentScope instanceof import_browserContextDispatcher.BrowserContextDispatcher)
+      return parentScope;
+    return parentScope.parentScope();
   }
 }
 // Annotate the CommonJS export names for ESM import in node:

package/lib/server/dispatchers/frameDispatcher.js

@@ -32,7 +32,7 @@ var import_utilsBundle = require("../../utilsBundle");
 class FrameDispatcher extends import_dispatcher.Dispatcher {
   constructor(scope, frame) {
     const gcBucket = frame._page.mainFrame() === frame ? "MainFrame" : "Frame";
-    const pageDispatcher = (0, import_dispatcher.existingDispatcher)(frame._page);
+    const pageDispatcher = scope.connection.existingDispatcher(frame._page);
     super(pageDispatcher || scope, frame, "Frame", {
       url: frame.url(),
       name: frame.name(),
@@ -58,7 +58,7 @@ class FrameDispatcher extends import_dispatcher.Dispatcher {
     });
   }
   static from(scope, frame) {
-    const result = (0, import_dispatcher.existingDispatcher)(frame);
+    const result = scope.connection.existingDispatcher(frame);
     return result || new FrameDispatcher(scope, frame);
   }
   static fromNullable(scope, frame) {
@@ -66,162 +66,159 @@ class FrameDispatcher extends import_dispatcher.Dispatcher {
       return;
     return FrameDispatcher.from(scope, frame);
   }
-  async goto(params, metadata) {
-    return { response: import_networkDispatchers.ResponseDispatcher.fromNullable(this._browserContextDispatcher, await this._frame.goto(metadata, params.url, params)) };
+  async goto(params, progress) {
+    return { response: import_networkDispatchers.ResponseDispatcher.fromNullable(this._browserContextDispatcher, await this._frame.goto(progress, params.url, params)) };
   }
-  async frameElement() {
-    return { element: import_elementHandlerDispatcher.ElementHandleDispatcher.from(this, await this._frame.frameElement()) };
+  async frameElement(params, progress) {
+    return { element: import_elementHandlerDispatcher.ElementHandleDispatcher.from(this, await progress.race(this._frame.frameElement())) };
   }
-  async evaluateExpression(params, metadata) {
-    return { value: (0, import_jsHandleDispatcher.serializeResult)(await this._frame.evaluateExpression(params.expression, {
-      isFunction: params.isFunction,
-      world: params.isolatedContext ? "utility" : "main"
-    }, (0, import_jsHandleDispatcher.parseArgument)(params.arg))) };
+  async evaluateExpression(params, progress) {
+    return { value: (0, import_jsHandleDispatcher.serializeResult)(await progress.race(this._frame.evaluateExpression(params.expression, { isFunction: params.isFunction, world: params.isolatedContext ? "utility" : "main" }, (0, import_jsHandleDispatcher.parseArgument)(params.arg)))) };
   }
-  async evaluateExpressionHandle(params, metadata) {
-    return { handle: import_elementHandlerDispatcher.ElementHandleDispatcher.fromJSHandle(this, await this._frame.evaluateExpressionHandle(params.expression, {
-      isFunction: params.isFunction,
-      world: params.isolatedContext ? "utility" : "main"
-    }, (0, import_jsHandleDispatcher.parseArgument)(params.arg))) };
+  async evaluateExpressionHandle(params, progress) {
+    return { handle: import_elementHandlerDispatcher.ElementHandleDispatcher.fromJSOrElementHandle(this, await progress.race(this._frame.evaluateExpressionHandle(params.expression, { isFunction: params.isFunction, world: params.isolatedContext ? "utility" : "main" }, (0, import_jsHandleDispatcher.parseArgument)(params.arg)))) };
   }
-  async waitForSelector(params, metadata) {
-    return { element: import_elementHandlerDispatcher.ElementHandleDispatcher.fromNullable(this, await this._frame.waitForSelector(metadata, params.selector, params)) };
+  async waitForSelector(params, progress) {
+    return { element: import_elementHandlerDispatcher.ElementHandleDispatcher.fromNullable(this, await this._frame.waitForSelector(progress, params.selector, true, params)) };
   }
-  async dispatchEvent(params, metadata) {
-    return this._frame.dispatchEvent(metadata, params.selector, params.type, (0, import_jsHandleDispatcher.parseArgument)(params.eventInit), params);
+  async dispatchEvent(params, progress) {
+    return this._frame.dispatchEvent(progress, params.selector, params.type, (0, import_jsHandleDispatcher.parseArgument)(params.eventInit), params);
   }
-  async evalOnSelector(params, metadata) {
-    return { value: (0, import_jsHandleDispatcher.serializeResult)(await this._frame.evalOnSelector(params.selector, !!params.strict, params.expression, params.isFunction, (0, import_jsHandleDispatcher.parseArgument)(params.arg))) };
+  async evalOnSelector(params, progress) {
+    return { value: (0, import_jsHandleDispatcher.serializeResult)(await progress.race(this._frame.evalOnSelector(params.selector, !!params.strict, params.expression, params.isFunction, (0, import_jsHandleDispatcher.parseArgument)(params.arg)))) };
   }
-  async evalOnSelectorAll(params, metadata) {
+  async evalOnSelectorAll(params, progress) {
     return { value: (0, import_jsHandleDispatcher.serializeResult)(await this._frame.evalOnSelectorAll(params.selector, params.expression, params.isFunction, (0, import_jsHandleDispatcher.parseArgument)(params.arg), null, params.isolatedContext)) };
   }
-  async querySelector(params, metadata) {
-    return { element: import_elementHandlerDispatcher.ElementHandleDispatcher.fromNullable(this, await this._frame.querySelector(params.selector, params)) };
+  async querySelector(params, progress) {
+    return { element: import_elementHandlerDispatcher.ElementHandleDispatcher.fromNullable(this, await progress.race(this._frame.querySelector(params.selector, params))) };
   }
-  async querySelectorAll(params, metadata) {
-    const elements = await this._frame.querySelectorAll(params.selector);
+  async querySelectorAll(params, progress) {
+    const elements = await progress.race(this._frame.querySelectorAll(params.selector));
     return { elements: elements.map((e) => import_elementHandlerDispatcher.ElementHandleDispatcher.from(this, e)) };
   }
-  async queryCount(params) {
-    return { value: await this._frame.queryCount(params.selector) };
+  async queryCount(params, progress) {
+    return { value: await progress.race(this._frame.queryCount(params.selector, params)) };
   }
-  async content() {
-    return { value: await this._frame.content() };
+  async content(params, progress) {
+    return { value: await progress.race(this._frame.content()) };
   }
-  async setContent(params, metadata) {
-    return await this._frame.setContent(metadata, params.html, params);
+  async setContent(params, progress) {
+    return await this._frame.setContent(progress, params.html, params);
   }
-  async addScriptTag(params, metadata) {
-    return { element: import_elementHandlerDispatcher.ElementHandleDispatcher.from(this, await this._frame.addScriptTag(params)) };
+  async addScriptTag(params, progress) {
+    return { element: import_elementHandlerDispatcher.ElementHandleDispatcher.from(this, await progress.race(this._frame.addScriptTag(params))) };
   }
-  async addStyleTag(params, metadata) {
-    return { element: import_elementHandlerDispatcher.ElementHandleDispatcher.from(this, await this._frame.addStyleTag(params)) };
+  async addStyleTag(params, progress) {
+    return { element: import_elementHandlerDispatcher.ElementHandleDispatcher.from(this, await progress.race(this._frame.addStyleTag(params))) };
   }
-  async click(params, metadata) {
-    metadata.potentiallyClosesScope = true;
-    return await this._frame.click(metadata, params.selector, params);
+  async click(params, progress) {
+    progress.metadata.potentiallyClosesScope = true;
+    return await this._frame.click(progress, params.selector, params);
   }
-  async dblclick(params, metadata) {
-    return await this._frame.dblclick(metadata, params.selector, params);
+  async dblclick(params, progress) {
+    return await this._frame.dblclick(progress, params.selector, params);
   }
-  async dragAndDrop(params, metadata) {
-    return await this._frame.dragAndDrop(metadata, params.source, params.target, params);
+  async dragAndDrop(params, progress) {
+    return await this._frame.dragAndDrop(progress, params.source, params.target, params);
   }
-  async tap(params, metadata) {
-    return await this._frame.tap(metadata, params.selector, params);
+  async tap(params, progress) {
+    return await this._frame.tap(progress, params.selector, params);
   }
-  async fill(params, metadata) {
-    return await this._frame.fill(metadata, params.selector, params.value, params);
+  async fill(params, progress) {
+    return await this._frame.fill(progress, params.selector, params.value, params);
   }
-  async focus(params, metadata) {
-    await this._frame.focus(metadata, params.selector, params);
+  async focus(params, progress) {
+    await this._frame.focus(progress, params.selector, params);
   }
-  async blur(params, metadata) {
-    await this._frame.blur(metadata, params.selector, params);
+  async blur(params, progress) {
+    await this._frame.blur(progress, params.selector, params);
   }
-  async textContent(params, metadata) {
-    const value = await this._frame.textContent(metadata, params.selector, params);
+  async textContent(params, progress) {
+    const value = await this._frame.textContent(progress, params.selector, params);
     return { value: value === null ? void 0 : value };
   }
-  async innerText(params, metadata) {
-    return { value: await this._frame.innerText(metadata, params.selector, params) };
+  async innerText(params, progress) {
+    return { value: await this._frame.innerText(progress, params.selector, params) };
   }
-  async innerHTML(params, metadata) {
-    return { value: await this._frame.innerHTML(metadata, params.selector, params) };
+  async innerHTML(params, progress) {
+    return { value: await this._frame.innerHTML(progress, params.selector, params) };
   }
-  async getAttribute(params, metadata) {
-    const value = await this._frame.getAttribute(metadata, params.selector, params.name, params);
+  async resolveSelector(params, progress) {
+    return await this._frame.resolveSelector(progress, params.selector);
+  }
+  async getAttribute(params, progress) {
+    const value = await this._frame.getAttribute(progress, params.selector, params.name, params);
     return { value: value === null ? void 0 : value };
   }
-  async inputValue(params, metadata) {
-    const value = await this._frame.inputValue(metadata, params.selector, params);
+  async inputValue(params, progress) {
+    const value = await this._frame.inputValue(progress, params.selector, params);
     return { value };
   }
-  async isChecked(params, metadata) {
-    return { value: await this._frame.isChecked(metadata, params.selector, params) };
+  async isChecked(params, progress) {
+    return { value: await this._frame.isChecked(progress, params.selector, params) };
   }
-  async isDisabled(params, metadata) {
-    return { value: await this._frame.isDisabled(metadata, params.selector, params) };
+  async isDisabled(params, progress) {
+    return { value: await this._frame.isDisabled(progress, params.selector, params) };
   }
-  async isEditable(params, metadata) {
-    return { value: await this._frame.isEditable(metadata, params.selector, params) };
+  async isEditable(params, progress) {
+    return { value: await this._frame.isEditable(progress, params.selector, params) };
   }
-  async isEnabled(params, metadata) {
-    return { value: await this._frame.isEnabled(metadata, params.selector, params) };
+  async isEnabled(params, progress) {
+    return { value: await this._frame.isEnabled(progress, params.selector, params) };
   }
-  async isHidden(params, metadata) {
-    return { value: await this._frame.isHidden(metadata, params.selector, params) };
+  async isHidden(params, progress) {
+    return { value: await this._frame.isHidden(progress, params.selector, params) };
   }
-  async isVisible(params, metadata) {
-    return { value: await this._frame.isVisible(metadata, params.selector, params) };
+  async isVisible(params, progress) {
+    return { value: await this._frame.isVisible(progress, params.selector, params) };
   }
-  async hover(params, metadata) {
-    return await this._frame.hover(metadata, params.selector, params);
+  async hover(params, progress) {
+    return await this._frame.hover(progress, params.selector, params);
   }
-  async selectOption(params, metadata) {
+  async selectOption(params, progress) {
     const elements = (params.elements || []).map((e) => e._elementHandle);
-    return { values: await this._frame.selectOption(metadata, params.selector, elements, params.options || [], params) };
+    return { values: await this._frame.selectOption(progress, params.selector, elements, params.options || [], params) };
   }
-  async setInputFiles(params, metadata) {
-    return await this._frame.setInputFiles(metadata, params.selector, params);
+  async setInputFiles(params, progress) {
+    return await this._frame.setInputFiles(progress, params.selector, params);
   }
-  async type(params, metadata) {
-    return await this._frame.type(metadata, params.selector, params.text, params);
+  async type(params, progress) {
+    return await this._frame.type(progress, params.selector, params.text, params);
   }
-  async press(params, metadata) {
-    return await this._frame.press(metadata, params.selector, params.key, params);
+  async press(params, progress) {
+    return await this._frame.press(progress, params.selector, params.key, params);
   }
-  async check(params, metadata) {
-    return await this._frame.check(metadata, params.selector, params);
+  async check(params, progress) {
+    return await this._frame.check(progress, params.selector, params);
   }
-  async uncheck(params, metadata) {
-    return await this._frame.uncheck(metadata, params.selector, params);
+  async uncheck(params, progress) {
+    return await this._frame.uncheck(progress, params.selector, params);
   }
-  async waitForTimeout(params, metadata) {
-    return await this._frame.waitForTimeout(metadata, params.timeout);
+  async waitForTimeout(params, progress) {
+    return await this._frame.waitForTimeout(progress, params.waitTimeout);
   }
-  async waitForFunction(params, metadata) {
-    return { handle: import_elementHandlerDispatcher.ElementHandleDispatcher.fromJSHandle(this, await this._frame._waitForFunctionExpression(metadata, params.expression, params.isFunction, (0, import_jsHandleDispatcher.parseArgument)(params.arg), params)) };
+  async waitForFunction(params, progress) {
+    return { handle: import_elementHandlerDispatcher.ElementHandleDispatcher.fromJSOrElementHandle(this, await this._frame.waitForFunctionExpression(progress, params.expression, params.isFunction, (0, import_jsHandleDispatcher.parseArgument)(params.arg), params)) };
   }
-  async title(params, metadata) {
-    return { value: await this._frame.title() };
+  async title(params, progress) {
+    return { value: await progress.race(this._frame.title()) };
   }
-  async highlight(params, metadata) {
-    return await this._frame.highlight(params.selector);
+  async highlight(params, progress) {
+    return await this._frame.highlight(progress, params.selector);
   }
-  async expect(params, metadata) {
-    metadata.potentiallyClosesScope = true;
+  async expect(params, progress) {
+    progress.metadata.potentiallyClosesScope = true;
     let expectedValue = params.expectedValue ? (0, import_jsHandleDispatcher.parseArgument)(params.expectedValue) : void 0;
     if (params.expression === "to.match.aria" && expectedValue)
       expectedValue = (0, import_ariaSnapshot.parseAriaSnapshotUnsafe)(import_utilsBundle.yaml, expectedValue);
-    const result = await this._frame.expect(metadata, params.selector, { ...params, expectedValue });
+    const result = await this._frame.expect(progress, params.selector, { ...params, expectedValue }, params.timeout);
     if (result.received !== void 0)
       result.received = (0, import_jsHandleDispatcher.serializeResult)(result.received);
     return result;
   }
-  async ariaSnapshot(params, metadata) {
-    return { snapshot: await this._frame.ariaSnapshot(metadata, params.selector, params) };
+  async ariaSnapshot(params, progress) {
+    return { snapshot: await this._frame.ariaSnapshot(progress, params.selector) };
   }
 }
 // Annotate the CommonJS export names for ESM import in node:

package/lib/server/dispatchers/jsHandleDispatcher.js

@@ -35,29 +35,34 @@ class JSHandleDispatcher extends import_dispatcher.Dispatcher {
     this._type_JSHandle = true;
     jsHandle._setPreviewCallback((preview) => this._dispatchEvent("previewUpdated", { preview }));
   }
-  async evaluateExpression(params) {
-    return { value: serializeResult(await this._object.evaluateExpression(params.expression, { isFunction: params.isFunction }, parseArgument(params.arg), params.isolatedContext)) };
+  static fromJSHandle(scope, handle) {
+    return scope.connection.existingDispatcher(handle) || new JSHandleDispatcher(scope, handle);
   }
-  async evaluateExpressionHandle(params) {
-    const jsHandle = await this._object.evaluateExpressionHandle(params.expression, { isFunction: params.isFunction }, parseArgument(params.arg), params.isolatedContext);
-    return { handle: import_elementHandlerDispatcher.ElementHandleDispatcher.fromJSHandle(this.parentScope(), jsHandle) };
+  async evaluateExpression(params, progress) {
+    const jsHandle = await progress.race(this._object.evaluateExpression(params.expression, { isFunction: params.isFunction }, parseArgument(params.arg)));
+    return { value: serializeResult(jsHandle) };
   }
-  async getProperty(params) {
-    const jsHandle = await this._object.getProperty(params.name);
-    return { handle: import_elementHandlerDispatcher.ElementHandleDispatcher.fromJSHandle(this.parentScope(), jsHandle) };
+  async evaluateExpressionHandle(params, progress) {
+    const jsHandle = await progress.race(this._object.evaluateExpressionHandle(params.expression, { isFunction: params.isFunction }, parseArgument(params.arg)));
+    return { handle: import_elementHandlerDispatcher.ElementHandleDispatcher.fromJSOrElementHandle(this.parentScope(), jsHandle) };
   }
-  async getPropertyList() {
-    const map = await this._object.getProperties();
+  async getProperty(params, progress) {
+    const jsHandle = await progress.race(this._object.getProperty(params.name));
+    return { handle: import_elementHandlerDispatcher.ElementHandleDispatcher.fromJSOrElementHandle(this.parentScope(), jsHandle) };
+  }
+  async getPropertyList(params, progress) {
+    const map = await progress.race(this._object.getProperties());
     const properties = [];
-    for (const [name, value] of map)
-      properties.push({ name, value: import_elementHandlerDispatcher.ElementHandleDispatcher.fromJSHandle(this.parentScope(), value) });
+    for (const [name, value] of map) {
+      properties.push({ name, value: import_elementHandlerDispatcher.ElementHandleDispatcher.fromJSOrElementHandle(this.parentScope(), value) });
+    }
     return { properties };
   }
-  async jsonValue() {
-    return { value: serializeResult(await this._object.jsonValue()) };
+  async jsonValue(params, progress) {
+    return { value: serializeResult(await progress.race(this._object.jsonValue())) };
   }
-  async dispose(_, metadata) {
-    metadata.potentiallyClosesScope = true;
+  async dispose(_, progress) {
+    progress.metadata.potentiallyClosesScope = true;
     this._object.dispose();
     this._dispose();
   }

package/lib/server/dispatchers/jsonPipeDispatcher.js

@@ -22,16 +22,16 @@ __export(jsonPipeDispatcher_exports, {
 });
 module.exports = __toCommonJS(jsonPipeDispatcher_exports);
 var import_dispatcher = require("./dispatcher");
-var import_crypto = require("../utils/crypto");
+var import_instrumentation = require("../instrumentation");
 class JsonPipeDispatcher extends import_dispatcher.Dispatcher {
   constructor(scope) {
-    super(scope, { guid: "jsonPipe@" + (0, import_crypto.createGuid)() }, "JsonPipe", {});
+    super(scope, new import_instrumentation.SdkObject(scope._object, "jsonPipe"), "JsonPipe", {});
     this._type_JsonPipe = true;
   }
-  async send(params) {
+  async send(params, progress) {
     this.emit("message", params.message);
   }
-  async close() {
+  async close(params, progress) {
     this.emit("close");
     if (!this._disposed) {
       this._dispatchEvent("closed", {});