patchright-core 1.57.0 → 1.59.0

package/lib/server/dispatchers/browserContextDispatcher.js

@@ -36,6 +36,7 @@ var import_path = __toESM(require("path"));
 var import_browserContext = require("../browserContext");
 var import_artifactDispatcher = require("./artifactDispatcher");
 var import_cdpSessionDispatcher = require("./cdpSessionDispatcher");
+var import_debuggerDispatcher = require("./debuggerDispatcher");
 var import_dialogDispatcher = require("./dialogDispatcher");
 var import_dispatcher = require("./dispatcher");
 var import_frameDispatcher = require("./frameDispatcher");
@@ -43,6 +44,7 @@ var import_networkDispatchers = require("./networkDispatchers");
 var import_pageDispatcher = require("./pageDispatcher");
 var import_crBrowser = require("../chromium/crBrowser");
 var import_errors = require("../errors");
+var import_disposableDispatcher = require("./disposableDispatcher");
 var import_tracingDispatcher = require("./tracingDispatcher");
 var import_webSocketRouteDispatcher = require("./webSocketRouteDispatcher");
 var import_writableStreamDispatcher = require("./writableStreamDispatcher");
@@ -52,12 +54,14 @@ var import_recorder = require("../recorder");
 var import_recorderApp = require("../recorder/recorderApp");
 var import_elementHandlerDispatcher = require("./elementHandlerDispatcher");
 var import_jsHandleDispatcher = require("./jsHandleDispatcher");
