patchright-core 1.57.0 → 1.59.0

package/lib/server/webkit/webkit.js

@@ -51,12 +51,10 @@ class WebKit extends import_browserType.BrowserType {
       CURL_COOKIE_JAR_PATH: process.platform === "win32" && isPersistent ? import_path.default.join(userDataDir, "cookiejar.db") : void 0
     };
   }
-  doRewriteStartupLog(error) {
-    if (!error.logs)
-      return error;
-    if (error.logs.includes("Failed to open display") || error.logs.includes("cannot open display"))
-      error.logs = "\n" + (0, import_ascii.wrapInASCIIBox)(import_browserType.kNoXServerRunningError, 1);
-    return error;
+  doRewriteStartupLog(logs) {
+    if (logs.includes("Failed to open display") || logs.includes("cannot open display"))
+      logs = "\n" + (0, import_ascii.wrapInASCIIBox)(import_browserType.kNoXServerRunningError, 1);
+    return logs;
   }
   attemptToGracefullyCloseBrowser(transport) {
     transport.send({ method: "Playwright.close", params: {}, id: import_wkConnection.kBrowserCloseMessageId });

package/lib/server/webkit/wkBrowser.js

@@ -38,9 +38,8 @@ var import_browserContext = require("../browserContext");
 var network = __toESM(require("../network"));
 var import_wkConnection = require("./wkConnection");
 var import_wkPage = require("./wkPage");
-var import_errors = require("../errors");
 var import_webkit = require("./webkit");
-const BROWSER_VERSION = "26.0";
+const BROWSER_VERSION = "26.4";
 const DEFAULT_USER_AGENT = `Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/605.1.15 (KHTML, like Gecko) Version/${BROWSER_VERSION} Safari/605.1.15`;
 class WKBrowser extends import_browser.Browser {
   constructor(parent, transport, options) {
@@ -56,7 +55,6 @@ class WKBrowser extends import_browser.Browser {
     this._browserSession.on("Playwright.downloadCreated", this._onDownloadCreated.bind(this));
     this._browserSession.on("Playwright.downloadFilenameSuggested", this._onDownloadFilenameSuggested.bind(this));
     this._browserSession.on("Playwright.downloadFinished", this._onDownloadFinished.bind(this));
-    this._browserSession.on("Playwright.screencastFinished", this._onScreencastFinished.bind(this));
     this._browserSession.on(import_wkConnection.kPageProxyMessageReceived, this._onPageProxyMessageReceived.bind(this));
   }
   static async connect(parent, transport, options) {
@@ -78,9 +76,6 @@ class WKBrowser extends import_browser.Browser {
     for (const wkPage of this._wkPages.values())
       wkPage.didClose();
     this._wkPages.clear();
-    for (const video of this._idToVideo.values())
-      video.artifact.reportFinished(new import_errors.TargetClosedError());
-    this._idToVideo.clear();
     this._didClose();
   }
   async doCreateNewContext(options) {
@@ -131,9 +126,6 @@ class WKBrowser extends import_browser.Browser {
   _onDownloadFinished(payload) {
     this._downloadFinished(payload.uuid, payload.error);
   }
-  _onScreencastFinished(payload) {
-    this._takeVideo(payload.screencastId)?.reportFinished();
-  }
   _onPageProxyCreated(event) {
     const pageProxyId = event.pageProxyId;
     let context = null;
@@ -315,7 +307,6 @@ class WKBrowserContext extends import_browserContext.BrowserContext {
   }
   async doClose(reason) {
     if (!this._browserContextId) {
-      await Promise.all(this._wkPages().map((wkPage) => wkPage._stopVideo()));
       await this._browser.close({ reason });
     } else {
       await this._browser._browserSession.send("Playwright.deleteContext", { browserContextId: this._browserContextId });

package/lib/server/webkit/wkConnection.js

@@ -89,11 +89,6 @@ class WKSession extends import_events.EventEmitter {
     this.connection = connection;
     this.sessionId = sessionId;
     this._rawSend = rawSend;
-    this.on = super.on;
-    this.off = super.removeListener;
-    this.addListener = super.addListener;
-    this.removeListener = super.removeListener;
-    this.once = super.once;
   }
   async send(method, params) {
     if (this._crashed || this._disposed || this.connection._browserDisconnectedLogs)
@@ -134,7 +129,7 @@ class WKSession extends import_events.EventEmitter {
         callback.resolve(object.result);
       }
     } else if (object.id && !object.error) {
-      (0, import_utils.assert)(this.isDisposed());
+      (0, import_utils.assert)(this.isDisposed(), JSON.stringify(object));
     } else {
       Promise.resolve().then(() => this.emit(object.method, object.params));
     }

package/lib/server/webkit/wkInterceptableRequest.js

@@ -54,7 +54,7 @@ class WKInterceptableRequest {
   constructor(session, frame, event, redirectedFrom, documentId) {
     this._session = session;
     this._requestId = event.requestId;
-    const resourceType = event.type ? event.type.toLowerCase() : redirectedFrom ? redirectedFrom.request.resourceType() : "other";
+    const resourceType = event.type ? toResourceType(event.type) : redirectedFrom ? redirectedFrom.request.resourceType() : "other";
     let postDataBuffer = null;
     this._timestamp = event.timestamp;
     this._wallTime = event.walltime * 1e3;
@@ -162,6 +162,34 @@ function wkMillisToRoundishMillis(value) {
   }
   return (value * 1e3 | 0) / 1e3;
 }
+function toResourceType(type) {
+  switch (type) {
+    case "Document":
+      return "document";
+    case "StyleSheet":
+      return "stylesheet";
+    case "Image":
+      return "image";
+    case "Font":
+      return "font";
+    case "Script":
+      return "script";
+    case "XHR":
+      return "xhr";
+    case "Fetch":
+      return "fetch";
+    case "Ping":
+      return "ping";
+    case "Beacon":
+      return "beacon";
+    case "WebSocket":
+      return "websocket";
+    case "EventSource":
+      return "eventsource";
+    default:
+      return "other";
+  }
+}
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
   WKInterceptableRequest,

package/lib/server/webkit/wkPage.js

@@ -31,14 +31,13 @@ __export(wkPage_exports, {
   WKPage: () => WKPage
 });
 module.exports = __toCommonJS(wkPage_exports);
-var import_path = __toESM(require("path"));
 var import_utils = require("../../utils");
 var import_headers = require("../../utils/isomorphic/headers");
-var import_crypto = require("../utils/crypto");
 var import_eventsHelper = require("../utils/eventsHelper");
 var import_hostPlatform = require("../utils/hostPlatform");
 var import_stackTrace = require("../../utils/isomorphic/stackTrace");
 var import_utilsBundle = require("../../utilsBundle");
+var import_browserContext = require("../browserContext");
 var dialog = __toESM(require("../dialog"));
 var dom = __toESM(require("../dom"));
 var import_errors = require("../errors");
@@ -51,12 +50,15 @@ var import_wkInput = require("./wkInput");
 var import_wkInterceptableRequest = require("./wkInterceptableRequest");
 var import_wkProvisionalPage = require("./wkProvisionalPage");
 var import_wkWorkers = require("./wkWorkers");
-var import_debugLogger = require("../utils/debugLogger");
 var import_webkit = require("./webkit");
+var import_registry = require("../registry");
+var import_videoRecorder = require("../videoRecorder");
 const UTILITY_WORLD_NAME = "__playwright_utility_world__";
+const enableFrameSessions = !process.env.WK_DISABLE_FRAME_SESSIONS && parseInt(import_registry.registry.findExecutable("webkit").revision, 10) >= 2245 && parseInt(import_registry.registry.findExecutable("webkit").revision, 10) <= 2255;
 class WKPage {
   constructor(browserContext, pageProxySession, opener) {
     this._provisionalPage = null;
+    this._targetIdToFrameSession = /* @__PURE__ */ new Map();
     this._requestIdToRequest = /* @__PURE__ */ new Map();
     this._requestIdToRequestWillBeSentEvent = /* @__PURE__ */ new Map();
     this._sessionListeners = [];
@@ -66,7 +68,6 @@ class WKPage {
     };
     this._lastConsoleMessage = null;
     this._requestIdToResponseReceivedPayloadEvent = /* @__PURE__ */ new Map();
-    this._recordingVideoFile = null;
     this._screencastGeneration = 0;
     this._pageProxySession = pageProxySession;
     this._opener = opener;
@@ -116,16 +117,7 @@ class WKPage {
       for (const [key, value] of this._browserContext._permissions)
         promises.push(this._grantPermissions(key, value));
     }
-    if (this._browserContext._options.recordVideo) {
-      const outputFile = import_path.default.join(this._browserContext._options.recordVideo.dir, (0, import_crypto.createGuid)() + ".webm");
-      promises.push(this._browserContext._ensureVideosPath().then(() => {
-        return this._startVideo({
-          // validateBrowserContextOptions ensures correct video size.
-          ...this._browserContext._options.recordVideo.size,
-          outputFile
-        });
-      }));
-    }
+    (0, import_videoRecorder.startAutomaticVideoRecording)(this._page);
     await Promise.all(promises);
   }
   _setSession(session) {
@@ -159,10 +151,13 @@ class WKPage {
       session.send("Page.createUserWorld", { name: UTILITY_WORLD_NAME }).catch((_) => {
       }),
       // Worlds are per-process
-      session.send("Console.enable"),
       session.send("Network.enable"),
       this._workers.initializeSession(session)
     ];
+    if (enableFrameSessions)
+      this._initializeFrameSessions(frameTree.frameTree, promises);
+    else
+      promises.push(session.send("Console.enable"));
     if (this._page.browserContext.needsPlaywrightBinding())
       promises.push(session.send("Runtime.addBinding", { name: import_page.PageBinding.kBindingName }));
     if (this._page.needsRequestInterception()) {
@@ -219,6 +214,13 @@ class WKPage {
     promises.push(session.send("Page.overrideSetting", { setting: "FixedBackgroundsPaintRelativeToDocument", value: contextOptions.isMobile }));
     await Promise.all(promises);
   }
+  _initializeFrameSessions(frame, promises) {
+    const session = this._targetIdToFrameSession.get(`frame-${frame.frame.id}`);
+    if (session)
+      promises.push(session.initialize());
+    for (const childFrame of frame.childFrames || [])
+      this._initializeFrameSessions(childFrame, promises);
+  }
   _onDidCommitProvisionalTarget(event) {
     const { oldTargetId, newTargetId } = event;
     (0, import_utils.assert)(this._provisionalPage);
@@ -244,6 +246,9 @@ class WKPage {
         this._session.markAsCrashed();
         this._page._didCrash();
       }
+    } else if (this._targetIdToFrameSession.has(targetId)) {
+      this._targetIdToFrameSession.get(targetId).dispose();
+      this._targetIdToFrameSession.delete(targetId);
     }
   }
   didClose() {
@@ -257,7 +262,7 @@ class WKPage {
       this._provisionalPage.dispose();
       this._provisionalPage = null;
     }
-    this._firstNonInitialNavigationCommittedReject(new import_errors.TargetClosedError());
+    this._firstNonInitialNavigationCommittedReject(new import_errors.TargetClosedError(this._page.closeReason()));
     this._page._didClose();
   }
   dispatchMessageToSession(message) {
@@ -288,8 +293,15 @@ class WKPage {
         session.dispatchMessage({ id: message.id, error: { message: e.message } });
       });
     });
-    if (targetInfo.type === "frame")
+    if (targetInfo.type === "frame") {
+      if (enableFrameSessions) {
+        const wkFrame = new WKFrame(this, session);
+        this._targetIdToFrameSession.set(targetInfo.targetId, wkFrame);
+        await wkFrame.initialize().catch((e) => {
+        });
+      }
       return;
+    }
     (0, import_utils.assert)(targetInfo.type === "page", "Only page targets are expected in WebKit, received: " + targetInfo.type);
     if (!targetInfo.isProvisional) {
       (0, import_utils.assert)(!this._page.initializedOrUndefined());
@@ -331,6 +343,8 @@ class WKPage {
       this._provisionalPage._session.dispatchMessage(JSON.parse(message));
     else if (this._session.sessionId === targetId)
       this._session.dispatchMessage(JSON.parse(message));
+    else if (this._targetIdToFrameSession.has(targetId))
+      this._targetIdToFrameSession.get(targetId)._session.dispatchMessage(JSON.parse(message));
     else
       throw new Error("Unknown target: " + targetId);
   }
@@ -453,7 +467,7 @@ class WKPage {
   }
   async navigateFrame(frame, url, referrer) {
     if (this._pageProxySession.isDisposed())
-      throw new import_errors.TargetClosedError();
+      throw new import_errors.TargetClosedError(this._page.closeReason());
     const pageProxyId = this._pageProxySession.sessionId;
     const result = await this._pageProxySession.connection.browserSession.send("Playwright.navigate", { url, pageProxyId, frameId: frame._id, referrer });
     return { newDocumentId: result.loaderId };
@@ -506,7 +520,7 @@ class WKPage {
         columnNumber: (columnNumber || 1) - 1
       }
     };
-    this._onConsoleRepeatCountUpdated({ count: 1 });
+    this._onConsoleRepeatCountUpdated({ count: 1, timestamp: event.message.timestamp });
   }
   _onConsoleRepeatCountUpdated(event) {
     if (this._lastConsoleMessage) {
@@ -517,8 +531,9 @@ class WKPage {
         count,
         location
       } = this._lastConsoleMessage;
+      const timestamp = event.timestamp ? event.timestamp * 1e3 : Date.now();
       for (let i = count; i < event.count; ++i)
-        this._page.addConsoleMessage(null, derivedType, handles, location, handles.length ? void 0 : text);
+        this._page.addConsoleMessage(null, derivedType, handles, location, handles.length ? void 0 : text, timestamp);
       this._lastConsoleMessage.count = event.count;
     }
   }
@@ -633,9 +648,11 @@ class WKPage {
   async updateUserAgent() {
     const contextOptions = this._browserContext._options;
     this._updateState("Page.overrideUserAgent", { value: contextOptions.userAgent });
+    const { navigatorPlatform } = (0, import_browserContext.calculateUserAgentEmulation)(contextOptions);
+    this._updateState("Page.overridePlatform", navigatorPlatform ? { value: navigatorPlatform } : {});
   }
   async bringToFront() {
-    this._pageProxySession.send("Target.activate", {
+    await this._pageProxySession.send("Target.activate", {
       targetId: this._session.sessionId
     });
   }
@@ -748,7 +765,6 @@ class WKPage {
     await this._updateState("Page.setBootstrapScript", { source: this._calculateBootstrapScript() });
   }
   async closePage(runBeforeUnload) {
-    await this._stopVideo();
     await this._pageProxySession.sendMayFail("Target.close", {
       targetId: this._session.sessionId,
       runBeforeUnload
@@ -762,23 +778,6 @@ class WKPage {
       return import_hostPlatform.hostPlatform === "mac10.15" ? 55 : 59;
     return 0;
   }
-  async _startVideo(options) {
-    (0, import_utils.assert)(!this._recordingVideoFile);
-    const { screencastId } = await this._pageProxySession.send("Screencast.startVideo", {
-      file: this._browserContext._browser.options.channel === "webkit-wsl" ? await (0, import_webkit.translatePathToWSL)(options.outputFile) : options.outputFile,
-      width: options.width,
-      height: options.height,
-      toolbarHeight: this._toolbarHeight()
-    });
-    this._recordingVideoFile = options.outputFile;
-    this._browserContext._browser._videoStarted(this._browserContext, screencastId, options.outputFile, this._page.waitForInitializedOrError());
-  }
-  async _stopVideo() {
-    if (!this._recordingVideoFile)
-      return;
-    await this._pageProxySession.sendMayFail("Screencast.stopVideo");
-    this._recordingVideoFile = null;
-  }
   validateScreenshotDimension(side, omitDeviceScaleFactor) {
     if (process.platform === "darwin")
       return;
@@ -845,25 +844,28 @@ class WKPage {
       throw e;
     });
   }
-  async setScreencastOptions(options) {
-    if (options) {
-      const so = { ...options, toolbarHeight: this._toolbarHeight() };
-      const { generation } = await this._pageProxySession.send("Screencast.startScreencast", so);
-      this._screencastGeneration = generation;
-    } else {
-      await this._pageProxySession.send("Screencast.stopScreencast");
-    }
+  startScreencast(options) {
+    this._pageProxySession.send("Screencast.startScreencast", {
+      quality: options.quality,
+      width: options.width,
+      height: options.height,
+      toolbarHeight: this._toolbarHeight()
+    }).then(({ generation }) => this._screencastGeneration = generation).catch(() => {
+    });
+  }
+  stopScreencast() {
+    this._pageProxySession.sendMayFail("Screencast.stopScreencast");
   }
   _onScreencastFrame(event) {
     const generation = this._screencastGeneration;
-    this._page.throttleScreencastFrameAck(() => {
-      this._pageProxySession.send("Screencast.screencastFrameAck", { generation }).catch((e) => import_debugLogger.debugLogger.log("error", e));
-    });
     const buffer = Buffer.from(event.data, "base64");
-    this._page.emit(import_page.Page.Events.ScreencastFrame, {
+    this._page.screencast.onScreencastFrame({
       buffer,
-      width: event.deviceWidth,
-      height: event.deviceHeight
+      frameSwapWallTime: event.timestamp ? event.timestamp * 1e3 : Date.now(),
+      viewportWidth: event.deviceWidth,
+      viewportHeight: event.deviceHeight
+    }, () => {
+      this._pageProxySession.sendMayFail("Screencast.screencastFrameAck", { generation });
     });
   }
   rafCountForStablePosition() {
@@ -886,7 +888,7 @@ class WKPage {
     const pageProxyId = this._pageProxySession.sessionId;
     const objectId = handle._objectId;
     if (this._browserContext._browser?.options.channel === "webkit-wsl")
-      paths = await Promise.all(paths.map((path2) => (0, import_webkit.translatePathToWSL)(path2)));
+      paths = await Promise.all(paths.map((path) => (0, import_webkit.translatePathToWSL)(path)));
     await Promise.all([
       this._pageProxySession.connection.browserSession.send("Playwright.grantFileReadAccess", { pageProxyId, paths }),
       this._session.send("DOM.setInputFiles", { objectId, paths })
@@ -977,6 +979,7 @@ class WKPage {
   }
   _handleRequestRedirect(request, requestId, responsePayload, timestamp) {
     const response = request.createResponse(responsePayload);
+    response._setHttpVersion(null);
     response._securityDetailsFinished();
     response._serverAddrFinished();
     response.setResponseHeadersSize(null);
@@ -1029,8 +1032,7 @@ class WKPage {
         validFrom: responseReceivedPayload?.response.security?.certificate?.validFrom,
         validTo: responseReceivedPayload?.response.security?.certificate?.validUntil
       });
-      if (event.metrics?.protocol)
-        response._setHttpVersion(event.metrics.protocol);
+      response._setHttpVersion(event.metrics?.protocol ?? null);
       response.setEncodedBodySize(event.metrics?.responseBodyBytesReceived ?? null);
       response.setResponseHeadersSize(event.metrics?.responseHeaderBytesReceived ?? null);
       response._requestFinished(import_helper.helper.secondsToRoundishMillis(event.timestamp - request._timestamp));
@@ -1054,6 +1056,7 @@ class WKPage {
     if (response) {
       response._serverAddrFinished();
       response._securityDetailsFinished();
+      response._setHttpVersion(null);
       response.setResponseHeadersSize(null);
       response.setEncodedBodySize(null);
       response._requestFinished(import_helper.helper.secondsToRoundishMillis(event.timestamp - request._timestamp));
@@ -1068,7 +1071,8 @@ class WKPage {
     const webPermissionToProtocol = /* @__PURE__ */ new Map([
       ["geolocation", "geolocation"],
       ["notifications", "notifications"],
-      ["clipboard-read", "clipboard-read"]
+      ["clipboard-read", "clipboard-read"],
+      ["screen-wake-lock", "screen-wake-lock"]
     ]);
     const filtered = permissions.map((permission) => {
       const protocolPermission = webPermissionToProtocol.get(permission);
@@ -1084,6 +1088,33 @@ class WKPage {
   shouldToggleStyleSheetToSyncAnimations() {
     return true;
   }
+  async setDockTile(image) {
+  }
+}
+class WKFrame {
+  constructor(page, session) {
+    this._sessionListeners = [];
+    this._initializePromise = null;
+    this._page = page;
+    this._session = session;
+  }
+  async initialize() {
+    if (this._initializePromise)
+      return this._initializePromise;
+    this._initializePromise = this._initializeImpl();
+    return this._initializePromise;
+  }
+  async _initializeImpl() {
+    this._sessionListeners = [
+      import_eventsHelper.eventsHelper.addEventListener(this._session, "Console.messageAdded", (event) => this._page._onConsoleMessage(event)),
+      import_eventsHelper.eventsHelper.addEventListener(this._session, "Console.messageRepeatCountUpdated", (event) => this._page._onConsoleRepeatCountUpdated(event))
+    ];
+    await this._session.send("Console.enable");
+  }
+  dispose() {
+    import_eventsHelper.eventsHelper.removeEventListeners(this._sessionListeners);
+    this._session.dispose();
+  }
 }
 function parseRemoteAddress(value) {
   if (!value)

package/lib/server/webkit/wkWorkers.js

@@ -96,7 +96,8 @@ class WKWorkers {
       lineNumber: (lineNumber || 1) - 1,
       columnNumber: (columnNumber || 1) - 1
     };
-    this._page.addConsoleMessage(worker, derivedType, handles, location, handles.length ? void 0 : text);
+    const timestamp = event.message.timestamp ? event.message.timestamp * 1e3 : Date.now();
+    this._page.addConsoleMessage(worker, derivedType, handles, location, handles.length ? void 0 : text, timestamp);
   }
 }
 // Annotate the CommonJS export names for ESM import in node:

package/lib/serverRegistry.js

@@ -0,0 +1,156 @@
+"use strict";
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+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 __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var serverRegistry_exports = {};
+__export(serverRegistry_exports, {
+  serverRegistry: () => serverRegistry
+});
+module.exports = __toCommonJS(serverRegistry_exports);
+var import_fs = __toESM(require("fs"));
+var import_net = __toESM(require("net"));
+var import_path = __toESM(require("path"));
+var import_os = __toESM(require("os"));
+const packageVersion = require("../package.json").version;
+class ServerRegistry {
+  async list() {
+    const files = await import_fs.default.promises.readdir(this._browsersDir()).catch(() => []);
+    const result = /* @__PURE__ */ new Map();
+    for (const file of files) {
+      try {
+        const filePath = import_path.default.join(this._browsersDir(), file);
+        const content = await import_fs.default.promises.readFile(filePath, "utf-8");
+        const descriptor = JSON.parse(content);
+        const key = descriptor.workspaceDir ?? "";
+        let list = result.get(key);
+        if (!list) {
+          list = [];
+          result.set(key, list);
+        }
+        list.push(canConnect(descriptor).then((connectable) => ({ ...descriptor, canConnect: connectable, file: filePath })));
+      } catch {
+      }
+    }
+    const resolvedResult = /* @__PURE__ */ new Map();
+    for (const [key, promises] of result) {
+      const entries = await Promise.all(promises);
+      const descriptors = [];
+      for (const entry of entries) {
+        if (!entry.canConnect && !entry.browser.userDataDir) {
+          await import_fs.default.promises.unlink(entry.file).catch(() => {
+          });
+          continue;
+        }
+        descriptors.push(entry);
+      }
+      if (descriptors.length)
+        resolvedResult.set(key, descriptors);
+    }
+    return resolvedResult;
+  }
+  async create(browser, endpoint) {
+    const file = import_path.default.join(this._browsersDir(), browser.guid);
+    await import_fs.default.promises.mkdir(this._browsersDir(), { recursive: true });
+    const descriptor = {
+      playwrightVersion: packageVersion,
+      playwrightLib: require.resolve(".."),
+      title: endpoint.title,
+      browser,
+      endpoint: endpoint.endpoint,
+      workspaceDir: endpoint.workspaceDir
+    };
+    await import_fs.default.promises.writeFile(file, JSON.stringify(descriptor), "utf-8");
+  }
+  async delete(guid) {
+    const file = import_path.default.join(this._browsersDir(), guid);
+    await import_fs.default.promises.unlink(file).catch(() => {
+    });
+  }
+  async deleteUserData(guid) {
+    const filePath = import_path.default.join(this._browsersDir(), guid);
+    const content = await import_fs.default.promises.readFile(filePath, "utf-8");
+    const descriptor = JSON.parse(content);
+    if (descriptor.browser.userDataDir)
+      await import_fs.default.promises.rm(descriptor.browser.userDataDir, { recursive: true, force: true });
+    await import_fs.default.promises.unlink(filePath);
+  }
+  readDescriptor(guid) {
+    const filePath = import_path.default.join(this._browsersDir(), guid);
+    const content = import_fs.default.readFileSync(filePath, "utf-8");
+    const descriptor = JSON.parse(content);
+    return descriptor;
+  }
+  async find(name) {
+    const entries = await this.list();
+    for (const [, browsers] of entries) {
+      for (const browser of browsers) {
+        if (browser.title === name)
+          return browser;
+      }
+    }
+    return null;
+  }
+  _browsersDir() {
+    return process.env.PLAYWRIGHT_SERVER_REGISTRY || registryDirectory;
+  }
+}
+async function canConnect(descriptor) {
+  if (!descriptor.endpoint)
+    return false;
+  if (descriptor.endpoint.startsWith("ws://") || descriptor.endpoint.startsWith("wss://")) {
+    return await new Promise((resolve) => {
+      const url = new URL(descriptor.endpoint);
+      const socket = import_net.default.createConnection(Number(url.port), url.hostname, () => {
+        socket.destroy();
+        resolve(true);
+      });
+      socket.on("error", () => resolve(false));
+    });
+  }
+  return await new Promise((resolve) => {
+    const socket = import_net.default.createConnection(descriptor.endpoint ?? descriptor.pipeName, () => {
+      socket.destroy();
+      resolve(true);
+    });
+    socket.on("error", () => resolve(false));
+  });
+}
+const defaultCacheDirectory = (() => {
+  if (process.platform === "linux")
+    return process.env.XDG_CACHE_HOME || import_path.default.join(import_os.default.homedir(), ".cache");
+  if (process.platform === "darwin")
+    return import_path.default.join(import_os.default.homedir(), "Library", "Caches");
+  if (process.platform === "win32")
+    return process.env.LOCALAPPDATA || import_path.default.join(import_os.default.homedir(), "AppData", "Local");
+  throw new Error("Unsupported platform: " + process.platform);
+})();
+const registryDirectory = import_path.default.join(defaultCacheDirectory, "ms-playwright", "b");
+const serverRegistry = new ServerRegistry();
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  serverRegistry
+});