patchright-core 1.57.0 → 1.58.2

package/lib/server/browserContext.js

@@ -55,6 +55,24 @@ var import_recorderApp = require("./recorder/recorderApp");
 var import_selectors = require("./selectors");
 var import_tracing = require("./trace/recorder/tracing");
 var rawStorageSource = __toESM(require("../generated/storageScriptSource"));
+const BrowserContextEvent = {
+  Console: "console",
+  Close: "close",
+  Page: "page",
+  // Can't use just 'error' due to node.js special treatment of error events.
+  // @see https://nodejs.org/api/events.html#events_error_events
+  PageError: "pageerror",
+  Request: "request",
+  Response: "response",
+  RequestFailed: "requestfailed",
+  RequestFinished: "requestfinished",
+  RequestAborted: "requestaborted",
+  RequestFulfilled: "requestfulfilled",
+  RequestContinued: "requestcontinued",
+  BeforeClose: "beforeclose",
+  VideoStarted: "videostarted",
+  RecorderEvent: "recorderevent"
+};
 class BrowserContext extends import_instrumentation.SdkObject {
   constructor(browser, options, browserContextId) {
     super(browser, "browser-context");
@@ -69,6 +87,7 @@ class BrowserContext extends import_instrumentation.SdkObject {
     this._creatingStorageStatePage = false;
     this.initScripts = [];
     this._routesInFlight = /* @__PURE__ */ new Set();
+    this._consoleApiExposed = false;
     this.attribution.context = this;
     this._browser = browser;
     this._options = options;
@@ -82,24 +101,7 @@ class BrowserContext extends import_instrumentation.SdkObject {
     this.dialogManager = new import_dialog.DialogManager(this.instrumentation);
   }
   static {
-    this.Events = {
-      Console: "console",
-      Close: "close",
-      Page: "page",
-      // Can't use just 'error' due to node.js special treatment of error events.
-      // @see https://nodejs.org/api/events.html#events_error_events
-      PageError: "pageerror",
-      Request: "request",
-      Response: "response",
-      RequestFailed: "requestfailed",
-      RequestFinished: "requestfinished",
-      RequestAborted: "requestaborted",
-      RequestFulfilled: "requestfulfilled",
-      RequestContinued: "requestcontinued",
-      BeforeClose: "beforeclose",
-      VideoStarted: "videostarted",
-      RecorderEvent: "recorderevent"
-    };
+    this.Events = BrowserContextEvent;
   }
   isPersistentContext() {
     return this._isPersistentContext;
@@ -119,12 +121,8 @@ class BrowserContext extends import_instrumentation.SdkObject {
       if (this._debugger.isPaused())
         import_recorderApp.RecorderApp.showInspectorNoReply(this);
     });
-    if ((0, import_debug.debugMode)() === "console") {
-      await this.extendInjectedScript(`
-        function installConsoleApi(injectedScript) { injectedScript.consoleApi.install(); }
-        module.exports = { default: () => installConsoleApi };
-      `);
-    }
+    if ((0, import_debug.debugMode)() === "console")
+      await this.exposeConsoleApi();
     if (this._options.serviceWorkers === "block")
       await this.addInitScript(void 0, `navigator.serviceWorker.register = async () => { };`);
     if (this._options.permissions)
@@ -133,6 +131,15 @@ class BrowserContext extends import_instrumentation.SdkObject {
   debugger() {
     return this._debugger;
   }
+  async exposeConsoleApi() {
+    if (this._consoleApiExposed)
+      return;
+    this._consoleApiExposed = true;
+    await this.extendInjectedScript(`
+      function installConsoleApi(injectedScript) { injectedScript.consoleApi.install(); }
+      module.exports = { default: () => installConsoleApi };
+    `);
+  }
   async _ensureVideosPath() {
     if (this._options.recordVideo)
       await (0, import_fileUtils.mkdirIfNeeded)(import_path.default.join(this._options.recordVideo.dir, "dummy"));
@@ -309,7 +316,7 @@ class BrowserContext extends import_instrumentation.SdkObject {
     const pageOrError = await progress.race(page.waitForInitializedOrError());
     if (pageOrError instanceof Error)
       throw pageOrError;
-    await page.mainFrame()._waitForLoadState(progress, "load");
+    await page.mainFrame().waitForLoadState(progress, "load");
     return page;
   }
   async _loadDefaultContext(progress) {
@@ -669,7 +676,8 @@ const defaultNewContextParamValues = {
   acceptDownloads: "accept",
   strictSelectors: false,
   serviceWorkers: "allow",
-  locale: "en-US"
+  locale: "en-US",
+  focusControl: false
 };
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {

package/lib/server/browserType.js

@@ -250,6 +250,13 @@ class BrowserType extends import_instrumentation.SdkObject {
         this.waitForReadyState(options, browserLogsCollector),
         exitPromise.then(() => ({ wsEndpoint: void 0 }))
       ]);
+      if (exitPromise.isDone()) {
+        const log = import_helper.helper.formatBrowserLogs(browserLogsCollector.recentLogs());
+        const updatedLog = this.doRewriteStartupLog(log);
+        throw new Error(`Failed to launch the browser process.
+Browser logs:
+${updatedLog}`);
+      }
       if (options.cdpPort !== void 0 || !this.supportsPipeTransport()) {
         transport = await import_transport.WebSocketTransport.connect(progress, wsEndpoint);
       } else {
@@ -276,15 +283,14 @@ class BrowserType extends import_instrumentation.SdkObject {
     throw new Error("Connecting to SELENIUM_REMOTE_URL is only supported by Chromium");
   }
   _validateLaunchOptions(options) {
-    const { devtools = false } = options;
-    let { headless = !devtools, downloadsPath, proxy } = options;
+    let { headless = true, downloadsPath, proxy } = options;
     if ((0, import_debug.debugMode)() === "inspector")
       headless = false;
     if (downloadsPath && !import_path.default.isAbsolute(downloadsPath))
       downloadsPath = import_path.default.join(process.cwd(), downloadsPath);
     if (options.socksProxyPort)
       proxy = { server: `socks5://127.0.0.1:${options.socksProxyPort}` };
-    return { ...options, devtools, headless, downloadsPath, proxy };
+    return { ...options, headless, downloadsPath, proxy };
   }
   _createUserDataDirArgMisuseError(userDataDirArg) {
     switch (this.attribution.playwright.options.sdkLanguage) {
@@ -301,7 +307,9 @@ class BrowserType extends import_instrumentation.SdkObject {
   _rewriteStartupLog(error) {
     if (!(0, import_protocolError.isProtocolError)(error))
       return error;
-    return this.doRewriteStartupLog(error);
+    if (error.logs)
+      error.logs = this.doRewriteStartupLog(error.logs);
+    return error;
   }
   async waitForReadyState(options, browserLogsCollector) {
     return {};

package/lib/server/chromium/chromium.js

@@ -114,7 +114,8 @@ class Chromium extends import_browserType.BrowserType {
       };
       (0, import_browserContext.validateBrowserContextOptions)(persistent, browserOptions);
       const browser = await progress.race(import_crBrowser.CRBrowser.connect(this.attribution.playwright, chromeTransport, browserOptions));
-      browser._isCollocatedWithServer = false;
+      if (!options.isLocal)
+        browser._isCollocatedWithServer = false;
       browser.on(import_browser.Browser.Events.Disconnected, doCleanup);
       return browser;
     } catch (error) {
@@ -128,13 +129,8 @@ class Chromium extends import_browserType.BrowserType {
     return directory ? new import_crDevTools.CRDevTools(import_path.default.join(directory, "devtools-preferences.json")) : void 0;
   }
   async connectToTransport(transport, options, browserLogsCollector) {
-    let devtools = this._devtools;
-    if (options.__testHookForDevTools) {
-      devtools = this._createDevTools();
-      await options.__testHookForDevTools(devtools);
-    }
     try {
-      return await import_crBrowser.CRBrowser.connect(this.attribution.playwright, transport, options, devtools);
+      return await import_crBrowser.CRBrowser.connect(this.attribution.playwright, transport, options, this._devtools);
     } catch (e) {
       if (browserLogsCollector.recentLogs().some((log) => log.includes("Failed to create a ProcessSingleton for your profile directory."))) {
         throw new Error(
@@ -144,14 +140,12 @@ class Chromium extends import_browserType.BrowserType {
       throw e;
     }
   }
-  doRewriteStartupLog(error) {
-    if (!error.logs)
-      return error;
-    if (error.logs.includes("Missing X server"))
-      error.logs = "\n" + (0, import_ascii.wrapInASCIIBox)(import_browserType.kNoXServerRunningError, 1);
-    if (!error.logs.includes("crbug.com/357670") && !error.logs.includes("No usable sandbox!") && !error.logs.includes("crbug.com/638180"))
-      return error;
-    error.logs = [
+  doRewriteStartupLog(logs) {
+    if (logs.includes("Missing X server"))
+      logs = "\n" + (0, import_ascii.wrapInASCIIBox)(import_browserType.kNoXServerRunningError, 1);
+    if (!logs.includes("crbug.com/357670") && !logs.includes("No usable sandbox!") && !logs.includes("crbug.com/638180"))
+      return logs;
+    return [
       `Chromium sandboxing failed!`,
       `================================`,
       `To avoid the sandboxing issue, do either of the following:`,
@@ -160,7 +154,6 @@ class Chromium extends import_browserType.BrowserType {
       `================================`,
       ``
     ].join("\n");
-    return error;
   }
   amendEnvironment(env) {
     return env;
@@ -284,11 +277,8 @@ 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") {
-      chromeArguments.push("--enable-unsafe-swiftshader");
+    if (import_os.default.platform() !== "darwin" || !(0, import_utils.hasGpuMac)()) {
     }
-    if (options.devtools)
-      chromeArguments.push("--auto-open-devtools-for-tabs");
     if (options.headless) {
       chromeArguments.push("--headless");
       chromeArguments.push(
@@ -324,6 +314,10 @@ class Chromium extends import_browserType.BrowserType {
     return waitForReadyState(options, browserLogsCollector);
   }
   getExecutableName(options) {
+    if (options.channel && import_registry.registry.isChromiumAlias(options.channel))
+      return "chromium";
+    if (options.channel === "chromium-tip-of-tree")
+      return options.headless ? "chromium-tip-of-tree-headless-shell" : "chromium-tip-of-tree";
     if (options.channel)
       return options.channel;
     return options.headless ? "chromium-headless-shell" : "chromium";

package/lib/server/chromium/chromiumSwitches.js

@@ -22,10 +22,10 @@ __export(chromiumSwitches_exports, {
 });
 module.exports = __toCommonJS(chromiumSwitches_exports);
 const disabledFeatures = (assistantMode) => [
-  // See https://github.com/microsoft/playwright/pull/10380
-  "AcceptCHFrame",
   // See https://github.com/microsoft/playwright/issues/14047
   "AvoidUnnecessaryBeforeUnloadCheckSync",
+  // See https://github.com/microsoft/playwright/issues/38568
+  "BoundaryEventDispatchTracksNodeRemoval",
   "DestroyProfileOnBrowserClose",
   // See https://github.com/microsoft/playwright/pull/13854
   "DialMediaRouteProvider",

package/lib/server/chromium/crBrowser.js

@@ -284,11 +284,12 @@ class CRBrowser extends import_browser.Browser {
     return this._clientRootSessionPromise;
   }
 }
+const CREvents = {
+  ServiceWorker: "serviceworker"
+};
 class CRBrowserContext extends import_browserContext.BrowserContext {
   static {
-    this.CREvents = {
-      ServiceWorker: "serviceworker"
-    };
+    this.CREvents = CREvents;
   }
   constructor(browser, browserContextId, options) {
     super(browser, options, browserContextId);
@@ -388,15 +389,24 @@ class CRBrowserContext extends import_browserContext.BrowserContext {
       ["midi-sysex", "midiSysex"],
       ["storage-access", "storageAccess"],
       ["local-fonts", "localFonts"],
-      ["local-network-access", "localNetworkAccess"]
+      ["local-network-access", ["localNetworkAccess", "localNetwork", "loopbackNetwork"]]
     ]);
-    const filtered = permissions.map((permission) => {
-      const protocolPermission = webPermissionToProtocol.get(permission);
-      if (!protocolPermission)
-        throw new Error("Unknown permission: " + permission);
-      return protocolPermission;
-    });
-    await this._browser._session.send("Browser.grantPermissions", { origin: origin === "*" ? void 0 : origin, browserContextId: this._browserContextId, permissions: filtered });
+    const grantPermissions = async (mapping) => {
+      const filtered = permissions.flatMap((permission) => {
+        const protocolPermission = mapping.get(permission);
+        if (!protocolPermission)
+          throw new Error("Unknown permission: " + permission);
+        return typeof protocolPermission === "string" ? [protocolPermission] : protocolPermission;
+      });
+      await this._browser._session.send("Browser.grantPermissions", { origin: origin === "*" ? void 0 : origin, browserContextId: this._browserContextId, permissions: filtered });
+    };
+    try {
+      await grantPermissions(webPermissionToProtocol);
+    } catch (e) {
+      const fallbackMapping = new Map(webPermissionToProtocol);
+      fallbackMapping.set("local-network-access", ["localNetworkAccess"]);
+      await grantPermissions(fallbackMapping);
+    }
   }
   async doClearPermissions() {
     await this._browser._session.send("Browser.resetPermissions", { browserContextId: this._browserContextId });
@@ -469,7 +479,7 @@ class CRBrowserContext extends import_browserContext.BrowserContext {
     }
   }
   async stopVideoRecording() {
-    await Promise.all(this._crPages().map((crPage) => crPage._mainFrameSession._stopVideoRecording()));
+    await Promise.all(this._crPages().map((crPage) => crPage._page.screencast.stopVideoRecording()));
   }
   onClosePersistent() {
   }

package/lib/server/chromium/crConnection.js

@@ -94,11 +94,6 @@ class CRSession extends import_instrumentation.SdkObject {
     this._parentSession = parentSession;
     this._sessionId = sessionId;
     this._eventListener = eventListener;
-    this.on = super.on;
-    this.addListener = super.addListener;
-    this.off = super.removeListener;
-    this.removeListener = super.removeListener;
-    this.once = super.once;
   }
   _markAsCrashed() {
     this._crashed = true;

package/lib/server/chromium/crCoverage.js

@@ -66,6 +66,7 @@ class JSCoverage {
     this._eventListeners = [
       import_eventsHelper.eventsHelper.addEventListener(this._client, "Debugger.scriptParsed", this._onScriptParsed.bind(this)),
       import_eventsHelper.eventsHelper.addEventListener(this._client, "Runtime.executionContextsCleared", this._onExecutionContextsCleared.bind(this)),
+      import_eventsHelper.eventsHelper.addEventListener(this._client, "Page.frameNavigated", this._onFrameNavigated.bind(this)),
       import_eventsHelper.eventsHelper.addEventListener(this._client, "Debugger.paused", this._onDebuggerPaused.bind(this))
     ];
     await Promise.all([
@@ -117,6 +118,11 @@ class JSCoverage {
     }
     return coverage;
   }
+  _onFrameNavigated(event) {
+    if (event.frame.parentId)
+      return;
+    this._onExecutionContextsCleared();
+  }
 }
 class CSSCoverage {
   constructor(client) {
@@ -136,7 +142,8 @@ class CSSCoverage {
     this._stylesheetSources.clear();
     this._eventListeners = [
       import_eventsHelper.eventsHelper.addEventListener(this._client, "CSS.styleSheetAdded", this._onStyleSheet.bind(this)),
-      import_eventsHelper.eventsHelper.addEventListener(this._client, "Runtime.executionContextsCleared", this._onExecutionContextsCleared.bind(this))
+      import_eventsHelper.eventsHelper.addEventListener(this._client, "Runtime.executionContextsCleared", this._onExecutionContextsCleared.bind(this)),
+      import_eventsHelper.eventsHelper.addEventListener(this._client, "Page.frameNavigated", this._onFrameNavigated.bind(this))
     ];
     await Promise.all([
       this._client.send("DOM.enable"),
@@ -192,6 +199,11 @@ class CSSCoverage {
     }
     return coverage;
   }
+  _onFrameNavigated(event) {
+    if (event.frame.parentId)
+      return;
+    this._onExecutionContextsCleared();
+  }
 }
 function convertToDisjointRanges(nestedRanges) {
   const points = [];

package/lib/server/chromium/crDevTools.js

@@ -44,8 +44,6 @@ class CRDevTools {
         return;
       const parsed = JSON.parse(event.payload);
       let result = void 0;
-      if (this.__testHookOnBinding)
-        this.__testHookOnBinding(parsed);
       if (parsed.method === "getPreferences") {
         if (this._prefs === void 0) {
           try {

package/lib/server/chromium/crNetworkManager.js

@@ -141,6 +141,8 @@ class CRNetworkManager {
   async setRequestInterception(value) {
     this._userRequestInterceptionEnabled = value;
     await this._updateProtocolRequestInterception();
+    if (this._page)
+      await this._forEachSession((info) => info.session.send("Network.setCacheDisabled", { cacheDisabled: this._page.needsRequestInterception() }));
   }
   async _updateProtocolRequestInterception() {
     const enabled = this._userRequestInterceptionEnabled || !!this._credentials;
@@ -153,7 +155,9 @@ class CRNetworkManager {
     const enabled = this._protocolRequestInterceptionEnabled;
     if (initial && !enabled)
       return;
-    const cachePromise = info.session.send("Network.setCacheDisabled", { cacheDisabled: false });
+    const hasHarRecorders = !!this._page?.browserContext?._harRecorders?.size;
+    const userInterception = this._page ? this._page.needsRequestInterception() : false;
+    const cachePromise = info.session.send("Network.setCacheDisabled", { cacheDisabled: userInterception || hasHarRecorders });
     let fetchPromise = Promise.resolve(void 0);
     if (!info.workerFrame) {
       if (enabled)
@@ -265,13 +269,17 @@ class CRNetworkManager {
         redirectedFrom = request2;
       }
     }
+    const isInterceptedOptionsPreflight = !!requestPausedEvent && requestPausedEvent.request.method === "OPTIONS" && requestWillBeSentEvent.initiator.type === "preflight";
+    if (isInterceptedOptionsPreflight && !(this._page || this._serviceWorker).needsRequestInterception()) {
+      requestPausedSessionInfo.session._sendMayFail("Fetch.continueRequest", { requestId: requestPausedEvent.requestId });
+      return;
+    }
     let frame = requestWillBeSentEvent.frameId ? this._page?.frameManager.frame(requestWillBeSentEvent.frameId) : requestWillBeSentSessionInfo.workerFrame;
     if (!frame && this._page && requestPausedEvent && requestPausedEvent.frameId)
       frame = this._page.frameManager.frame(requestPausedEvent.frameId);
     if (!frame && this._page && requestWillBeSentEvent.frameId === (this._page?.delegate)._targetId) {
       frame = this._page.frameManager.frameAttached(requestWillBeSentEvent.frameId, null);
     }
-    const isInterceptedOptionsPreflight = !!requestPausedEvent && requestPausedEvent.request.method === "OPTIONS" && requestWillBeSentEvent.initiator.type === "preflight";
     if (isInterceptedOptionsPreflight && (this._page || this._serviceWorker).needsRequestInterception()) {
       const requestHeaders = requestPausedEvent.request.headers;
       const responseHeaders = [
@@ -300,6 +308,10 @@ class CRNetworkManager {
     if (requestPausedEvent) {
       if (redirectedFrom || !this._userRequestInterceptionEnabled && this._protocolRequestInterceptionEnabled) {
         headersOverride = redirectedFrom?._originalRequestRoute?._alreadyContinuedParams?.headers;
+        if (headersOverride) {
+          const originalHeaders = Object.entries(requestPausedEvent.request.headers).map(([name, value]) => ({ name, value }));
+          headersOverride = network.applyHeadersOverrides(originalHeaders, headersOverride);
+        }
         requestPausedSessionInfo.session._sendMayFail("Fetch.continueRequest", { requestId: requestPausedEvent.requestId, headers: headersOverride });
       } else {
         route = new RouteImpl(requestPausedSessionInfo.session, requestPausedEvent.requestId, this._page, requestPausedEvent.networkId, this);
@@ -486,12 +498,11 @@ class InterceptableRequest {
       url,
       postDataEntries = null
     } = requestPausedEvent ? requestPausedEvent.request : requestWillBeSentEvent.request;
-    const type = (requestWillBeSentEvent.type || "").toLowerCase();
     let postDataBuffer = null;
     const entries = postDataEntries?.filter((entry) => entry.bytes);
     if (entries && entries.length)
       postDataBuffer = Buffer.concat(entries.map((entry) => Buffer.from(entry.bytes, "base64")));
-    this.request = new network.Request(context, frame, serviceWorker, redirectedFrom?.request || null, documentId, url, type, method, postDataBuffer, headersOverride || (0, import_utils.headersObjectToArray)(headers));
+    this.request = new network.Request(context, frame, serviceWorker, redirectedFrom?.request || null, documentId, url, toResourceType(requestWillBeSentEvent.type || "Other"), method, postDataBuffer, headersOverride || (0, import_utils.headersObjectToArray)(headers));
   }
 }
 class RouteImpl {
@@ -528,11 +539,12 @@ class RouteImpl {
   }
   async fulfill(response) {
     const isTextHtml = response.headers.some((header) => header.name.toLowerCase() === "content-type" && header.value.includes("text/html"));
-    var allInjections = [...this._page.delegate._mainFrameSession._evaluateOnNewDocumentScripts];
-    for (const binding of this._page.delegate._browserContext._pageBindings.values()) {
-      if (!allInjections.includes(binding)) allInjections.push(binding);
-    }
-    if (isTextHtml && allInjections.length) {
+    const pageDelegate = this._page?.delegate || null;
+    const initScriptTag = pageDelegate?.initScriptTag || "";
+    let allInjections = [];
+    if (pageDelegate)
+      allInjections = [...pageDelegate._mainFrameSession._evaluateOnNewDocumentScripts];
+    if (isTextHtml && allInjections.length && initScriptTag) {
       let useNonce = false;
       let scriptNonce = null;
       if (response.isBase64) {
@@ -583,7 +595,7 @@ class RouteImpl {
         let scriptId = import_crypto.default.randomBytes(22).toString("hex");
         let scriptSource = script.source || script;
         const nonceAttr = useNonce ? `nonce="${scriptNonce}"` : "";
-        injectionHTML += `<script class="${this._page.delegate.initScriptTag}" ${nonceAttr} id="${scriptId}" type="text/javascript">document.getElementById("${scriptId}")?.remove();${scriptSource}</script>`;
+        injectionHTML += `<script class="${initScriptTag}" ${nonceAttr} id="${scriptId}" type="text/javascript">document.getElementById("${scriptId}")?.remove();${scriptSource}</script>`;
       });
       const lower = response.body.toLowerCase();
       const headStartIndex = lower.indexOf("<head");
@@ -593,7 +605,27 @@ class RouteImpl {
           const headOpenEnd = response.body.indexOf(">", headStartIndex) + 1;
           const headContent = response.body.slice(headOpenEnd, headEndTagIndex);
           const headContentLower = headContent.toLowerCase();
-          const firstScriptIndex = headContentLower.indexOf("<script");
+          let firstScriptIndex = -1;
+          let searchPos = 0;
+          const endSearchPos = headContentLower.length;
+          while (searchPos < endSearchPos) {
+            const commentStart = headContentLower.indexOf("<!--", searchPos);
+            const scriptStart = headContentLower.indexOf("<script", searchPos);
+            if (scriptStart === -1 || scriptStart >= endSearchPos) {
+              break;
+            }
+            if (commentStart !== -1 && commentStart < scriptStart) {
+              const commentEnd = headContentLower.indexOf("-->", commentStart);
+              if (commentEnd !== -1) {
+                searchPos = commentEnd + 3;
+                continue;
+              } else {
+                break;
+              }
+            }
+            firstScriptIndex = scriptStart;
+            break;
+          }
           if (firstScriptIndex !== -1) {
             const insertPosition = headOpenEnd + firstScriptIndex;
             response.body = response.body.slice(0, insertPosition) + injectionHTML + response.body.slice(insertPosition);
@@ -731,6 +763,12 @@ class RouteImpl {
     }
     if (this._networkId != event.networkId || !this._sessionManager._alreadyTrackedNetworkIds.has(event.networkId)) return;
     try {
+      const url = event.request?.url || "";
+      const isPrivilegePage = url.startsWith("https://ntp.msn");
+      if (isPrivilegePage) {
+        await this._session._sendMayFail("Fetch.continueRequest", { requestId: event.requestId });
+        return;
+      }
       if (event.responseStatusCode >= 301 && event.responseStatusCode <= 308 || event.redirectedRequestId && !event.responseStatusCode) {
         await this._session.send("Fetch.continueRequest", { requestId: event.requestId, interceptResponse: true });
       } else {
@@ -745,7 +783,11 @@ class RouteImpl {
         });
       }
     } catch (error) {
-      await this._session._sendMayFail("Fetch.continueRequest", { requestId: event.requestId });
+      if (error.message.includes("Can only get response body on HeadersReceived pattern matched requests.")) {
+        await this._session.send("Fetch.continueRequest", { requestId: event.requestId, interceptResponse: true });
+      } else {
+        await this._session._sendMayFail("Fetch.continueRequest", { requestId: event.requestId });
+      }
     }
   }
 }
@@ -876,6 +918,44 @@ class ResponseExtraInfoTracker {
     this._requests.delete(requestId);
   }
 }
+function toResourceType(type) {
+  switch (type) {
+    case "Document":
+      return "document";
+    case "Stylesheet":
+      return "stylesheet";
+    case "Image":
+      return "image";
+    case "Media":
+      return "media";
+    case "Font":
+      return "font";
+    case "Script":
+      return "script";
+    case "TextTrack":
+      return "texttrack";
+    case "XHR":
+      return "xhr";
+    case "Fetch":
+      return "fetch";
+    case "EventSource":
+      return "eventsource";
+    case "WebSocket":
+      return "websocket";
+    case "Manifest":
+      return "manifest";
+    case "Ping":
+      return "ping";
+    case "CSPViolationReport":
+      return "cspreport";
+    case "Prefetch":
+    case "SignedExchange":
+    case "Preflight":
+    case "FedCM":
+    default:
+      return "other";
+  }
+}
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
   CRNetworkManager