+var import_disposable = require("../disposable");
 class BrowserContextDispatcher extends import_dispatcher.Dispatcher {
   constructor(parentScope, context) {
+    const debugger_ = import_debuggerDispatcher.DebuggerDispatcher.from(parentScope, context.debugger());
     const requestContext = import_networkDispatchers.APIRequestContextDispatcher.from(parentScope, context.fetchRequest);
     const tracing = import_tracingDispatcher.TracingDispatcher.from(parentScope, context.tracing);
     super(parentScope, context, "BrowserContext", {
-      isChromium: context._browser.options.isChromium,
+      debugger: debugger_,
       requestContext,
       tracing,
       options: context._options
@@ -66,10 +70,10 @@ class BrowserContextDispatcher extends import_dispatcher.Dispatcher {
     this._type_BrowserContext = true;
     this._subscriptions = /* @__PURE__ */ new Set();
     this._webSocketInterceptionPatterns = [];
-    this._bindings = [];
-    this._initScripts = [];
+    this._disposables = [];
     this._clockPaused = false;
     this._interceptionUrlMatchers = [];
+    this.adopt(debugger_);
     this.adopt(requestContext);
     this.adopt(tracing);
     this._requestInterceptor = (route, request) => {
@@ -83,15 +87,6 @@ class BrowserContextDispatcher extends import_dispatcher.Dispatcher {
       this._dispatchEvent("route", { route: new import_networkDispatchers.RouteDispatcher(import_networkDispatchers.RequestDispatcher.from(this, request), route) });
     };
     this._context = context;
-    const onVideo = (artifact) => {
-      const artifactDispatcher = import_artifactDispatcher.ArtifactDispatcher.from(parentScope, artifact);
-      this._dispatchEvent("video", { artifact: artifactDispatcher });
-    };
-    this.addObjectListener(import_browserContext.BrowserContext.Events.VideoStarted, onVideo);
-    for (const video of context._browser._idToVideo.values()) {
-      if (video.context === context)
-        onVideo(video.artifact);
-    }
     for (const page of context.pages())
       this._dispatchEvent("page", { page: import_pageDispatcher.PageDispatcher.from(this, page) });
     this.addObjectListener(import_browserContext.BrowserContext.Events.Page, (page) => {
@@ -197,7 +192,8 @@ class BrowserContextDispatcher extends import_dispatcher.Dispatcher {
           return import_elementHandlerDispatcher.ElementHandleDispatcher.from(import_frameDispatcher.FrameDispatcher.from(this, elementHandle._frame), elementHandle);
         return import_jsHandleDispatcher.JSHandleDispatcher.fromJSHandle(jsScope, a);
       }),
-      location: message.location()
+      location: message.location(),
+      timestamp: message.timestamp()
     };
   }
   async createTempFiles(params, progress) {
@@ -224,7 +220,8 @@ class BrowserContextDispatcher extends import_dispatcher.Dispatcher {
       this._dispatchEvent("bindingCall", { binding: binding2 });
       return binding2.promise();
     });
-    this._bindings.push(binding);
+    this._disposables.push(binding);
+    return { disposable: new import_disposableDispatcher.DisposableDispatcher(this, binding) };
   }
   async newPage(params, progress) {
     return { page: import_pageDispatcher.PageDispatcher.from(this, await this._context.newPage(progress)) };
@@ -264,7 +261,9 @@ class BrowserContextDispatcher extends import_dispatcher.Dispatcher {
     await progress.race(this._context.setHTTPCredentials(params.httpCredentials));
   }
   async addInitScript(params, progress) {
-    this._initScripts.push(await this._context.addInitScript(progress, params.source));
+    const initScript = await this._context.addInitScript(params.source);
+    this._disposables.push(initScript);
+    return { disposable: new import_disposableDispatcher.DisposableDispatcher(this, initScript) };
   }
   async setNetworkInterceptionPatterns(params, progress) {
     const hadMatchers = this._interceptionUrlMatchers.length > 0;
@@ -273,7 +272,7 @@ class BrowserContextDispatcher extends import_dispatcher.Dispatcher {
         await this._context.removeRequestInterceptor(this._requestInterceptor);
       this._interceptionUrlMatchers = [];
     } else {
-      this._interceptionUrlMatchers = params.patterns.map((pattern) => pattern.regexSource ? new RegExp(pattern.regexSource, pattern.regexFlags) : pattern.glob);
+      this._interceptionUrlMatchers = params.patterns.map(import_urlMatch.deserializeURLMatch);
       if (!hadMatchers)
         await this._context.addRequestInterceptor(progress, this._requestInterceptor);
     }
@@ -286,6 +285,9 @@ class BrowserContextDispatcher extends import_dispatcher.Dispatcher {
   async storageState(params, progress) {
     return await progress.race(this._context.storageState(progress, params.indexedDB));
   }
+  async setStorageState(params, progress) {
+    await this._context.setStorageState(progress, params.storageState, "api");
+  }
   async close(params, progress) {
     progress.metadata.potentiallyClosesScope = true;
     await this._context.close(params);
@@ -295,13 +297,15 @@ class BrowserContextDispatcher extends import_dispatcher.Dispatcher {
   }
   async disableRecorder(params, progress) {
     const recorder = await import_recorder.Recorder.existingForContext(this._context);
-    if (recorder)
-      recorder.setMode("none");
+    await recorder?.setMode("none");
+  }
+  async exposeConsoleApi(params, progress) {
+    await this._context.exposeConsoleApi();
   }
   async pause(params, progress) {
   }
   async newCDPSession(params, progress) {
-    if (!this._object._browser.options.isChromium)
+    if (this._object._browser.options.browserType !== "chromium")
       throw new Error(`CDP session is only available in Chromium`);
     if (!params.page && !params.frame || params.page && params.frame)
       throw new Error(`CDP session must be initiated with either Page or Frame, not none or both`);
@@ -319,13 +323,13 @@ class BrowserContextDispatcher extends import_dispatcher.Dispatcher {
     return { artifact: import_artifactDispatcher.ArtifactDispatcher.from(this, artifact) };
   }
   async clockFastForward(params, progress) {
-    await this._context.clock.fastForward(progress, params.ticksString ?? params.ticksNumber ?? 0);
+    await this._context.clock.fastForward(params.ticksString ?? params.ticksNumber ?? 0);
   }
   async clockInstall(params, progress) {
-    await this._context.clock.install(progress, params.timeString ?? params.timeNumber ?? void 0);
+    await this._context.clock.install(params.timeString ?? params.timeNumber ?? void 0);
   }
   async clockPauseAt(params, progress) {
-    await this._context.clock.pauseAt(progress, params.timeString ?? params.timeNumber ?? 0);
+    await this._context.clock.pauseAt(params.timeString ?? params.timeNumber ?? 0);
     this._clockPaused = true;
   }
   async clockResume(params, progress) {
@@ -333,13 +337,13 @@ class BrowserContextDispatcher extends import_dispatcher.Dispatcher {
     this._clockPaused = false;
   }
   async clockRunFor(params, progress) {
-    await this._context.clock.runFor(progress, params.ticksString ?? params.ticksNumber ?? 0);
+    await this._context.clock.runFor(params.ticksString ?? params.ticksNumber ?? 0);
   }
   async clockSetFixedTime(params, progress) {
-    await this._context.clock.setFixedTime(progress, params.timeString ?? params.timeNumber ?? 0);
+    await this._context.clock.setFixedTime(params.timeString ?? params.timeNumber ?? 0);
   }
   async clockSetSystemTime(params, progress) {
-    await this._context.clock.setSystemTime(progress, params.timeString ?? params.timeNumber ?? 0);
+    await this._context.clock.setSystemTime(params.timeString ?? params.timeNumber ?? 0);
   }
   async updateSubscription(params, progress) {
     if (params.enabled)
@@ -360,12 +364,8 @@ class BrowserContextDispatcher extends import_dispatcher.Dispatcher {
     this._interceptionUrlMatchers = [];
     this._context.removeRequestInterceptor(this._requestInterceptor).catch(() => {
     });
-    this._context.removeExposedBindings(this._bindings).catch(() => {
-    });
-    this._bindings = [];
-    this._context.removeInitScripts(this._initScripts).catch(() => {
+    (0, import_disposable.disposeAll)(this._disposables).catch(() => {
     });
-    this._initScripts = [];
     if (this._routeWebSocketInitScript)
       import_webSocketRouteDispatcher.WebSocketRouteDispatcher.uninstall(this.connection, this._context, this._routeWebSocketInitScript).catch(() => {
       });

package/lib/server/dispatchers/browserDispatcher.js

@@ -29,7 +29,7 @@ var import_browserContext = require("../browserContext");
 var import_artifactDispatcher = require("./artifactDispatcher");
 class BrowserDispatcher extends import_dispatcher.Dispatcher {
   constructor(scope, browser, options = {}) {
-    super(scope, browser, "Browser", { version: browser.version(), name: browser.options.name });
+    super(scope, browser, "Browser", { version: browser.version(), name: browser.options.name, browserName: browser.options.browserType });
     this._type_Browser = true;
     this._isolatedContexts = /* @__PURE__ */ new Set();
     this._options = options;
@@ -48,7 +48,7 @@ class BrowserDispatcher extends import_dispatcher.Dispatcher {
   }
   async newContext(params, progress) {
     if (params.recordVideo && this._object.attribution.playwright.options.isServer)
-      params.recordVideo.dir = this._object.options.artifactsDir;
+      params.recordVideo.dir = void 0;
     if (!this._options.isolateContexts) {
       const context2 = await this._object.newContext(progress, params);
       const contextDispatcher2 = import_browserContextDispatcher.BrowserContextDispatcher.from(this, context2);
@@ -91,23 +91,29 @@ class BrowserDispatcher extends import_dispatcher.Dispatcher {
     return { userAgent: this._object.userAgent() };
   }
   async newBrowserCDPSession(params, progress) {
-    if (!this._object.options.isChromium)
+    if (this._object.options.browserType !== "chromium")
       throw new Error(`CDP session is only available in Chromium`);
     const crBrowser = this._object;
     return { session: new import_cdpSessionDispatcher.CDPSessionDispatcher(this, await crBrowser.newBrowserCDPSession()) };
   }
   async startTracing(params, progress) {
-    if (!this._object.options.isChromium)
+    if (this._object.options.browserType !== "chromium")
       throw new Error(`Tracing is only available in Chromium`);
     const crBrowser = this._object;
     await crBrowser.startTracing(params.page ? params.page._object : void 0, params);
   }
   async stopTracing(params, progress) {
-    if (!this._object.options.isChromium)
+    if (this._object.options.browserType !== "chromium")
       throw new Error(`Tracing is only available in Chromium`);
     const crBrowser = this._object;
     return { artifact: import_artifactDispatcher.ArtifactDispatcher.from(this, await crBrowser.stopTracing()) };
   }
+  async startServer(params, progress) {
+    return await this._object.startServer(params.title, params);
+  }
+  async stopServer(params, progress) {
+    await this._object.stopServer();
+  }
   async cleanupContexts() {
     await Promise.all(Array.from(this._isolatedContexts).map((context) => context.close({ reason: "Global context cleanup (connection terminated)" })));
   }

package/lib/server/dispatchers/browserTypeDispatcher.js

@@ -57,6 +57,13 @@ class BrowserTypeDispatcher extends import_dispatcher.Dispatcher {
       defaultContext: browser._defaultContext ? import_browserContextDispatcher.BrowserContextDispatcher.from(browserDispatcher, browser._defaultContext) : void 0
     };
   }
+  async connectOverCDPTransport(params, progress) {
+    if (this._denyLaunch)
+      throw new Error(`Launching more browsers is not allowed.`);
+    const browser = await this._object.connectOverCDPTransport(progress, params.transport);
+    const browserDispatcher = new import_browserDispatcher.BrowserDispatcher(this, browser);
+    return { browser: browserDispatcher, defaultContext: browser._defaultContext ? import_browserContextDispatcher.BrowserContextDispatcher.from(browserDispatcher, browser._defaultContext) : void 0 };
+  }
 }
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {

package/lib/server/dispatchers/cdpSessionDispatcher.js

@@ -28,7 +28,10 @@ class CDPSessionDispatcher extends import_dispatcher.Dispatcher {
     super(scope, cdpSession, "CDPSession", {});
     this._type_CDPSession = true;
     this.addObjectListener(import_crConnection.CDPSession.Events.Event, ({ method, params }) => this._dispatchEvent("event", { method, params }));
-    this.addObjectListener(import_crConnection.CDPSession.Events.Closed, () => this._dispose());
+    this.addObjectListener(import_crConnection.CDPSession.Events.Closed, () => {
+      this._dispatchEvent("close");
+      this._dispose();
+    });
   }
   async send(params, progress) {
     return { result: await progress.race(this._object.send(params.method, params.params)) };

package/lib/server/dispatchers/debuggerDispatcher.js

@@ -0,0 +1,84 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var debuggerDispatcher_exports = {};
+__export(debuggerDispatcher_exports, {
+  DebuggerDispatcher: () => DebuggerDispatcher
+});
+module.exports = __toCommonJS(debuggerDispatcher_exports);
+var import_dispatcher = require("./dispatcher");
+var import_debugger = require("../debugger");
+var import_protocolFormatter = require("../../utils/isomorphic/protocolFormatter");
+class DebuggerDispatcher extends import_dispatcher.Dispatcher {
+  constructor(scope, debugger_) {
+    super(scope, debugger_, "Debugger", {});
+    this._type_EventTarget = true;
+    this._type_Debugger = true;
+    this.addObjectListener(import_debugger.Debugger.Events.PausedStateChanged, () => {
+      this._dispatchEvent("pausedStateChanged", { pausedDetails: this._serializePausedDetails() });
+    });
+    this._dispatchEvent("pausedStateChanged", { pausedDetails: this._serializePausedDetails() });
+  }
+  static from(scope, debugger_) {
+    const result = scope.connection.existingDispatcher(debugger_);
+    return result || new DebuggerDispatcher(scope, debugger_);
+  }
+  _serializePausedDetails() {
+    const details = this._object.pausedDetails();
+    if (!details)
+      return void 0;
+    const { metadata } = details;
+    return {
+      location: {
+        file: metadata.location?.file ?? "<unknown>",
+        line: metadata.location?.line,
+        column: metadata.location?.column
+      },
+      title: (0, import_protocolFormatter.renderTitleForCall)(metadata)
+    };
+  }
+  async requestPause(params, progress) {
+    if (this._object.isPaused())
+      throw new Error("Debugger is already paused");
+    this._object.setPauseBeforeWaitingActions();
+    this._object.setPauseAt({ next: true });
+  }
+  async resume(params, progress) {
+    if (!this._object.isPaused())
+      throw new Error("Debugger is not paused");
+    this._object.resume();
+  }
+  async next(params, progress) {
+    if (!this._object.isPaused())
+      throw new Error("Debugger is not paused");
+    this._object.setPauseBeforeWaitingActions();
+    this._object.setPauseAt({ next: true });
+    this._object.resume();
+  }
+  async runTo(params, progress) {
+    if (!this._object.isPaused())
+      throw new Error("Debugger is not paused");
+    this._object.setPauseBeforeWaitingActions();
+    this._object.setPauseAt({ location: params.location });
+    this._object.resume();
+  }
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  DebuggerDispatcher
+});

package/lib/server/dispatchers/dispatcher.js

@@ -85,11 +85,7 @@ class Dispatcher extends import_events.EventEmitter {
     this.connection.sendAdopt(this, child);
   }
   async _runCommand(callMetadata, method, validParams) {
-    const controller = new import_progress.ProgressController(callMetadata, (message) => {
-      const logName = this._object.logName || "api";
-      import_utils.debugLogger.log(logName, message);
-      this._object.instrumentation.onCallLog(this._object, callMetadata, logName, message);
-    });
+    const controller = import_progress.ProgressController.createForSdkObject(this._object, callMetadata);
     this._activeProgressControllers.add(controller);
     try {
       return await controller.run((progress) => this[method](validParams, progress), validParams?.timeout);
@@ -106,7 +102,7 @@ class Dispatcher extends import_events.EventEmitter {
     this.connection.sendEvent(this, method, params);
   }
   _dispose(reason) {
-    this._disposeRecursively(new import_errors.TargetClosedError());
+    this._disposeRecursively(new import_errors.TargetClosedError(this._object.closeReason()));
     this.connection.sendDispose(this, reason);
   }
   _onDispose() {
@@ -257,7 +253,7 @@ class DispatcherConnection {
     const { id, guid, method, params, metadata } = message;
     const dispatcher = this._dispatcherByGuid.get(guid);
     if (!dispatcher) {
-      this.onmessage({ id, error: (0, import_errors.serializeError)(new import_errors.TargetClosedError()) });
+      this.onmessage({ id, error: (0, import_errors.serializeError)(new import_errors.TargetClosedError(void 0)) });
       return;
     }
     let validParams;
@@ -273,7 +269,7 @@ class DispatcherConnection {
       this.onmessage({ id, error: (0, import_errors.serializeError)(e) });
       return;
     }
-    const metainfo = import_protocolMetainfo.methodMetainfo.get(dispatcher._type + "." + method);
+    const metainfo = (0, import_protocolMetainfo.getMetainfo)({ type: dispatcher._type, method });
     if (metainfo?.internal) {
       validMetadata.internal = true;
     }
@@ -325,19 +321,19 @@ class DispatcherConnection {
     const response = { id };
     try {
       if (this._dispatcherByGuid.get(guid) !== dispatcher)
-        throw new import_errors.TargetClosedError(closeReason(sdkObject));
+        throw new import_errors.TargetClosedError(sdkObject.closeReason());
       const result = await dispatcher._runCommand(callMetadata, method, validParams);
       const validator = (0, import_validator.findValidator)(dispatcher._type, method, "Result");
       response.result = validator(result, "", this._validatorToWireContext());
       callMetadata.result = result;
     } catch (e) {
       if ((0, import_errors.isTargetClosedError)(e)) {
-        const reason = closeReason(sdkObject);
+        const reason = sdkObject.closeReason();
         if (reason)
           (0, import_utils.rewriteErrorMessage)(e, reason);
       } else if ((0, import_protocolError.isProtocolError)(e)) {
         if (e.type === "closed")
-          e = new import_errors.TargetClosedError(closeReason(sdkObject), e.browserLogMessage());
+          e = new import_errors.TargetClosedError(sdkObject.closeReason(), e.browserLogMessage());
         else if (e.type === "crashed")
           (0, import_utils.rewriteErrorMessage)(e, "Target crashed " + e.browserLogMessage());
       }
@@ -359,9 +355,6 @@ class DispatcherConnection {
       await new Promise((f) => setTimeout(f, slowMo));
   }
 }
-function closeReason(sdkObject) {
-  return sdkObject.attribution.page?.closeReason || sdkObject.attribution.context?._closeReason || sdkObject.attribution.browser?._closeReason;
-}
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
   Dispatcher,

package/lib/server/dispatchers/disposableDispatcher.js

@@ -0,0 +1,39 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var disposableDispatcher_exports = {};
+__export(disposableDispatcher_exports, {
+  DisposableDispatcher: () => DisposableDispatcher
+});
+module.exports = __toCommonJS(disposableDispatcher_exports);
+var import_dispatcher = require("./dispatcher");
+class DisposableDispatcher extends import_dispatcher.Dispatcher {
+  constructor(scope, disposable) {
+    super(scope, disposable, "Disposable", {});
+    this._type_Disposable = true;
+  }
+  async dispose(_, progress) {
+    progress.metadata.potentiallyClosesScope = true;
+    await this._object.dispose();
+    this._dispose();
+  }
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  DisposableDispatcher
+});

package/lib/server/dispatchers/electronDispatcher.js

@@ -58,7 +58,8 @@ class ElectronApplicationDispatcher extends import_dispatcher.Dispatcher {
         type: message.type(),
         text: message.text(),
         args: message.args().map((a) => import_jsHandleDispatcher.JSHandleDispatcher.fromJSHandle(this, a)),
-        location: message.location()
+        location: message.location(),
+        timestamp: message.timestamp()
       });
     });
   }

package/lib/server/dispatchers/frameDispatcher.js

@@ -73,10 +73,10 @@ class FrameDispatcher extends import_dispatcher.Dispatcher {
     return { element: import_elementHandlerDispatcher.ElementHandleDispatcher.from(this, await progress.race(this._frame.frameElement())) };
   }
   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)))) };
+    return { value: (0, import_jsHandleDispatcher.serializeResult)(await progress.race(this._frame.evaluateExpression(params.expression, { isFunction: params.isFunction }, (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)))) };
+    return { handle: import_elementHandlerDispatcher.ElementHandleDispatcher.fromJSOrElementHandle(this, await progress.race(this._frame.evaluateExpressionHandle(params.expression, { isFunction: params.isFunction }, (0, import_jsHandleDispatcher.parseArgument)(params.arg)))) };
   }
   async waitForSelector(params, progress) {
     return { element: import_elementHandlerDispatcher.ElementHandleDispatcher.fromNullable(this, await this._frame.waitForSelector(progress, params.selector, true, params)) };
@@ -88,7 +88,7 @@ class FrameDispatcher extends import_dispatcher.Dispatcher {
     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, 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)) };
+    return { value: (0, import_jsHandleDispatcher.serializeResult)(await progress.race(this._frame.evalOnSelectorAll(params.selector, params.expression, params.isFunction, (0, import_jsHandleDispatcher.parseArgument)(params.arg)))) };
   }
   async querySelector(params, progress) {
     return { element: import_elementHandlerDispatcher.ElementHandleDispatcher.fromNullable(this, await progress.race(this._frame.querySelector(params.selector, params))) };
@@ -112,6 +112,9 @@ class FrameDispatcher extends import_dispatcher.Dispatcher {
   async addStyleTag(params, progress) {
     return { element: import_elementHandlerDispatcher.ElementHandleDispatcher.from(this, await progress.race(this._frame.addStyleTag(params))) };
   }
+  async ariaSnapshot(params, progress) {
+    return await this._frame.ariaSnapshot(progress, params);
+  }
   async click(params, progress) {
     progress.metadata.potentiallyClosesScope = true;
     return await this._frame.click(progress, params.selector, params);
@@ -212,14 +215,11 @@ class FrameDispatcher extends import_dispatcher.Dispatcher {
     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(progress, params.selector, { ...params, expectedValue }, params.timeout);
+    const result = await this._frame.expect(progress, params.selector, { ...params, expectedValue, timeoutForLogs: params.timeout });
     if (result.received !== void 0)
       result.received = (0, import_jsHandleDispatcher.serializeResult)(result.received);
     return result;
   }
-  async ariaSnapshot(params, progress) {
-    return { snapshot: await this._frame.ariaSnapshot(progress, params.selector) };
-  }
 }
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {

package/lib/server/dispatchers/localUtilsDispatcher.js

@@ -31,12 +31,14 @@ __export(localUtilsDispatcher_exports, {
   LocalUtilsDispatcher: () => LocalUtilsDispatcher
 });
 module.exports = __toCommonJS(localUtilsDispatcher_exports);
+var import_net = __toESM(require("net"));
 var import_dispatcher = require("./dispatcher");
 var import_instrumentation = require("../../server/instrumentation");
 var localUtils = __toESM(require("../localUtils"));
 var import_userAgent = require("../utils/userAgent");
 var import_deviceDescriptors = require("../deviceDescriptors");
 var import_jsonPipeDispatcher = require("../dispatchers/jsonPipeDispatcher");
+var import_pipeTransport = require("../pipeTransport");
 var import_socksInterceptor = require("../socksInterceptor");
 var import_transport = require("../transport");
 var import_network = require("../utils/network");
@@ -78,12 +80,17 @@ class LocalUtilsDispatcher extends import_dispatcher.Dispatcher {
     localUtils.addStackToTracingNoReply(this._stackSessions, params);
   }
   async connect(params, progress) {
+    if (URL.canParse(params.endpoint))
+      return await this._connectOverWebSocket(params, progress);
+    return await this._connectOverPipe(params, progress);
+  }
+  async _connectOverWebSocket(params, progress) {
     const wsHeaders = {
       "User-Agent": (0, import_userAgent.getUserAgent)(),
       "x-playwright-proxy": params.exposeNetwork ?? "",
       ...params.headers
     };
-    const wsEndpoint = await urlToWSEndpoint(progress, params.wsEndpoint);
+    const wsEndpoint = await urlToWSEndpoint(progress, params.endpoint);
     const transport = await import_transport.WebSocketTransport.connect(progress, wsEndpoint, { headers: wsHeaders, followRedirects: true, debugLogHeader: "x-playwright-debug-log" });
     const socksInterceptor = new import_socksInterceptor.SocksInterceptor(transport, params.exposeNetwork, params.socksProxyRedirectPortForTest);
     const pipe = new import_jsonPipeDispatcher.JsonPipeDispatcher(this);
@@ -112,6 +119,35 @@ class LocalUtilsDispatcher extends import_dispatcher.Dispatcher {
     pipe.on("close", () => transport.close());
     return { pipe, headers: transport.headers };
   }
+  async _connectOverPipe(params, progress) {
+    const socket = await new Promise((resolve, reject) => {
+      const conn = import_net.default.connect(params.endpoint, () => resolve(conn));
+      conn.on("error", reject);
+    });
+    const transport = new import_pipeTransport.PipeTransport(socket, socket);
+    const pipe = new import_jsonPipeDispatcher.JsonPipeDispatcher(this);
+    transport.onmessage = (json) => {
+      const cb = () => {
+        try {
+          pipe.dispatch(json);
+        } catch (e) {
+          transport.close();
+        }
+      };
+      if (params.slowMo)
+        setTimeout(cb, params.slowMo);
+      else
+        cb();
+    };
+    pipe.on("message", (message) => {
+      transport.send(message);
+    });
+    transport.onclose = (reason) => {
+      pipe.wasClosed(reason);
+    };
+    pipe.on("close", () => socket.end());
+    return { pipe, headers: [] };
+  }
   async globToRegex(params, progress) {
     const regex = (0, import_urlMatch.resolveGlobToRegexPattern)(params.baseURL, params.glob, params.webSocketUrl);
     return { regex };

package/lib/server/dispatchers/networkDispatchers.js

@@ -30,7 +30,6 @@ var import_dispatcher = require("./dispatcher");
 var import_frameDispatcher = require("./frameDispatcher");
 var import_pageDispatcher = require("./pageDispatcher");
 var import_tracingDispatcher = require("./tracingDispatcher");
-var import_network2 = require("../network");
 class RequestDispatcher extends import_dispatcher.Dispatcher {
   static from(scope, request) {
     const result = scope.connection.existingDispatcher(request);
@@ -54,12 +53,11 @@ class RequestDispatcher extends import_dispatcher.Dispatcher {
       postData: postData === null ? void 0 : postData,
       headers: request.headers(),
       isNavigationRequest: request.isNavigationRequest(),
-      redirectedFrom: RequestDispatcher.fromNullable(scope, request.redirectedFrom()),
-      hasResponse: !!request._existingResponse()
+      redirectedFrom: RequestDispatcher.fromNullable(scope, request.redirectedFrom())
     });
     this._type_Request = true;
     this._browserContextDispatcher = scope;
-    this.addObjectListener(import_network2.Request.Events.Response, () => this._dispatchEvent("response", {}));
+    ResponseDispatcher.fromNullable(scope, request._existingResponse());
   }
   async rawRequestHeaders(params, progress) {
     return { headers: await progress.race(this._object.rawRequestHeaders()) };
@@ -83,8 +81,8 @@ class ResponseDispatcher extends import_dispatcher.Dispatcher {
     this._type_Response = true;
   }
   static from(scope, response) {
-    const result = scope.connection.existingDispatcher(response);
     const requestDispatcher = RequestDispatcher.from(scope, response.request());
+    const result = scope.connection.existingDispatcher(response);
     return result || new ResponseDispatcher(requestDispatcher, response);
   }
   static fromNullable(scope, response) {
@@ -102,6 +100,9 @@ class ResponseDispatcher extends import_dispatcher.Dispatcher {
   async rawResponseHeaders(params, progress) {
     return { headers: await progress.race(this._object.rawResponseHeaders()) };
   }
+  async httpVersion(params, progress) {
+    return { value: await progress.race(this._object.httpVersion()) };
+  }
   async sizes(params, progress) {
     return { sizes: await progress.race(this._object.sizes()) };
   }