patchright-bun-core 1.58.2 → 1.59.0

package/lib/server/screencast.js

@@ -1,9 +1,7 @@
 "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)
@@ -17,171 +15,120 @@ var __copyProps = (to, from, except, desc) => {
   }
   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 screencast_exports = {};
 __export(screencast_exports, {
   Screencast: () => Screencast
 });
 module.exports = __toCommonJS(screencast_exports);
-var import_path = __toESM(require("path"));
 var import_utils = require("../utils");
 var import_utils2 = require("../utils");
-var import_videoRecorder = require("./videoRecorder");
-var import_page = require("./page");
-var import_registry = require("./registry");
 class Screencast {
   constructor(page) {
-    this._videoRecorder = null;
-    this._videoId = null;
-    this._screencastClients = /* @__PURE__ */ new Set();
-    // Aiming at 25 fps by default - each frame is 40ms, but we give some slack with 35ms.
-    // When throttling for tracing, 200ms between frames, except for 10 frames around the action.
-    this._frameThrottler = new FrameThrottler(10, 35, 200);
-    this._frameListener = null;
-    this._page = page;
-  }
-  stopFrameThrottler() {
-    this._frameThrottler.dispose();
-  }
-  setOptions(options) {
-    this._setOptions(options).catch((e) => import_utils2.debugLogger.log("error", e));
-    this._frameThrottler.setThrottlingEnabled(!!options);
+    this._clients = /* @__PURE__ */ new Set();
+    this.page = page;
+    this.page.instrumentation.addListener(this, page.browserContext);
+  }
+  async handlePageOrContextClose() {
+    const clients = [...this._clients];
+    this._clients.clear();
+    for (const client of clients) {
+      if (client.gracefulClose)
+        await client.gracefulClose();
+    }
   }
-  throttleFrameAck(ack) {
-    this._frameThrottler.ack(ack);
+  dispose() {
+    for (const client of this._clients)
+      client.dispose();
+    this._clients.clear();
+    this.page.instrumentation.removeListener(this);
   }
-  temporarilyDisableThrottling() {
-    this._frameThrottler.recharge();
+  showActions(options) {
+    this._actions = options;
   }
-  launchVideoRecorder() {
-    const recordVideo = this._page.browserContext._options.recordVideo;
-    if (!recordVideo)
-      return void 0;
-    (0, import_utils.assert)(!this._videoId);
-    this._videoId = (0, import_utils.createGuid)();
-    const outputFile = import_path.default.join(recordVideo.dir, this._videoId + ".webm");
-    const videoOptions = {
-      // validateBrowserContextOptions ensures correct video size.
-      ...recordVideo.size,
-      outputFile
-    };
-    const ffmpegPath = import_registry.registry.findExecutable("ffmpeg").executablePathOrDie(this._page.browserContext._browser.sdkLanguage());
-    this._videoRecorder = new import_videoRecorder.VideoRecorder(ffmpegPath, videoOptions);
-    this._frameListener = import_utils.eventsHelper.addEventListener(this._page, import_page.Page.Events.ScreencastFrame, (frame) => this._videoRecorder.writeFrame(frame.buffer, frame.frameSwapWallTime / 1e3));
-    this._page.waitForInitializedOrError().then((p) => {
-      if (p instanceof Error)
-        this.stopVideoRecording().catch(() => {
-        });
-    });
-    return videoOptions;
+  hideActions() {
+    this._actions = void 0;
   }
-  async startVideoRecording(options) {
-    const videoId = this._videoId;
-    (0, import_utils.assert)(videoId);
-    this._page.once(import_page.Page.Events.Close, () => this.stopVideoRecording().catch(() => {
-    }));
-    const gotFirstFrame = new Promise((f) => this._page.once(import_page.Page.Events.ScreencastFrame, f));
-    await this._startScreencast(this._videoRecorder, {
-      quality: 90,
-      width: options.width,
-      height: options.height
-    });
-    gotFirstFrame.then(() => {
-      this._page.browserContext._browser._videoStarted(this._page.browserContext, videoId, options.outputFile, this._page.waitForInitializedOrError());
-    });
+  addClient(client) {
+    this._clients.add(client);
+    if (this._clients.size === 1)
+      this._startScreencast(client.size, client.quality);
+    return { size: this._size };
   }
-  async stopVideoRecording() {
-    if (!this._videoId)
+  removeClient(client) {
+    if (!this._clients.has(client))
       return;
-    if (this._frameListener)
-      import_utils.eventsHelper.removeEventListeners([this._frameListener]);
-    this._frameListener = null;
-    const videoId = this._videoId;
-    this._videoId = null;
-    const videoRecorder = this._videoRecorder;
-    this._videoRecorder = null;
-    await this._stopScreencast(videoRecorder);
-    await videoRecorder.stop();
-    const video = this._page.browserContext._browser._takeVideo(videoId);
-    video?.reportFinished();
-  }
-  async _setOptions(options) {
-    if (options)
-      await this._startScreencast(this, options);
-    else
-      await this._stopScreencast(this);
-  }
-  async _startScreencast(client, options) {
-    this._screencastClients.add(client);
-    if (this._screencastClients.size === 1) {
-      await this._page.delegate.startScreencast({
-        width: options.width,
-        height: options.height,
-        quality: options.quality
-      });
+    this._clients.delete(client);
+    if (!this._clients.size)
+      this._stopScreencast();
+  }
+  size() {
+    return this._size;
+  }
+  _startScreencast(size, quality) {
+    this._size = size;
+    if (!this._size) {
+      const viewport = this.page.browserContext._options.viewport || { width: 800, height: 600 };
+      const scale = Math.min(1, 800 / Math.max(viewport.width, viewport.height));
+      this._size = {
+        width: Math.floor(viewport.width * scale),
+        height: Math.floor(viewport.height * scale)
+      };
     }
+    this._size = {
+      width: this._size.width & ~1,
+      height: this._size.height & ~1
+    };
+    this.page.delegate.startScreencast({
+      width: this._size.width,
+      height: this._size.height,
+      quality: quality ?? 90
+    });
   }
-  async _stopScreencast(client) {
-    this._screencastClients.delete(client);
-    if (!this._screencastClients.size)
-      await this._page.delegate.stopScreencast();
-  }
-}
-class FrameThrottler {
-  constructor(nonThrottledFrames, defaultInterval, throttlingInterval) {
-    this._acks = [];
-    this._throttlingEnabled = false;
-    this._nonThrottledFrames = nonThrottledFrames;
-    this._budget = nonThrottledFrames;
-    this._defaultInterval = defaultInterval;
-    this._throttlingInterval = throttlingInterval;
-    this._tick();
+  _stopScreencast() {
+    this.page.delegate.stopScreencast();
   }
-  dispose() {
-    if (this._timeoutId) {
-      clearTimeout(this._timeoutId);
-      this._timeoutId = void 0;
+  onScreencastFrame(frame, ack) {
+    const asyncResults = [];
+    for (const client of this._clients) {
+      const result = client.onFrame(frame);
+      if (result)
+        asyncResults.push(result);
     }
-  }
-  setThrottlingEnabled(enabled) {
-    this._throttlingEnabled = enabled;
-  }
-  recharge() {
-    for (const ack of this._acks)
-      ack();
-    this._acks = [];
-    this._budget = this._nonThrottledFrames;
-    if (this._timeoutId) {
-      clearTimeout(this._timeoutId);
-      this._tick();
+    if (ack) {
+      if (!asyncResults.length)
+        ack();
+      else
+        Promise.race(asyncResults).then(ack);
     }
   }
-  ack(ack) {
-    if (!this._timeoutId) {
-      ack();
+  async onBeforeCall(sdkObject, metadata, parentId) {
+    if (!this._actions)
       return;
-    }
-    this._acks.push(ack);
+    metadata.annotate = true;
   }
-  _tick() {
-    const ack = this._acks.shift();
-    if (ack) {
-      --this._budget;
-      ack();
-    }
-    if (this._throttlingEnabled && this._budget <= 0) {
-      this._timeoutId = setTimeout(() => this._tick(), this._throttlingInterval);
-    } else {
-      this._timeoutId = setTimeout(() => this._tick(), this._defaultInterval);
-    }
+  async onBeforeInputAction(sdkObject, metadata) {
+    if (!this._actions)
+      return;
+    const page = sdkObject.attribution.page;
+    if (!page)
+      return;
+    const actionTitle = (0, import_utils.renderTitleForCall)(metadata);
+    const utility = await page.mainFrame()._utilityContext();
+    await utility.evaluate(async (options) => {
+      const { injected, duration } = options;
+      injected.setScreencastAnnotation(options);
+      await new Promise((f) => injected.utils.builtins.setTimeout(f, duration));
+      injected.setScreencastAnnotation(null);
+    }, {
+      injected: await utility.injectedScript(),
+      duration: this._actions?.duration ?? 500,
+      point: metadata.point,
+      box: metadata.box,
+      actionTitle,
+      position: this._actions?.position,
+      fontSize: this._actions?.fontSize
+    }).catch((e) => import_utils2.debugLogger.log("error", e));
   }
 }
 // Annotate the CommonJS export names for ESM import in node:

package/lib/server/trace/recorder/snapshotter.js

@@ -57,7 +57,7 @@ class Snapshotter {
   async resetForReuse() {
     if (this._initScript) {
       import_eventsHelper.eventsHelper.removeEventListeners(this._eventListeners);
-      await this._context.removeInitScripts([this._initScript]);
+      await this._initScript.dispose();
       this._initScript = void 0;
     }
   }
@@ -69,7 +69,7 @@ class Snapshotter {
     ];
     const { javaScriptEnabled } = this._context._options;
     const initScriptSource = `(${import_snapshotterInjected.frameSnapshotStreamer})("${this._snapshotStreamer}", ${javaScriptEnabled || javaScriptEnabled === void 0})`;
-    this._initScript = await this._context.addInitScript(void 0, initScriptSource);
+    this._initScript = await this._context.addInitScript(initScriptSource);
     await this._context.safeNonStallingEvaluateInAllFrames(initScriptSource, "main");
   }
   dispose() {

package/lib/server/trace/recorder/tracing.js

@@ -38,6 +38,7 @@ var import_snapshotter = require("./snapshotter");
 var import_protocolMetainfo = require("../../../utils/isomorphic/protocolMetainfo");
 var import_assert = require("../../../utils/isomorphic/assert");
 var import_time = require("../../../utils/isomorphic/time");
+var import_manualPromise = require("../../../utils/isomorphic/manualPromise");
 var import_eventsHelper = require("../../utils/eventsHelper");
 var import_crypto = require("../../utils/crypto");
 var import_userAgent = require("../../utils/userAgent");
@@ -48,15 +49,14 @@ var import_errors = require("../../errors");
 var import_fileUtils = require("../../utils/fileUtils");
 var import_harTracer = require("../../har/harTracer");
 var import_instrumentation = require("../../instrumentation");
-var import_page = require("../../page");
 var import_progress = require("../../progress");
 const version = 8;
-const kScreencastOptions = { width: 800, height: 600, quality: 90 };
 class Tracing extends import_instrumentation.SdkObject {
   constructor(context, tracesDir) {
     super(context, "tracing");
     this._fs = new import_fileUtils.SerializedFS();
     this._screencastListeners = [];
+    this._pageTracingRecorders = /* @__PURE__ */ new Map();
     this._eventListeners = [];
     this._isStopping = false;
     this._allResources = /* @__PURE__ */ new Set();
@@ -219,10 +219,9 @@ class Tracing extends import_instrumentation.SdkObject {
   }
   _stopScreencast() {
     import_eventsHelper.eventsHelper.removeEventListeners(this._screencastListeners);
-    if (!(this._context instanceof import_browserContext.BrowserContext))
-      return;
-    for (const page of this._context.pages())
-      page.screencast.setOptions(null);
+    for (const recorder of this._pageTracingRecorders.values())
+      recorder.dispose();
+    this._pageTracingRecorders.clear();
   }
   _allocateNewTraceFile(state) {
     const suffix = state.chunkOrdinal ? `-chunk${state.chunkOrdinal}` : ``;
@@ -331,15 +330,27 @@ class Tracing extends import_instrumentation.SdkObject {
     await this._snapshotter?.captureSnapshot(sdkObject.attribution.page, metadata.id, snapshotName).catch(() => {
     });
   }
-  _shouldCaptureSnapshot(sdkObject, metadata) {
-    return !!this._snapshotter?.started() && shouldCaptureSnapshot(metadata) && !!sdkObject.attribution.page;
+  _shouldCaptureSnapshot(sdkObject, metadata, phase) {
+    if (!sdkObject.attribution.page || !this._snapshotter?.started())
+      return;
+    const metainfo = (0, import_protocolMetainfo.getMetainfo)(metadata);
+    if (!metainfo?.snapshot)
+      return false;
+    switch (phase) {
+      case "before":
+        return !metainfo.input || !!metainfo.isAutoWaiting;
+      case "input":
+        return !!metainfo.input;
+      case "after":
+        return true;
+    }
   }
   onBeforeCall(sdkObject, metadata, parentId) {
     const event = createBeforeActionTraceEvent(metadata, parentId ?? this._currentGroupId());
     if (!event)
       return Promise.resolve();
-    sdkObject.attribution.page?.screencast.temporarilyDisableThrottling();
-    if (this._shouldCaptureSnapshot(sdkObject, metadata))
+    this._temporarilyDisableThrottling(sdkObject.attribution.page);
+    if (this._shouldCaptureSnapshot(sdkObject, metadata, "before"))
       event.beforeSnapshot = `before@${metadata.id}`;
     this._state?.callIds.add(metadata.id);
     this._appendTraceEvent(event);
@@ -351,8 +362,8 @@ class Tracing extends import_instrumentation.SdkObject {
     const event = createInputActionTraceEvent(metadata);
     if (!event)
       return Promise.resolve();
-    sdkObject.attribution.page?.screencast.temporarilyDisableThrottling();
-    if (this._shouldCaptureSnapshot(sdkObject, metadata))
+    this._temporarilyDisableThrottling(sdkObject.attribution.page);
+    if (this._shouldCaptureSnapshot(sdkObject, metadata, "input"))
       event.inputSnapshot = `input@${metadata.id}`;
     this._appendTraceEvent(event);
     return this._captureSnapshot(event.inputSnapshot, sdkObject, metadata);
@@ -375,8 +386,8 @@ class Tracing extends import_instrumentation.SdkObject {
     const event = createAfterActionTraceEvent(metadata);
     if (!event)
       return Promise.resolve();
-    sdkObject.attribution.page?.screencast.temporarilyDisableThrottling();
-    if (this._shouldCaptureSnapshot(sdkObject, metadata))
+    this._temporarilyDisableThrottling(sdkObject.attribution.page);
+    if (this._shouldCaptureSnapshot(sdkObject, metadata, "after"))
       event.afterSnapshot = `after@${metadata.id}`;
     this._appendTraceEvent(event);
     return this._captureSnapshot(event.afterSnapshot, sdkObject, metadata);
@@ -483,26 +494,28 @@ class Tracing extends import_instrumentation.SdkObject {
     };
     this._appendTraceEvent(event);
   }
+  _temporarilyDisableThrottling(page) {
+    if (page)
+      this._pageTracingRecorders.get(page)?.temporarilyDisableThrottling();
+  }
   _startScreencastInPage(page) {
-    page.screencast.setOptions(kScreencastOptions);
     const prefix = page.guid;
-    this._screencastListeners.push(
-      import_eventsHelper.eventsHelper.addEventListener(page, import_page.Page.Events.ScreencastFrame, (params) => {
-        const suffix = params.timestamp || Date.now();
-        const sha1 = `${prefix}-${suffix}.jpeg`;
-        const event = {
-          type: "screencast-frame",
-          pageId: page.guid,
-          sha1,
-          width: params.width,
-          height: params.height,
-          timestamp: (0, import_time.monotonicTime)(),
-          frameSwapWallTime: params.frameSwapWallTime
-        };
-        this._appendResource(sha1, params.buffer);
-        this._appendTraceEvent(event);
-      })
-    );
+    const onFrame = (params) => {
+      const suffix = Date.now();
+      const sha1 = `${prefix}-${suffix}.jpeg`;
+      const event = {
+        type: "screencast-frame",
+        pageId: page.guid,
+        sha1,
+        width: params.viewportWidth,
+        height: params.viewportHeight,
+        timestamp: (0, import_time.monotonicTime)(),
+        frameSwapWallTime: params.frameSwapWallTime
+      };
+      this._appendResource(sha1, params.buffer);
+      this._appendTraceEvent(event);
+    };
+    this._pageTracingRecorders.set(page, new ScreencastTracingRecorder(page.screencast, onFrame));
   }
   _appendTraceEvent(event) {
     const visited = visitTraceEvent(event, this._state.traceSha1s);
@@ -545,10 +558,6 @@ function visitTraceEvent(object, sha1s) {
   }
   return object;
 }
-function shouldCaptureSnapshot(metadata) {
-  const metainfo = import_protocolMetainfo.methodMetainfo.get(metadata.type + "." + metadata.method);
-  return !!metainfo?.snapshot;
-}
 function createBeforeActionTraceEvent(metadata, parentId) {
   if (metadata.internal || metadata.method.startsWith("tracing"))
     return null;
@@ -598,6 +607,48 @@ function createAfterActionTraceEvent(metadata) {
     point: metadata.point
   };
 }
+const throttledRate = 200;
+const unthrottleDuration = 500;
+class ScreencastTracingRecorder {
+  constructor(screencast, onFrame) {
+    this._unthrottledUntil = 0;
+    this._screencast = screencast;
+    this._client = {
+      onFrame: (frame) => {
+        const time = (0, import_time.monotonicTime)();
+        if (time < this._unthrottledUntil) {
+          onFrame(frame);
+          return;
+        }
+        if (this._pendingAck)
+          return;
+        onFrame(frame);
+        this._pendingAck = new import_manualPromise.ManualPromise();
+        this._timer = setTimeout(() => this._clearPendingAck(), throttledRate);
+        return this._pendingAck;
+      },
+      gracefulClose: () => this.dispose(),
+      dispose: () => this.dispose()
+    };
+    this._screencast.addClient(this._client);
+  }
+  dispose() {
+    this._screencast.removeClient(this._client);
+    this._clearPendingAck();
+  }
+  temporarilyDisableThrottling() {
+    this._unthrottledUntil = (0, import_time.monotonicTime)() + unthrottleDuration;
+    this._clearPendingAck();
+  }
+  _clearPendingAck() {
+    this._pendingAck?.resolve();
+    this._pendingAck = void 0;
+    if (this._timer) {
+      clearTimeout(this._timer);
+      this._timer = void 0;
+    }
+  }
+}
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
   Tracing

package/lib/server/trace/viewer/traceViewer.js

@@ -91,7 +91,7 @@ async function startTraceViewerServer(options) {
   });
   const transport = options?.transport || (options?.isServer ? new StdinServer() : void 0);
   if (transport)
-    server.createWebSocket(transport);
+    server.createWebSocket(() => transport);
   const { host, port } = options || {};
   await server.start({ preferredPort: port, host });
   return server;
@@ -126,13 +126,12 @@ async function installRootRedirect(server, traceUrl, options) {
     return true;
   });
 }
-async function runTraceViewerApp(traceUrl, browserName, options, exitOnClose) {
+async function runTraceViewerApp(traceUrl, browserName, options) {
   traceUrl = validateTraceUrlOrPath(traceUrl);
   const server = await startTraceViewerServer(options);
   await installRootRedirect(server, traceUrl, options);
   const page = await openTraceViewerApp(server.urlPrefix("precise"), browserName, options);
-  if (exitOnClose)
-    page.on("close", () => (0, import_utils.gracefullyProcessExitDoNotHang)(0));
+  page.on("close", () => (0, import_utils.gracefullyProcessExitDoNotHang)(0));
   return page;
 }
 async function runTraceInBrowser(traceUrl, options) {

package/lib/server/usKeyboardLayout.js

@@ -119,6 +119,13 @@ const USKeyboardLayout = {
   "ArrowUp": { "keyCode": 38, "key": "ArrowUp" },
   "ArrowRight": { "keyCode": 39, "key": "ArrowRight" },
   "ArrowDown": { "keyCode": 40, "key": "ArrowDown" },
+  // Media keys
+  "AudioVolumeMute": { "keyCode": 173, "key": "AudioVolumeMute" },
+  "AudioVolumeDown": { "keyCode": 174, "key": "AudioVolumeDown" },
+  "AudioVolumeUp": { "keyCode": 175, "key": "AudioVolumeUp" },
+  "MediaTrackNext": { "keyCode": 176, "key": "MediaTrackNext" },
+  "MediaTrackPrevious": { "keyCode": 177, "key": "MediaTrackPrevious" },
+  "MediaPlayPause": { "keyCode": 179, "key": "MediaPlayPause" },
   // Numpad
   "NumLock": { "keyCode": 144, "key": "NumLock" },
   "NumpadDivide": { "keyCode": 111, "key": "/", "location": 3 },

package/lib/server/utils/comparators.js

@@ -37,7 +37,7 @@ var import_pixelmatch = __toESM(require("../../third_party/pixelmatch"));
 var import_utilsBundle = require("../../utilsBundle");
 var import_utilsBundle2 = require("../../utilsBundle");
 var import_utilsBundle3 = require("../../utilsBundle");
-var import_imageUtils = require("./imageUtils");
+var import_imageUtils = require("../../utils/isomorphic/imageUtils");
 function getComparator(mimeType) {
   if (mimeType === "image/png")
     return compareImages.bind(null, "image/png");

package/lib/server/utils/disposable.js

@@ -0,0 +1,32 @@
+"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 disposable_exports = {};
+__export(disposable_exports, {
+  disposeAll: () => disposeAll
+});
+module.exports = __toCommonJS(disposable_exports);
+async function disposeAll(disposables) {
+  const copy = [...disposables];
+  disposables.length = 0;
+  await Promise.all(copy.map((d) => d.dispose()));
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  disposeAll
+});

package/lib/server/utils/eventsHelper.js

@@ -24,7 +24,9 @@ module.exports = __toCommonJS(eventsHelper_exports);
 class EventsHelper {
   static addEventListener(emitter, eventName, handler) {
     emitter.on(eventName, handler);
-    return { emitter, eventName, handler };
+    return { emitter, eventName, handler, dispose: async () => {
+      emitter.removeListener(eventName, handler);
+    } };
   }
   static removeEventListeners(listeners) {
     for (const listener of listeners)

package/lib/server/utils/fileUtils.js

@@ -32,6 +32,7 @@ __export(fileUtils_exports, {
   canAccessFile: () => canAccessFile,
   copyFileAndMakeWritable: () => copyFileAndMakeWritable,
   existsAsync: () => existsAsync,
+  makeSocketPath: () => makeSocketPath,
   mkdirIfNeeded: () => mkdirIfNeeded,
   removeFolders: () => removeFolders,
   sanitizeForFilePath: () => sanitizeForFilePath,
@@ -39,9 +40,10 @@ __export(fileUtils_exports, {
 });
 module.exports = __toCommonJS(fileUtils_exports);
 var import_fs = __toESM(require("fs"));
+var import_os = __toESM(require("os"));
 var import_path = __toESM(require("path"));
+var import_crypto = require("./crypto");
 var import_manualPromise = require("../../utils/isomorphic/manualPromise");
-var import_zipBundle = require("../../zipBundle");
 const existsAsync = (path2) => new Promise((resolve) => import_fs.default.stat(path2, (err) => resolve(!err)));
 async function mkdirIfNeeded(filePath) {
   await import_fs.default.promises.mkdir(import_path.default.dirname(filePath), { recursive: true }).catch(() => {
@@ -72,6 +74,16 @@ function sanitizeForFilePath(s) {
 function toPosixPath(aPath) {
   return aPath.split(import_path.default.sep).join(import_path.default.posix.sep);
 }
+function makeSocketPath(domain, name) {
+  const userNameHash = (0, import_crypto.calculateSha1)(process.env.USERNAME || process.env.USER || "default").slice(0, 8);
+  if (process.platform === "win32")
+    return `\\\\.\\pipe\\pw-${userNameHash}-${domain}-${name}`;
+  const baseDir = process.env.PLAYWRIGHT_SOCKETS_DIR || import_path.default.join(import_os.default.tmpdir(), `pw-${userNameHash}`);
+  const dir = import_path.default.join(baseDir, domain);
+  const result = import_path.default.join(dir, `${name}.sock`);
+  import_fs.default.mkdirSync(dir, { recursive: true });
+  return result;
+}
 class SerializedFS {
   constructor() {
     this._buffers = /* @__PURE__ */ new Map();
@@ -165,7 +177,8 @@ class SerializedFS {
         return;
       }
       case "zip": {
-        const zipFile = new import_zipBundle.yazl.ZipFile();
+        const { yazl } = await import("playwright-core/lib/zipBundle");
+        const zipFile = new yazl.ZipFile();
         const result = new import_manualPromise.ManualPromise();
         zipFile.on("error", (error) => result.reject(error));
         for (const entry of op.entries)
@@ -184,6 +197,7 @@ class SerializedFS {
   canAccessFile,
   copyFileAndMakeWritable,
   existsAsync,
+  makeSocketPath,
   mkdirIfNeeded,
   removeFolders,
   sanitizeForFilePath,