patchright-bun-core 1.58.2 → 1.59.0

package/lib/server/browserContext.js

@@ -29,6 +29,7 @@ var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: tru
 var browserContext_exports = {};
 __export(browserContext_exports, {
   BrowserContext: () => BrowserContext,
+  calculateUserAgentEmulation: () => calculateUserAgentEmulation,
   normalizeProxySettings: () => normalizeProxySettings,
   validateBrowserContextOptions: () => validateBrowserContextOptions,
   verifyClientCertificates: () => verifyClientCertificates,
@@ -36,14 +37,12 @@ __export(browserContext_exports, {
 });
 module.exports = __toCommonJS(browserContext_exports);
 var import_fs = __toESM(require("fs"));
-var import_path = __toESM(require("path"));
 var import_crypto = require("./utils/crypto");
 var import_debug = require("./utils/debug");
 var import_clock = require("./clock");
 var import_debugger = require("./debugger");
 var import_dialog = require("./dialog");
 var import_fetch = require("./fetch");
-var import_fileUtils = require("./utils/fileUtils");
 var import_stackTrace = require("../utils/isomorphic/stackTrace");
 var import_harRecorder = require("./har/harRecorder");
 var import_helper = require("./helper");
@@ -70,8 +69,9 @@ const BrowserContextEvent = {
   RequestFulfilled: "requestfulfilled",
   RequestContinued: "requestcontinued",
   BeforeClose: "beforeclose",
-  VideoStarted: "videostarted",
-  RecorderEvent: "recorderevent"
+  RecorderEvent: "recorderevent",
+  PageClosed: "pageclosed",
+  InternalFrameNavigatedToNewDocument: "internalframenavigatedtonewdocument"
 };
 class BrowserContext extends import_instrumentation.SdkObject {
   constructor(browser, options, browserContextId) {
@@ -113,18 +113,22 @@ class BrowserContext extends import_instrumentation.SdkObject {
     if (this.attribution.playwright.options.isInternalPlaywright)
       return;
     this._debugger = new import_debugger.Debugger(this);
-    if ((0, import_debug.debugMode)() === "inspector")
+    const shouldEnableDebugger = !this.attribution.playwright.options.isServer && ((0, import_debug.isUnderTest)() || !!this._browser.options.headful);
+    if (shouldEnableDebugger) {
+      this._debugger.setPauseAt();
+      this._debugger.on(import_debugger.Debugger.Events.PausedStateChanged, () => {
+        if (this._debugger.isPaused())
+          import_recorderApp.RecorderApp.showInspectorNoReply(this);
+      });
+    }
+    if ((0, import_debug.debugMode)() === "inspector") {
+      this._debugger.setPauseAt({ next: true });
       await import_recorderApp.RecorderApp.show(this, { pauseOnNextStatement: true });
-    if (this._debugger.isPaused())
-      import_recorderApp.RecorderApp.showInspectorNoReply(this);
-    this._debugger.on(import_debugger.Debugger.Events.PausedStateChanged, () => {
-      if (this._debugger.isPaused())
-        import_recorderApp.RecorderApp.showInspectorNoReply(this);
-    });
+    }
     if ((0, import_debug.debugMode)() === "console")
       await this.exposeConsoleApi();
     if (this._options.serviceWorkers === "block")
-      await this.addInitScript(void 0, `
+      await this.addInitScript(`
 if (navigator.serviceWorker) navigator.serviceWorker.register = async () => { console.warn('Service Worker registration blocked by Playwright'); };
 `);
     if (this._options.permissions)
@@ -142,10 +146,6 @@ if (navigator.serviceWorker) navigator.serviceWorker.register = async () => { co
       module.exports = { default: () => installConsoleApi };
     `);
   }
-  async _ensureVideosPath() {
-    if (this._options.recordVideo)
-      await (0, import_fileUtils.mkdirIfNeeded)(import_path.default.join(this._options.recordVideo.dir, "dummy"));
-  }
   canResetForReuse() {
     if (this._closedStatus !== "open")
       return false;
@@ -239,7 +239,7 @@ if (navigator.serviceWorker) navigator.serviceWorker.register = async () => { co
   async exposePlaywrightBindingIfNeeded() {
     this._playwrightBindingExposed ??= (async () => {
       await this.doExposePlaywrightBinding();
-      this.bindingsInitScript = import_page2.PageBinding.createInitScript();
+      this.bindingsInitScript = import_page2.PageBinding.createInitScript(this);
       this.initScripts.push(this.bindingsInitScript);
       await this.doAddInitScript(this.bindingsInitScript);
       await this.safeNonStallingEvaluateInAllFrames(this.bindingsInitScript.source, "main");
@@ -257,7 +257,7 @@ if (navigator.serviceWorker) navigator.serviceWorker.register = async () => { co
         throw new Error(`Function "${name}" has been already registered in one of the pages`);
     }
     await progress.race(this.exposePlaywrightBindingIfNeeded());
-    const binding = new import_page2.PageBinding(name, playwrightBinding, needsHandle);
+    const binding = new import_page2.PageBinding(this, name, playwrightBinding, needsHandle);
     binding.forClient = forClient;
     this._pageBindings.set(name, binding);
     try {
@@ -269,13 +269,12 @@ if (navigator.serviceWorker) navigator.serviceWorker.register = async () => { co
       throw error;
     }
   }
-  async removeExposedBindings(bindings) {
-    bindings = bindings.filter((binding) => this._pageBindings.get(binding.name) === binding);
-    for (const binding of bindings)
-      this._pageBindings.delete(binding.name);
-    await this.doRemoveInitScripts(bindings.map((binding) => binding.initScript));
-    const cleanup = bindings.map((binding) => `{ ${binding.cleanupScript} };
-`).join("");
+  async removeExposedBinding(binding) {
+    if (this._pageBindings.get(binding.name) !== binding)
+      return;
+    this._pageBindings.delete(binding.name);
+    await this.doRemoveInitScripts([binding.initScript]);
+    const cleanup = `{ ${binding.cleanupScript} };`;
     await this.safeNonStallingEvaluateInAllFrames(cleanup, "main");
   }
   async grantPermissions(permissions, origin) {
@@ -362,26 +361,21 @@ if (navigator.serviceWorker) navigator.serviceWorker.register = async () => { co
     if (username)
       this._options.httpCredentials = { username, password: password || "" };
   }
-  async addInitScript(progress, source) {
-    const initScript = new import_page.InitScript(source);
+  async addInitScript(source) {
+    const initScript = new import_page.InitScript(this, source);
     this.initScripts.push(initScript);
     try {
-      const promise = this.doAddInitScript(initScript);
-      if (progress)
-        await progress.race(promise);
-      else
-        await promise;
+      await this.doAddInitScript(initScript);
       return initScript;
     } catch (error) {
-      this.removeInitScripts([initScript]).catch(() => {
+      initScript.dispose().catch(() => {
       });
       throw error;
     }
   }
-  async removeInitScripts(initScripts) {
-    const set = new Set(initScripts);
-    this.initScripts = this.initScripts.filter((script) => !set.has(script));
-    await this.doRemoveInitScripts(initScripts);
+  async removeInitScript(initScript) {
+    this.initScripts = this.initScripts.filter((script) => initScript !== script);
+    await this.doRemoveInitScripts([initScript]);
   }
   async addRequestInterceptor(progress, handler) {
     this.requestInterceptors.push(handler);
@@ -417,16 +411,13 @@ if (navigator.serviceWorker) navigator.serviceWorker.register = async () => { co
       for (const harRecorder of this._harRecorders.values())
         await harRecorder.flush();
       await this.tracing.flush();
-      const promises = [];
-      for (const { context, artifact } of this._browser._idToVideo.values()) {
-        if (context === this)
-          promises.push(artifact.finishedPromise());
-      }
+      await Promise.all(this.pages().map((page) => page.screencast.handlePageOrContextClose()));
       if (this._customCloseHandler) {
         await this._customCloseHandler();
       } else {
         await this.doClose(options.reason);
       }
+      const promises = [];
       promises.push(this._deleteAllDownloads());
       promises.push(this._deleteAllTempDirs());
       await Promise.all(promises);
@@ -602,22 +593,6 @@ function validateBrowserContextOptions(options, browserOptions) {
     options.acceptDownloads = "internal-browser-default";
   if (!options.viewport && !options.noDefaultViewport)
     options.viewport = { width: 1280, height: 720 };
-  if (options.recordVideo) {
-    if (!options.recordVideo.size) {
-      if (options.noDefaultViewport) {
-        options.recordVideo.size = { width: 800, height: 600 };
-      } else {
-        const size = options.viewport;
-        const scale = Math.min(1, 800 / Math.max(size.width, size.height));
-        options.recordVideo.size = {
-          width: Math.floor(size.width * scale),
-          height: Math.floor(size.height * scale)
-        };
-      }
-    }
-    options.recordVideo.size.width &= ~1;
-    options.recordVideo.size.height &= ~1;
-  }
   if (options.proxy)
     options.proxy = normalizeProxySettings(options.proxy);
   verifyGeolocation(options.geolocation);
@@ -669,6 +644,69 @@ function normalizeProxySettings(proxy) {
     bypass = bypass.split(",").map((t) => t.trim()).join(",");
   return { ...proxy, server, bypass };
 }
+function calculateUserAgentEmulation(options) {
+  const ua = options.userAgent;
+  if (!ua)
+    return { navigatorPlatform: void 0, userAgentMetadata: void 0 };
+  const userAgentMetadata = {
+    mobile: !!options.isMobile,
+    model: "",
+    architecture: "x86",
+    platform: "Windows",
+    platformVersion: ""
+  };
+  const androidMatch = ua.match(/Android (\d+(\.\d+)?(\.\d+)?)/);
+  const iPhoneMatch = ua.match(/iPhone OS (\d+(_\d+)?)/);
+  const iPadMatch = ua.match(/iPad; CPU OS (\d+(_\d+)?)/);
+  const macOSMatch = ua.match(/Mac OS X (\d+(_\d+)?(_\d+)?)/);
+  const windowsMatch = ua.match(/Windows\D+(\d+(\.\d+)?(\.\d+)?)/);
+  if (androidMatch) {
+    userAgentMetadata.platform = "Android";
+    userAgentMetadata.platformVersion = androidMatch[1];
+    userAgentMetadata.architecture = "arm";
+  } else if (iPhoneMatch) {
+    userAgentMetadata.platform = "iOS";
+    userAgentMetadata.platformVersion = iPhoneMatch[1].replace(/_/g, ".");
+    userAgentMetadata.architecture = "arm";
+  } else if (iPadMatch) {
+    userAgentMetadata.platform = "iOS";
+    userAgentMetadata.platformVersion = iPadMatch[1].replace(/_/g, ".");
+    userAgentMetadata.architecture = "arm";
+  } else if (macOSMatch) {
+    userAgentMetadata.platform = "macOS";
+    userAgentMetadata.platformVersion = macOSMatch[1].replace(/_/g, ".");
+    if (!ua.includes("Intel"))
+      userAgentMetadata.architecture = "arm";
+  } else if (windowsMatch) {
+    userAgentMetadata.platform = "Windows";
+    userAgentMetadata.platformVersion = windowsMatch[1];
+  } else if (ua.toLowerCase().includes("linux")) {
+    userAgentMetadata.platform = "Linux";
+  }
+  if (ua.includes("ARM") || ua.includes("aarch64"))
+    userAgentMetadata.architecture = "arm";
+  let navigatorPlatform;
+  if (!process.env.PLAYWRIGHT_NO_UA_PLATFORM) {
+    switch (userAgentMetadata.platform) {
+      case "Android":
+        navigatorPlatform = userAgentMetadata.architecture === "arm" ? "Linux armv8l" : "Linux x86_64";
+        break;
+      case "iOS":
+        navigatorPlatform = ua.includes("iPad") ? "iPad" : "iPhone";
+        break;
+      case "macOS":
+        navigatorPlatform = "MacIntel";
+        break;
+      case "Linux":
+        navigatorPlatform = userAgentMetadata.architecture === "arm" ? "Linux aarch64" : "Linux x86_64";
+        break;
+      case "Windows":
+        navigatorPlatform = "Win32";
+        break;
+    }
+  }
+  return { navigatorPlatform, userAgentMetadata };
+}
 const paramsThatAllowContextReuse = [
   "colorScheme",
   "forcedColors",
@@ -695,6 +733,7 @@ const defaultNewContextParamValues = {
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
   BrowserContext,
+  calculateUserAgentEmulation,
   normalizeProxySettings,
   validateBrowserContextOptions,
   verifyClientCertificates,

package/lib/server/browserType.js

@@ -59,7 +59,7 @@ class BrowserType extends import_instrumentation.SdkObject {
     this.logName = "browser";
   }
   executablePath() {
-    return import_registry.registry.findExecutable(this._name).executablePath(this.attribution.playwright.options.sdkLanguage) || "";
+    return import_registry.registry.findExecutable(this._name).executablePath() || "";
   }
   name() {
     return this._name;
@@ -115,7 +115,7 @@ class BrowserType extends import_instrumentation.SdkObject {
         await progress.race(options.__testHookBeforeCreateBrowser());
       const browserOptions = {
         name: this._name,
-        isChromium: this._name === "chromium",
+        browserType: this._name,
         channel: options.channel,
         slowMo: options.slowMo,
         persistent,
@@ -129,7 +129,8 @@ class BrowserType extends import_instrumentation.SdkObject {
         protocolLogger,
         browserLogsCollector,
         wsEndpoint: transport instanceof import_transport.WebSocketTransport ? transport.wsEndpoint : void 0,
-        originalLaunchOptions: options
+        originalLaunchOptions: options,
+        userDataDir: persistent ? userDataDir : void 0
       };
       if (persistent)
         (0, import_browserContext.validateBrowserContextOptions)(persistent, browserOptions);
@@ -152,10 +153,14 @@ class BrowserType extends import_instrumentation.SdkObject {
       args = [],
       executablePath = null
     } = options;
-    await this._createArtifactDirs(options);
     const tempDirectories = [];
-    const artifactsDir = await import_fs.default.promises.mkdtemp(import_path.default.join(import_os.default.tmpdir(), "playwright-artifacts-"));
-    tempDirectories.push(artifactsDir);
+    let artifactsDir;
+    if (options.artifactsDir) {
+      artifactsDir = options.artifactsDir;
+    } else {
+      artifactsDir = await import_fs.default.promises.mkdtemp(import_path.default.join(import_os.default.tmpdir(), "playwright-artifacts-"));
+      tempDirectories.push(artifactsDir);
+    }
     if (userDataDir) {
       (0, import_assert.assert)(import_path.default.isAbsolute(userDataDir), "userDataDir must be an absolute path");
       if (!await (0, import_fileUtils.existsAsync)(userDataDir))
@@ -270,15 +275,12 @@ ${updatedLog}`);
       throw error;
     }
   }
-  async _createArtifactDirs(options) {
-    if (options.downloadsPath)
-      await import_fs.default.promises.mkdir(options.downloadsPath, { recursive: true });
-    if (options.tracesDir)
-      await import_fs.default.promises.mkdir(options.tracesDir, { recursive: true });
-  }
   async connectOverCDP(progress, endpointURL, options) {
     throw new Error("CDP connections are only supported by Chromium");
   }
+  async connectOverCDPTransport(progress, transport) {
+    throw new Error("CDP connections are only supported by Chromium");
+  }
   async _launchWithSeleniumHub(progress, hubUrl, options) {
     throw new Error("Connecting to SELENIUM_REMOTE_URL is only supported by Chromium");
   }

package/lib/server/chromium/chromium.js

@@ -82,6 +82,12 @@ class Chromium extends import_browserType.BrowserType {
       headersMap = { "User-Agent": (0, import_userAgent.getUserAgent)() };
     else if (headersMap && !Object.keys(headersMap).some((key) => key.toLowerCase() === "user-agent"))
       headersMap["User-Agent"] = (0, import_userAgent.getUserAgent)();
+    const wsEndpoint = await urlToWSEndpoint(progress, endpointURL, headersMap);
+    const chromeTransport = await import_transport.WebSocketTransport.connect(progress, wsEndpoint, { headers: headersMap, followRedirects: true, debugLogHeader: "x-playwright-debug-log" });
+    const closeAndWait = async () => await chromeTransport.closeAndWait();
+    return this._connectOverCDPImpl(progress, chromeTransport, closeAndWait, options, onClose);
+  }
+  async _connectOverCDPImpl(progress, transport, closeAndWait, options, onClose) {
     const artifactsDir = await progress.race(import_fs.default.promises.mkdtemp(ARTIFACTS_FOLDER));
     const doCleanup = async () => {
       await (0, import_fileUtils.removeFolders)([artifactsDir]);
@@ -89,20 +95,17 @@ class Chromium extends import_browserType.BrowserType {
       onClose = void 0;
       await cb?.();
     };
-    let chromeTransport;
     const doClose = async () => {
-      await chromeTransport?.closeAndWait();
+      await closeAndWait();
       await doCleanup();
     };
     try {
-      const wsEndpoint = await urlToWSEndpoint(progress, endpointURL, headersMap);
-      chromeTransport = await import_transport.WebSocketTransport.connect(progress, wsEndpoint, { headers: headersMap });
       const browserProcess = { close: doClose, kill: doClose };
       const persistent = { noDefaultViewport: true };
       const browserOptions = {
         slowMo: options.slowMo,
         name: "chromium",
-        isChromium: true,
+        browserType: "chromium",
         persistent,
         browserProcess,
         protocolLogger: import_helper.helper.debugProtocolLogger(),
@@ -113,7 +116,7 @@ class Chromium extends import_browserType.BrowserType {
         originalLaunchOptions: {}
       };
       (0, import_browserContext.validateBrowserContextOptions)(persistent, browserOptions);
-      const browser = await progress.race(import_crBrowser.CRBrowser.connect(this.attribution.playwright, chromeTransport, browserOptions));
+      const browser = await progress.race(import_crBrowser.CRBrowser.connect(this.attribution.playwright, transport, browserOptions));
       if (!options.isLocal)
         browser._isCollocatedWithServer = false;
       browser.on(import_browser.Browser.Events.Disconnected, doCleanup);
@@ -124,6 +127,10 @@ class Chromium extends import_browserType.BrowserType {
       throw error;
     }
   }
+  async connectOverCDPTransport(progress, transport) {
+    const closeAndWait = async () => transport.close();
+    return this._connectOverCDPImpl(progress, transport, closeAndWait, { isLocal: true });
+  }
   _createDevTools() {
     const directory = import_registry.registry.findExecutable("chromium").directory;
     return directory ? new import_crDevTools.CRDevTools(import_path.default.join(directory, "devtools-preferences.json")) : void 0;
@@ -163,7 +170,6 @@ class Chromium extends import_browserType.BrowserType {
     transport.send(message);
   }
   async _launchWithSeleniumHub(progress, hubUrl, options) {
-    await progress.race(this._createArtifactDirs(options));
     if (!hubUrl.endsWith("/"))
       hubUrl = hubUrl + "/";
     const args = this._innerDefaultArgs(options);
@@ -277,9 +283,7 @@ class Chromium extends import_browserType.BrowserType {
     if (args.find((arg) => !arg.startsWith("-")))
       throw new Error("Arguments can not specify page to be opened");
     const chromeArguments = [...(0, import_chromiumSwitches.chromiumSwitches)(options.assistantMode, options.channel)];
-    if (import_os.default.platform() !== "darwin" || !(0, import_utils.hasGpuMac)()) {
-      chromeArguments.push("--enable-unsafe-swiftshader");
-    }
+    chromeArguments.push("--enable-unsafe-swiftshader");
     if (options.headless) {
       chromeArguments.push("--headless");
       chromeArguments.push(
@@ -299,11 +303,9 @@ class Chromium extends import_browserType.BrowserType {
       }
       chromeArguments.push(`--proxy-server=${proxy.server}`);
       const proxyBypassRules = [];
-      if (options.socksProxyPort)
-        proxyBypassRules.push("<-loopback>");
       if (proxy.bypass)
         proxyBypassRules.push(...proxy.bypass.split(",").map((t) => t.trim()).map((t) => t.startsWith(".") ? "*" + t : t));
-      if (!process.env.PLAYWRIGHT_DISABLE_FORCED_CHROMIUM_PROXIED_LOOPBACK && !proxyBypassRules.includes("<-loopback>"))
+      if (options.socksProxyPort || (0, import_crBrowser.shouldProxyLoopback)(proxy.bypass))
         proxyBypassRules.push("<-loopback>");
       if (proxyBypassRules.length > 0)
         chromeArguments.push(`--proxy-bypass-list=${proxyBypassRules.join(";")}`);

package/lib/server/chromium/crBrowser.js

@@ -29,7 +29,8 @@ var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: tru
 var crBrowser_exports = {};
 __export(crBrowser_exports, {
   CRBrowser: () => CRBrowser,
-  CRBrowserContext: () => CRBrowserContext
+  CRBrowserContext: () => CRBrowserContext,
+  shouldProxyLoopback: () => shouldProxyLoopback
 });
 module.exports = __toCommonJS(crBrowser_exports);
 var import_path = __toESM(require("path"));
@@ -54,6 +55,7 @@ class CRBrowser extends import_browser.Browser {
     this._serviceWorkers = /* @__PURE__ */ new Map();
     this._version = "";
     this._majorVersion = 0;
+    this._revision = "";
     this._tracingRecording = false;
     this._userAgent = "";
     this._connection = connection;
@@ -75,6 +77,7 @@ class CRBrowser extends import_browser.Browser {
     if (options.__testHookOnConnectToBrowser)
       await options.__testHookOnConnectToBrowser();
     const version = await session.send("Browser.getVersion");
+    browser._revision = version.revision;
     browser._version = version.product.substring(version.product.indexOf("/") + 1);
     try {
       browser._majorVersion = +browser._version.split(".")[0];
@@ -100,10 +103,10 @@ class CRBrowser extends import_browser.Browser {
     const proxy = options.proxyOverride || options.proxy;
     let proxyBypassList = void 0;
     if (proxy) {
-      if (process.env.PLAYWRIGHT_DISABLE_FORCED_CHROMIUM_PROXIED_LOOPBACK)
-        proxyBypassList = proxy.bypass;
-      else
+      if (shouldProxyLoopback(proxy.bypass))
         proxyBypassList = "<-loopback>" + (proxy.bypass ? `,${proxy.bypass}` : "");
+      else
+        proxyBypassList = proxy.bypass;
     }
     const { browserContextId } = await this._session.send("Target.createBrowserContext", {
       disposeOnDetach: true,
@@ -389,7 +392,8 @@ class CRBrowserContext extends import_browserContext.BrowserContext {
       ["midi-sysex", "midiSysex"],
       ["storage-access", "storageAccess"],
       ["local-fonts", "localFonts"],
-      ["local-network-access", ["localNetworkAccess", "localNetwork", "loopbackNetwork"]]
+      ["local-network-access", ["localNetworkAccess", "localNetwork", "loopbackNetwork"]],
+      ["screen-wake-lock", "wakeLockScreen"]
     ]);
     const grantPermissions = async (mapping) => {
       const filtered = permissions.flatMap((permission) => {
@@ -466,7 +470,6 @@ class CRBrowserContext extends import_browserContext.BrowserContext {
   async doClose(reason) {
     await this.dialogManager.closeBeforeUnloadDialogs();
     if (!this._browserContextId) {
-      await this.stopVideoRecording();
       await this._browser.close({ reason });
       return;
     }
@@ -479,9 +482,6 @@ class CRBrowserContext extends import_browserContext.BrowserContext {
       this._browser._serviceWorkers.delete(targetId);
     }
   }
-  async stopVideoRecording() {
-    await Promise.all(this._crPages().map((crPage) => crPage._page.screencast.stopVideoRecording()));
-  }
   onClosePersistent() {
   }
   async clearCache() {
@@ -513,8 +513,16 @@ class CRBrowserContext extends import_browserContext.BrowserContext {
     return rootSession.attachToTarget(targetId);
   }
 }
+function shouldProxyLoopback(bypass) {
+  if (process.env.PLAYWRIGHT_DISABLE_FORCED_CHROMIUM_PROXIED_LOOPBACK)
+    return false;
+  const hosts = (bypass || "").split(",").map((s) => s.trim());
+  const shouldBypassSomeLoopback = ["localhost", "127.0.0.1", "::1", "[::]", "[::1]", "<loopback>", "<-loopback>"].some((host) => hosts.includes(host));
+  return !shouldBypassSomeLoopback;
+}
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
   CRBrowser,
-  CRBrowserContext
+  CRBrowserContext,
+  shouldProxyLoopback
 });

package/lib/server/chromium/crNetworkManager.js

@@ -239,7 +239,7 @@ class CRNetworkManager {
       this._requestIdToRequestWillBeSentEvent.delete(requestId);
     } else {
       const existingRequest = this._requestIdToRequest.get(requestId);
-      const alreadyContinuedParams = existingRequest?._route?._alreadyContinuedParams;
+      const alreadyContinuedParams = existingRequest?._originalRequestRoute?._alreadyContinuedParams;
       if (alreadyContinuedParams && !event.redirectedRequestId) {
         sessionInfo.session._sendMayFail("Fetch.continueRequest", {
           ...alreadyContinuedParams,
@@ -333,7 +333,7 @@ class CRNetworkManager {
       const response2 = await session.send("Network.getResponseBody", { requestId: request._requestId });
       if (response2.body || !expectedLength)
         return Buffer.from(response2.body, response2.base64Encoded ? "base64" : "utf8");
-      if (request._route?._fulfilled)
+      if (request._originalRequestRoute?._fulfilled)
         return Buffer.from("");
       const resource = await session.send("Network.loadNetworkResource", { url: request.request.url(), frameId: this._serviceWorker ? void 0 : request.request.frame()._id, options: { disableCache: false, includeCredentials: true } });
       const chunks = [];
@@ -372,7 +372,8 @@ class CRNetworkManager {
         responseStart: -1
       };
     }
-    const response = new network.Response(request.request, responsePayload.status, responsePayload.statusText, (0, import_utils.headersObjectToArray)(responsePayload.headers), timing, getResponseBody, !!responsePayload.fromServiceWorker, responsePayload.protocol);
+    const response = new network.Response(request.request, responsePayload.status, responsePayload.statusText, (0, import_utils.headersObjectToArray)(responsePayload.headers), timing, getResponseBody, !!responsePayload.fromServiceWorker);
+    response._setHttpVersion(responsePayload?.protocol ?? null);
     if (responsePayload?.remoteIPAddress && typeof responsePayload?.remotePort === "number") {
       response._serverAddrFinished({
         ipAddress: responsePayload.remoteIPAddress,
@@ -478,7 +479,6 @@ class InterceptableRequest {
     this._requestId = requestWillBeSentEvent.requestId;
     this._interceptionId = requestPausedEvent && requestPausedEvent.requestId;
     this._documentId = documentId;
-    this._route = route;
     this._originalRequestRoute = route ?? redirectedFrom?._originalRequestRoute;
     const {
       headers,