patchright-bun-core 1.58.2 → 1.59.0

package/lib/server/firefox/ffInput.js

@@ -23,6 +23,20 @@ __export(ffInput_exports, {
   RawTouchscreenImpl: () => RawTouchscreenImpl
 });
 module.exports = __toCommonJS(ffInput_exports);
+const kFirefoxKeyOverrides = /* @__PURE__ */ new Map([
+  ["AudioVolumeMute", { code: "VolumeMute", keyCodeWithoutLocation: 181 }],
+  ["AudioVolumeDown", { code: "VolumeDown", keyCodeWithoutLocation: 182 }],
+  ["AudioVolumeUp", { code: "VolumeUp", keyCodeWithoutLocation: 183 }]
+]);
+function toFirefoxKeyDescription(description) {
+  const override = kFirefoxKeyOverrides.get(description.key);
+  if (!override)
+    return description;
+  return {
+    ...description,
+    ...override
+  };
+}
 function toModifiersMask(modifiers) {
   let mask = 0;
   if (modifiers.has("Alt"))
@@ -59,13 +73,14 @@ class RawKeyboardImpl {
     this._client = client;
   }
   async keydown(progress, modifiers, keyName, description, autoRepeat) {
-    let text = description.text;
+    const keyDescription = toFirefoxKeyDescription(description);
+    let text = keyDescription.text;
     if (text === "\r")
       text = "";
-    const { code, key, location } = description;
+    const { code, key, location } = keyDescription;
     await progress.race(this._client.send("Page.dispatchKeyEvent", {
       type: "keydown",
-      keyCode: description.keyCodeWithoutLocation,
+      keyCode: keyDescription.keyCodeWithoutLocation,
       code,
       key,
       repeat: autoRepeat,
@@ -74,11 +89,12 @@ class RawKeyboardImpl {
     }));
   }
   async keyup(progress, modifiers, keyName, description) {
-    const { code, key, location } = description;
+    const keyDescription = toFirefoxKeyDescription(description);
+    const { code, key, location } = keyDescription;
     await progress.race(this._client.send("Page.dispatchKeyEvent", {
       type: "keyup",
       key,
-      keyCode: description.keyCodeWithoutLocation,
+      keyCode: keyDescription.keyCodeWithoutLocation,
       code,
       location,
       repeat: false

package/lib/server/firefox/ffNetworkManager.js

@@ -133,8 +133,7 @@ class FFNetworkManager {
       this._requests.delete(request._id);
       response._requestFinished(responseEndTime);
     }
-    if (event.protocolVersion)
-      response._setHttpVersion(event.protocolVersion);
+    response._setHttpVersion(event.protocolVersion ?? null);
     this._page.frameManager.reportRequestFinished(request.request, response);
   }
   _onRequestFailed(event) {
@@ -147,6 +146,7 @@ class FFNetworkManager {
       response.setTransferSize(null);
       response.setEncodedBodySize(null);
       response._requestFinished(-1);
+      response._setHttpVersion(null);
     }
     request.request._setFailureText(event.errorCode);
     this._page.frameManager.requestFailed(request.request, event.errorCode === "NS_BINDING_ABORTED");

package/lib/server/firefox/ffPage.js

@@ -43,7 +43,7 @@ var import_ffInput = require("./ffInput");
 var import_ffNetworkManager = require("./ffNetworkManager");
 var import_stackTrace = require("../../utils/isomorphic/stackTrace");
 var import_errors = require("../errors");
-var import_debugLogger = require("../utils/debugLogger");
+var import_videoRecorder = require("../videoRecorder");
 const UTILITY_WORLD_NAME = "__playwright_utility_world__";
 class FFPage {
   constructor(session, browserContext, opener) {
@@ -89,19 +89,14 @@ class FFPage {
       import_eventsHelper.eventsHelper.addEventListener(this._session, "Page.webSocketFrameSent", this._onWebSocketFrameSent.bind(this)),
       import_eventsHelper.eventsHelper.addEventListener(this._session, "Page.screencastFrame", this._onScreencastFrame.bind(this))
     ];
-    const screencast = this._page.screencast;
-    const videoOptions = screencast.launchVideoRecorder();
-    if (videoOptions)
-      screencast.startVideoRecording(videoOptions).catch((e) => import_debugLogger.debugLogger.log("error", e));
-    this._session.once("Page.ready", () => {
-      if (this._reportedAsNew)
-        return;
-      this._reportedAsNew = true;
-      this._page.reportAsNew(this._opener?._page);
-    });
-    this.addInitScript(new import_page.InitScript(""), UTILITY_WORLD_NAME).catch((e) => this._markAsError(e));
-  }
-  async _markAsError(error) {
+    const promises = [];
+    if (!this._page.isStorageStatePage)
+      (0, import_videoRecorder.startAutomaticVideoRecording)(this._page);
+    promises.push(new Promise((f) => this._session.once("Page.ready", f)));
+    Promise.all(promises).then(() => this._reportAsNew(), (error) => this._reportAsNew(error));
+    this.addInitScript(new import_page.InitScript(this._page, ""), UTILITY_WORLD_NAME).catch((e) => this._reportAsNew(e));
+  }
+  _reportAsNew(error) {
     if (this._reportedAsNew)
       return;
     this._reportedAsNew = true;
@@ -203,7 +198,8 @@ class FFPage {
     const context = this._contextIdToContext.get(executionContextId);
     if (!context)
       return;
-    this._page.addConsoleMessage(null, type === "warn" ? "warning" : type, args.map((arg) => (0, import_ffExecutionContext.createHandle)(context, arg)), location);
+    const timestamp = Date.now();
+    this._page.addConsoleMessage(null, type === "warn" ? "warning" : type, args.map((arg) => (0, import_ffExecutionContext.createHandle)(context, arg)), location, void 0, timestamp);
   }
   _onDialogOpened(params) {
     this._page.browserContext.dialogManager.dialogDidOpen(new dialog.Dialog(
@@ -253,7 +249,7 @@ class FFPage {
     workerSession.on("Runtime.console", (event2) => {
       const { type, args, location } = event2;
       const context = worker.existingExecutionContext;
-      this._page.addConsoleMessage(worker, type, args.map((arg) => (0, import_ffExecutionContext.createHandle)(context, arg)), location);
+      this._page.addConsoleMessage(worker, type, args.map((arg) => (0, import_ffExecutionContext.createHandle)(context, arg)), location, void 0, Date.now());
     });
   }
   _onWorkerDestroyed(event) {
@@ -276,7 +272,7 @@ class FFPage {
     this._page._didCrash();
   }
   didClose() {
-    this._markAsError(new import_errors.TargetClosedError(this._page.closeReason()));
+    this._reportAsNew(new import_errors.TargetClosedError(this._page.closeReason()));
     this._session.dispose();
     import_eventsHelper.eventsHelper.removeEventListeners(this._eventListeners);
     this._networkManager.dispose();
@@ -417,23 +413,22 @@ class FFPage {
       throw e;
     });
   }
-  async startScreencast(options) {
-    await this._session.send("Page.startScreencast", options);
+  startScreencast(options) {
+    this._session.sendMayFail("Page.startScreencast", { width: options.width, height: options.height, quality: options.quality });
   }
-  async stopScreencast() {
-    await this._session.sendMayFail("Page.stopScreencast");
+  stopScreencast() {
+    this._session.sendMayFail("Page.stopScreencast");
   }
   _onScreencastFrame(event) {
-    this._page.screencast.throttleFrameAck(() => {
-      this._session.sendMayFail("Page.screencastFrameAck");
-    });
     const buffer = Buffer.from(event.data, "base64");
-    this._page.emit(import_page2.Page.Events.ScreencastFrame, {
+    this._page.screencast.onScreencastFrame({
       buffer,
       frameSwapWallTime: event.timestamp * 1e3,
       // timestamp is in seconds, we need to convert to milliseconds.
-      width: event.deviceWidth,
-      height: event.deviceHeight
+      viewportWidth: event.deviceWidth,
+      viewportHeight: event.deviceHeight
+    }, () => {
+      this._session.sendMayFail("Page.screencastFrameAck");
     });
   }
   rafCountForStablePosition() {
@@ -486,6 +481,8 @@ class FFPage {
   shouldToggleStyleSheetToSyncAnimations() {
     return false;
   }
+  async setDockTile(image) {
+  }
 }
 function webSocketId(frameId, wsid) {
   return `${frameId}---${wsid}`;

package/lib/server/frames.js

@@ -47,7 +47,6 @@ var import_progress = require("./progress");
 var types = __toESM(require("./types"));
 var import_utils = require("../utils");
 var import_protocolError = require("./protocolError");
-var import_debugLogger = require("./utils/debugLogger");
 var import_eventsHelper = require("./utils/eventsHelper");
 var import_selectorParser = require("../utils/isomorphic/selectorParser");
 var import_manualPromise = require("../utils/isomorphic/manualPromise");
@@ -179,7 +178,7 @@ class FrameManager {
     const navigationEvent = { url, name, newDocument: frame._currentDocument, isPublic: true };
     this._fireInternalFrameNavigation(frame, navigationEvent);
     if (!initial) {
-      import_debugLogger.debugLogger.log("api", `  navigated to "${url}"`);
+      frame.apiLog(`  navigated to "${url}"`);
       this._page.frameNavigatedToNewDocument(frame);
     }
     frame.setPendingDocument(keepPending);
@@ -195,7 +194,7 @@ class FrameManager {
     frame._url = url;
     const navigationEvent = { url, name: frame._name, isPublic: true };
     this._fireInternalFrameNavigation(frame, navigationEvent);
-    import_debugLogger.debugLogger.log("api", `  navigated to "${url}"`);
+    frame.apiLog(`  navigated to "${url}"`);
   }
   frameAbortedNavigation(frameId, errorText, documentId) {
     const frame = this._frames.get(frameId);
@@ -398,7 +397,7 @@ class Frame extends import_instrumentation.SdkObject {
     this._firedLifecycleEvents.add(event);
     this.emit(Frame.Events.AddLifecycle, event);
     if (this === this._page.mainFrame() && this._url !== "about:blank")
-      import_debugLogger.debugLogger.log("api", `  "${event}" event fired`);
+      this.apiLog(`  "${event}" event fired`);
     this._page.mainFrame()._recalculateNetworkIdle();
   }
   _onClearLifecycle() {
@@ -470,7 +469,7 @@ class Frame extends import_instrumentation.SdkObject {
       this._firedLifecycleEvents.add("networkidle");
       this.emit(Frame.Events.AddLifecycle, "networkidle");
       if (this === this._page.mainFrame() && this._url !== "about:blank")
-        import_debugLogger.debugLogger.log("api", `  "networkidle" event fired`);
+        this.apiLog(`  "networkidle" event fired`);
     }
     if (frameThatAllowsRemovingNetworkIdle !== this && this._firedLifecycleEvents.has("networkidle") && !isNetworkIdle) {
       this._firedLifecycleEvents.delete("networkidle");
@@ -605,7 +604,7 @@ class Frame extends import_instrumentation.SdkObject {
     return value;
   }
   async querySelector(selector, options) {
-    import_debugLogger.debugLogger.log("api", `    finding element using the selector "${selector}"`);
+    this.apiLog(`    finding element using the selector "${selector}"`);
     return this.selectors.query(selector, options);
   }
   async waitForSelector(progress, selector, performActionPreChecksAndLog, options, scope) {
@@ -1145,9 +1144,6 @@ class Frame extends import_instrumentation.SdkObject {
   async waitForTimeout(progress, timeout) {
     return progress.wait(timeout);
   }
-  async ariaSnapshot(progress, selector) {
-    return await this._retryWithProgressIfNotConnected(progress, selector, { strict: true, performActionPreChecks: true }, (handle) => progress.race(handle.ariaSnapshot()));
-  }
   async expect(progress, selector, options) {
     progress.log(`${(0, import_utils.renderTitleForCall)(progress.metadata)}${options.timeoutForLogs ? ` with timeout ${options.timeoutForLogs}ms` : ""}`);
     const lastIntermediateResult = { isSet: false };
@@ -1306,8 +1302,17 @@ class Frame extends import_instrumentation.SdkObject {
     return JSON.parse(handle.rawValue());
   }
   async title() {
-    const context = await this._utilityContext();
-    return context.evaluate(() => document.title);
+    try {
+      return await this.raceAgainstEvaluationStallingEvents(async () => {
+        const context = await this._utilityContext();
+        return await context.evaluate(() => document.title);
+      });
+    } catch {
+      const url = this.pendingDocument()?.request?.url();
+      if (url)
+        return `Loading ${url}`;
+      return "";
+    }
   }
   async rafrafTimeout(progress, timeout) {
     if (timeout === 0)
@@ -1407,6 +1412,30 @@ class Frame extends import_instrumentation.SdkObject {
       injectedScript.extend(source2, arg2);
     }, { source, arg });
   }
+  async ariaSnapshot(progress, options = {}) {
+    if (options.selector && options.track)
+      throw new Error("Cannot specify both selector and track options");
+    if (options.selector && options.mode !== "ai") {
+      const snapshot2 = await this._retryWithProgressIfNotConnected(progress, options.selector, { strict: true, performActionPreChecks: true }, async (handle) => {
+        return await progress.race(handle.evaluateInUtility(([injected, element, opts]) => injected.ariaSnapshot(element, opts), { mode: "default", depth: options.depth }));
+      });
+      return { snapshot: snapshot2 };
+    }
+    let targetFrame;
+    let info;
+    if (options.selector) {
+      const resolved = await this.selectors.resolveInjectedForSelector(options.selector, { strict: true });
+      if (!resolved)
+        throw new Error(`Selector "${options.selector}" did not resolve to any element`);
+      targetFrame = resolved.frame;
+      info = resolved.info;
+    } else {
+      targetFrame = this;
+    }
+    const result = await (0, import_page.ariaSnapshotForFrame)(progress, targetFrame, { ...options, info });
+    const snapshot = options.track && result.incremental ? result.incremental.join("\n") : result.full.join("\n");
+    return { snapshot };
+  }
   _asLocator(selector) {
     return (0, import_utils.asLocator)(this._page.browserContext._browser.sdkLanguage(), selector);
   }

package/lib/server/har/harRecorder.js

@@ -37,7 +37,6 @@ var import_artifact = require("../artifact");
 var import_harTracer = require("./harTracer");
 var import_crypto = require("../utils/crypto");
 var import_manualPromise = require("../../utils/isomorphic/manualPromise");
-var import_zipBundle = require("../../zipBundle");
 class HarRecorder {
   constructor(context, page, options) {
     this._isFlushed = false;
@@ -56,7 +55,8 @@ class HarRecorder {
       waitForContentOnStop: true,
       urlFilter: urlFilterRe ?? options.urlGlob
     });
-    this._zipFile = content === "attach" || expectsZip ? new import_zipBundle.yazl.ZipFile() : null;
+    const { yazl } = require("../../zipBundle");
+    this._zipFile = content === "attach" || expectsZip ? new yazl.ZipFile() : null;
     this._tracer.start({ omitScripts: false });
   }
   onEntryStarted(entry) {

package/lib/server/har/harTracer.js

@@ -278,9 +278,6 @@ class HarTracer {
           harEntry._securityDetails = details;
       }));
     }
-    const httpVersion = response.httpVersion();
-    harEntry.request.httpVersion = httpVersion;
-    harEntry.response.httpVersion = httpVersion;
     const compressionCalculationBarrier = this._options.omitSizes ? void 0 : {
       _encodedBodySize: -1,
       _decodedBodySize: -1,
@@ -317,6 +314,10 @@ class HarTracer {
         this._delegate.onEntryFinished(harEntry);
     });
     this._addBarrier(page || request.serviceWorker(), promise);
+    this._addBarrier(page || request.serviceWorker(), response.httpVersion().then((httpVersion) => {
+      harEntry.request.httpVersion = httpVersion;
+      harEntry.response.httpVersion = httpVersion;
+    }));
     const timing = response.timing();
     harEntry.timings.receive = response.request()._responseEndTiming !== -1 ? import_helper.helper.millisToRoundishMillis(response.request()._responseEndTiming - timing.responseStart) : -1;
     this._computeHarEntryTotalTime(harEntry);
@@ -389,7 +390,7 @@ class HarTracer {
     harEntry.response = {
       status: response.status(),
       statusText: response.statusText(),
-      httpVersion: response.httpVersion(),
+      httpVersion: FALLBACK_HTTP_VERSION,
       // These are bad values that will be overwritten below.
       cookies: [],
       headers: [],

package/lib/server/input.js

@@ -48,6 +48,10 @@ class Keyboard {
     this._raw = raw;
     this._page = page;
   }
+  async apiDown(progress, key) {
+    await this._page.instrumentation.onBeforeInputAction(this._page, progress.metadata);
+    await this.down(progress, key);
+  }
   async down(progress, key) {
     const description = this._keyDescriptionForString(key);
     const autoRepeat = this._pressedKeys.has(description.code);
@@ -67,6 +71,10 @@ class Keyboard {
       return { ...description, text: "" };
     return description;
   }
+  async apiUp(progress, key) {
+    await this._page.instrumentation.onBeforeInputAction(this._page, progress.metadata);
+    await this.up(progress, key);
+  }
   async up(progress, key) {
     const description = this._keyDescriptionForString(key);
     if (kModifiers.includes(description.key))
@@ -74,9 +82,17 @@ class Keyboard {
     this._pressedKeys.delete(description.code);
     await this._raw.keyup(progress, this._pressedModifiers, key, description);
   }
-  async insertText(progress, text) {
+  async apiInsertText(progress, text) {
+    await this._page.instrumentation.onBeforeInputAction(this._page, progress.metadata);
+    await this._insertText(progress, text);
+  }
+  async _insertText(progress, text) {
     await this._raw.sendText(progress, text);
   }
+  async apiType(progress, text, options) {
+    await this._page.instrumentation.onBeforeInputAction(this._page, progress.metadata);
+    await this.type(progress, text, options);
+  }
   async type(progress, text, options) {
     const delay = options && options.delay || void 0;
     for (const char of text) {
@@ -85,10 +101,14 @@ class Keyboard {
       } else {
         if (delay)
           await progress.wait(delay);
-        await this.insertText(progress, char);
+        await this._insertText(progress, char);
       }
     }
   }
+  async apiPress(progress, key, options = {}) {
+    await this._page.instrumentation.onBeforeInputAction(this._page, progress.metadata);
+    await this.press(progress, key, options);
+  }
   async press(progress, key, options = {}) {
     function split(keyString) {
       const keys = [];
@@ -157,6 +177,11 @@ class Mouse {
   currentPoint() {
     return { x: this._x, y: this._y };
   }
+  async apiMove(progress, x, y, options = {}) {
+    progress.metadata.point = { x, y };
+    await this._page.instrumentation.onBeforeInputAction(this._page, progress.metadata);
+    await this.move(progress, x, y, options);
+  }
   async move(progress, x, y, options = {}) {
     const { steps = 1 } = options;
     const fromX = this._x;
@@ -169,18 +194,33 @@ class Mouse {
       await this._raw.move(progress, middleX, middleY, this._lastButton, this._buttons, this._keyboard._modifiers(), !!options.forClick);
     }
   }
+  async apiDown(progress, options = {}) {
+    progress.metadata.point = this.currentPoint();
+    await this._page.instrumentation.onBeforeInputAction(this._page, progress.metadata);
+    await this.down(progress, options);
+  }
   async down(progress, options = {}) {
     const { button = "left", clickCount = 1 } = options;
     this._lastButton = button;
     this._buttons.add(button);
     await this._raw.down(progress, this._x, this._y, this._lastButton, this._buttons, this._keyboard._modifiers(), clickCount);
   }
+  async apiUp(progress, options = {}) {
+    progress.metadata.point = this.currentPoint();
+    await this._page.instrumentation.onBeforeInputAction(this._page, progress.metadata);
+    await this.up(progress, options);
+  }
   async up(progress, options = {}) {
     const { button = "left", clickCount = 1 } = options;
     this._lastButton = "none";
     this._buttons.delete(button);
     await this._raw.up(progress, this._x, this._y, button, this._buttons, this._keyboard._modifiers(), clickCount);
   }
+  async apiClick(progress, x, y, options = {}) {
+    progress.metadata.point = { x, y };
+    await this._page.instrumentation.onBeforeInputAction(this._page, progress.metadata);
+    await this.click(progress, x, y, options);
+  }
   async click(progress, x, y, options = {}) {
     const { delay = null, clickCount = 1, steps } = options;
     if (delay) {
@@ -206,7 +246,8 @@ class Mouse {
       await Promise.all(promises);
     }
   }
-  async wheel(progress, deltaX, deltaY) {
+  async apiWheel(progress, deltaX, deltaY) {
+    await this._page.instrumentation.onBeforeInputAction(this._page, progress.metadata);
     await this._raw.wheel(progress, this._x, this._y, this._buttons, this._keyboard._modifiers(), deltaX, deltaY);
   }
 }
@@ -260,9 +301,13 @@ class Touchscreen {
     this._raw = raw;
     this._page = page;
   }
-  async tap(progress, x, y) {
+  async apiTap(progress, x, y) {
     if (!this._page.browserContext._options.hasTouch)
       throw new Error("hasTouch must be enabled on the browser context before using the touchscreen.");
+    await this._page.instrumentation.onBeforeInputAction(this._page, progress.metadata);
+    await this.tap(progress, x, y);
+  }
+  async tap(progress, x, y) {
     await this._raw.tap(progress, x, y, this._page.keyboard._modifiers());
   }
 }

package/lib/server/instrumentation.js

@@ -25,6 +25,7 @@ __export(instrumentation_exports, {
 module.exports = __toCommonJS(instrumentation_exports);
 var import_events = require("events");
 var import_crypto = require("./utils/crypto");
+var import_debugLogger = require("./utils/debugLogger");
 class SdkObject extends import_events.EventEmitter {
   constructor(parent, guidPrefix, guid) {
     super();
@@ -33,6 +34,10 @@ class SdkObject extends import_events.EventEmitter {
     this.attribution = { ...parent.attribution };
     this.instrumentation = parent.instrumentation;
   }
+  apiLog(message) {
+    if (!this.attribution.playwright.options.isInternalPlaywright)
+      import_debugLogger.debugLogger.log("api", message);
+  }
   closeReason() {
     return this.attribution.page?._closeReason || this.attribution.context?._closeReason || this.attribution.browser?._closeReason;
   }

package/lib/server/launchApp.js

@@ -106,7 +106,6 @@ async function syncLocalStorageWithSettings(page, appName) {
     });
     const settings = await import_fs.default.promises.readFile(settingsFile, "utf-8").catch(() => "{}");
     await page.addInitScript(
-      progress,
       `(${String((settings2) => {
         if (location && location.protocol === "data:")
           return;

package/lib/server/localUtils.js

@@ -45,13 +45,13 @@ var import_crypto = require("./utils/crypto");
 var import_harBackend = require("./harBackend");
 var import_manualPromise = require("../utils/isomorphic/manualPromise");
 var import_zipFile = require("./utils/zipFile");
-var import_zipBundle = require("../zipBundle");
-var import_traceUtils = require("../utils/isomorphic/traceUtils");
+var import_traceUtils = require("../utils/isomorphic/trace/traceUtils");
 var import_assert = require("../utils/isomorphic/assert");
 var import_fileUtils = require("./utils/fileUtils");
 async function zip(progress, stackSessions, params) {
   const promise = new import_manualPromise.ManualPromise();
-  const zipFile = new import_zipBundle.yazl.ZipFile();
+  const { yauzl, yazl } = require("../zipBundle");
+  const zipFile = new yazl.ZipFile();
   zipFile.on("error", (error) => promise.reject(error));
   const addFile = (file, name) => {
     try {
@@ -69,7 +69,7 @@ async function zip(progress, stackSessions, params) {
     zipFile.addBuffer(buffer, "trace.stacks");
   }
   if (params.includeSources) {
-    const sourceFiles = /* @__PURE__ */ new Set();
+    const sourceFiles = new Set(params.additionalSources);
     for (const { stack } of stackSession?.callStacks || []) {
       if (!stack)
         continue;
@@ -77,7 +77,7 @@ async function zip(progress, stackSessions, params) {
         sourceFiles.add(file);
     }
     for (const sourceFile of sourceFiles)
-      addFile(sourceFile, "resources/src@" + await (0, import_crypto.calculateSha1)(sourceFile) + ".txt");
+      addFile(sourceFile, "resources/src@" + (0, import_crypto.calculateSha1)(sourceFile) + ".txt");
   }
   if (params.mode === "write") {
     await progress.race(import_fs.default.promises.mkdir(import_path.default.dirname(params.zipFile), { recursive: true }));
@@ -90,7 +90,7 @@ async function zip(progress, stackSessions, params) {
   }
   const tempFile = params.zipFile + ".tmp";
   await progress.race(import_fs.default.promises.rename(params.zipFile, tempFile));
-  import_zipBundle.yauzl.open(tempFile, (err, inZipFile) => {
+  yauzl.open(tempFile, (err, inZipFile) => {
     if (err) {
       promise.reject(err);
       return;

package/lib/server/network.js

@@ -373,7 +373,7 @@ class Route extends import_instrumentation.SdkObject {
   }
 }
 class Response extends import_instrumentation.SdkObject {
-  constructor(request, status, statusText2, headers, timing, getResponseBodyCallback, fromServiceWorker, httpVersion) {
+  constructor(request, status, statusText2, headers, timing, getResponseBodyCallback, fromServiceWorker) {
     super(request.frame() || request._context, "response");
     this._contentPromise = null;
     this._finishedPromise = new import_manualPromise.ManualPromise();
@@ -381,6 +381,7 @@ class Response extends import_instrumentation.SdkObject {
     this._serverAddrPromise = new import_manualPromise.ManualPromise();
     this._securityDetailsPromise = new import_manualPromise.ManualPromise();
     this._rawResponseHeadersPromise = new import_manualPromise.ManualPromise();
+    this._httpVersionPromise = new import_manualPromise.ManualPromise();
     this._encodedBodySizePromise = new import_manualPromise.ManualPromise();
     this._transferSizePromise = new import_manualPromise.ManualPromise();
     this._responseHeadersSizePromise = new import_manualPromise.ManualPromise();
@@ -394,7 +395,6 @@ class Response extends import_instrumentation.SdkObject {
       this._headersMap.set(name.toLowerCase(), value);
     this._getResponseBodyCallback = getResponseBodyCallback;
     this._request._setResponse(this);
-    this._httpVersion = httpVersion;
     this._fromServiceWorker = fromServiceWorker;
   }
   _serverAddrFinished(addr) {
@@ -410,7 +410,7 @@ class Response extends import_instrumentation.SdkObject {
     this._finishedPromise.resolve();
   }
   _setHttpVersion(httpVersion) {
-    this._httpVersion = httpVersion;
+    this._httpVersionPromise.resolve(httpVersion);
   }
   url() {
     return this._url;
@@ -476,14 +476,15 @@ class Response extends import_instrumentation.SdkObject {
   frame() {
     return this._request.frame();
   }
-  httpVersion() {
-    if (!this._httpVersion)
+  async httpVersion() {
+    const httpVersion = await this._httpVersionPromise || null;
+    if (!httpVersion)
       return "HTTP/1.1";
-    if (this._httpVersion === "http/1.1")
+    if (httpVersion === "http/1.1")
       return "HTTP/1.1";
-    if (this._httpVersion === "h2")
+    if (httpVersion === "h2")
       return "HTTP/2.0";
-    return this._httpVersion;
+    return httpVersion;
   }
   fromServiceWorker() {
     return this._fromServiceWorker;