patchright-core 1.58.2 → 1.59.0

package/lib/server/page.js

@@ -32,11 +32,12 @@ __export(page_exports, {
   Page: () => Page,
   PageBinding: () => PageBinding,
   Worker: () => Worker,
-  WorkerEvent: () => WorkerEvent
+  WorkerEvent: () => WorkerEvent,
+  ariaSnapshotForFrame: () => ariaSnapshotForFrame
 });
 module.exports = __toCommonJS(page_exports);
-var import_pageBinding = require("./pageBinding");
 var import_browserContext = require("./browserContext");
+var import_disposable = require("./disposable");
 var import_console = require("./console");
 var import_errors = require("./errors");
 var import_fileChooser = require("./fileChooser");
@@ -54,6 +55,9 @@ var import_selectorParser = require("../utils/isomorphic/selectorParser");
 var import_manualPromise = require("../utils/isomorphic/manualPromise");
 var import_utilityScriptSerializers = require("../utils/isomorphic/utilityScriptSerializers");
 var import_callLog = require("./callLog");
+var rawBindingsControllerSource = __toESM(require("../generated/bindingsControllerSource"));
+var import_overlay = require("./overlay");
+var import_dom = require("./dom");
 var import_screencast = require("./screencast");
 const PageEvent = {
   Close: "close",
@@ -65,16 +69,15 @@ const PageEvent = {
   FrameDetached: "framedetached",
   InternalFrameNavigatedToNewDocument: "internalframenavigatedtonewdocument",
   LocatorHandlerTriggered: "locatorhandlertriggered",
-  ScreencastFrame: "screencastframe",
-  Video: "video",
   WebSocket: "websocket",
   Worker: "worker"
 };
+const navigationMarkSymbol = Symbol("navigationMark");
 class Page extends import_instrumentation.SdkObject {
   constructor(delegate, browserContext) {
     super(browserContext, "page");
     this._closedState = "open";
-    this._closedPromise = new import_manualPromise.ManualPromise();
+    this.closedPromise = new import_manualPromise.ManualPromise();
     this._initializedPromise = new import_manualPromise.ManualPromise();
     this._consoleMessages = [];
     this._pageErrors = [];
@@ -86,7 +89,6 @@ class Page extends import_instrumentation.SdkObject {
     this.initScripts = [];
     this._workers = /* @__PURE__ */ new Map();
     this.requestInterceptors = [];
-    this.video = null;
     this._locatorHandlers = /* @__PURE__ */ new Map();
     this._lastLocatorHandlerUid = 0;
     this._locatorHandlerRunningCounter = 0;
@@ -99,6 +101,7 @@ class Page extends import_instrumentation.SdkObject {
     this.touchscreen = new input.Touchscreen(delegate.rawTouchscreen, this);
     this.screenshotter = new import_screenshotter.Screenshotter(this);
     this.frameManager = new frames.FrameManager(this);
+    this.overlay = new import_overlay.Overlay(this);
     this.screencast = new import_screencast.Screencast(this);
     if (delegate.pdf)
       this.pdf = delegate.pdf.bind(delegate);
@@ -159,17 +162,20 @@ class Page extends import_instrumentation.SdkObject {
   }
   _didClose() {
     this.frameManager.dispose();
-    this.screencast.stopFrameThrottler();
+    this.screencast.dispose();
+    this.overlay.dispose();
     (0, import_utils.assert)(this._closedState !== "closed", "Page closed twice");
     this._closedState = "closed";
     this.emit(Page.Events.Close);
-    this._closedPromise.resolve();
+    this.browserContext.emit(import_browserContext.BrowserContext.Events.PageClosed, this);
+    this.closedPromise.resolve();
     this.instrumentation.onPageClose(this);
     this.openScope.close(new import_errors.TargetClosedError(this.closeReason()));
   }
   _didCrash() {
     this.frameManager.dispose();
-    this.screencast.stopFrameThrottler();
+    this.screencast.dispose();
+    this.overlay.dispose();
     this.emit(Page.Events.Crash);
     this._crashed = true;
     this.instrumentation.onPageClose(this);
@@ -203,16 +209,25 @@ class Page extends import_instrumentation.SdkObject {
       throw new Error(`Function "${name}" has been already registered`);
     if (this.browserContext._pageBindings.has(name))
       throw new Error(`Function "${name}" has been already registered in the browser context`);
-    const binding = new PageBinding(name, playwrightBinding, needsHandle);
+    await progress.race(this.browserContext.exposePlaywrightBindingIfNeeded());
+    const binding = new PageBinding(this, name, playwrightBinding, needsHandle);
     this._pageBindings.set(name, binding);
-    await this.delegate.exposeBinding(binding);
-  }
-  async removeExposedBindings(bindings) {
-    for (const key of this._pageBindings.keys()) {
-      if (!key.startsWith("__pw"))
-        this._pageBindings.delete(key);
+    try {
+      await progress.race(this.delegate.addInitScript(binding.initScript));
+      await progress.race(this.safeNonStallingEvaluateInAllFrames(binding.initScript.source, "main"));
+      return binding;
+    } catch (error) {
+      this._pageBindings.delete(name);
+      throw error;
     }
-    await this.delegate.removeExposedBindings();
+  }
+  async removeExposedBinding(binding) {
+    if (this._pageBindings.get(binding.name) !== binding)
+      return;
+    this._pageBindings.delete(binding.name);
+    await this.delegate.removeInitScripts([binding.initScript]);
+    const cleanup = `{ ${binding.cleanupScript} };`;
+    await this.safeNonStallingEvaluateInAllFrames(cleanup, "main");
   }
   async setExtraHTTPHeaders(progress, headers) {
     const oldHeaders = this._extraHTTPHeaders;
@@ -241,8 +256,8 @@ class Page extends import_instrumentation.SdkObject {
       return;
     await PageBinding.dispatch(this, payload, context);
   }
-  addConsoleMessage(worker, type, args, location, text) {
-    const message = new import_console.ConsoleMessage(this, worker, type, text, args, location);
+  addConsoleMessage(worker, type, args, location, text, timestamp) {
+    const message = new import_console.ConsoleMessage(this, worker, type, text, args, location, timestamp);
     const intercepted = this.frameManager.interceptConsoleMessage(message);
     if (intercepted) {
       args.forEach((arg) => arg.dispose());
@@ -253,8 +268,14 @@ class Page extends import_instrumentation.SdkObject {
     if (this._initialized)
       this.emitOnContext(import_browserContext.BrowserContext.Events.Console, message);
   }
-  consoleMessages() {
-    return this._consoleMessages;
+  clearConsoleMessages() {
+    this._consoleMessages.length = 0;
+  }
+  consoleMessages(filter) {
+    if (filter === "all")
+      return this._consoleMessages;
+    const marked = this._consoleMessages.findLastIndex((m) => m[navigationMarkSymbol]);
+    return marked === -1 ? this._consoleMessages : this._consoleMessages.slice(marked + 1);
   }
   addPageError(pageError) {
     this._pageErrors.push(pageError);
@@ -262,8 +283,14 @@ class Page extends import_instrumentation.SdkObject {
     if (this._initialized)
       this.emitOnContext(import_browserContext.BrowserContext.Events.PageError, pageError, this);
   }
-  pageErrors() {
-    return this._pageErrors;
+  clearPageErrors() {
+    this._pageErrors.length = 0;
+  }
+  pageErrors(filter) {
+    if (filter === "all")
+      return this._pageErrors;
+    const marked = this._pageErrors.findLastIndex((e) => e[navigationMarkSymbol]);
+    return marked === -1 ? this._pageErrors : this._pageErrors.slice(marked + 1);
   }
   async reload(progress, options) {
     return this.mainFrame().raceNavigationAction(progress, async () => {
@@ -440,21 +467,21 @@ class Page extends import_instrumentation.SdkObject {
   async bringToFront() {
     await this.delegate.bringToFront();
   }
-  async addInitScript(progress, source) {
-    const initScript = new InitScript(source);
+  async addInitScript(source) {
+    const initScript = new InitScript(this, source);
     this.initScripts.push(initScript);
     try {
-      await progress.race(this.delegate.addInitScript(initScript));
+      await this.delegate.addInitScript(initScript);
     } catch (error) {
-      this.removeInitScripts([initScript]).catch(() => {
+      initScript.dispose().catch(() => {
       });
       throw error;
     }
     return initScript;
   }
-  async removeInitScripts(initScripts) {
-    this.initScripts.splice(0, this.initScripts.length);
-    await this.delegate.removeInitScripts();
+  async removeInitScript(initScript) {
+    this.initScripts = this.initScripts.filter((script) => initScript !== script);
+    await this.delegate.removeInitScripts([initScript]);
   }
   needsRequestInterception() {
     return this.requestInterceptors.length > 0 || this.browserContext.requestInterceptors.length > 0;
@@ -570,13 +597,15 @@ class Page extends import_instrumentation.SdkObject {
     if (options.reason)
       this._closeReason = options.reason;
     const runBeforeUnload = !!options.runBeforeUnload;
+    if (!runBeforeUnload)
+      await this.screencast.handlePageOrContextClose();
     if (this._closedState !== "closing") {
       if (!runBeforeUnload)
         this._closedState = "closing";
       await this.delegate.closePage(runBeforeUnload).catch((e) => import_debugLogger.debugLogger.log("error", e));
     }
     if (!runBeforeUnload)
-      await this._closedPromise;
+      await this.closedPromise;
   }
   isClosed() {
     return this._closedState === "closed";
@@ -618,9 +647,22 @@ class Page extends import_instrumentation.SdkObject {
   }
   frameNavigatedToNewDocument(frame) {
     this.emit(Page.Events.InternalFrameNavigatedToNewDocument, frame);
+    this.browserContext.emit(import_browserContext.BrowserContext.Events.InternalFrameNavigatedToNewDocument, frame, this);
     const origin = frame.origin();
     if (origin)
       this.browserContext.addVisitedOrigin(origin);
+    if (frame === this.mainFrame()) {
+      if (this._consoleMessages.length > 0)
+        this._consoleMessages[this._consoleMessages.length - 1][navigationMarkSymbol] = true;
+      if (this._pageErrors.length > 0)
+        this._pageErrors[this._pageErrors.length - 1][navigationMarkSymbol] = true;
+    }
+  }
+  allInitScripts() {
+    const bindings = [...this.browserContext._pageBindings.values(), ...this._pageBindings.values()].map((binding) => binding.initScript);
+    if (this.browserContext.bindingsInitScript)
+      bindings.unshift(this.browserContext.bindingsInitScript);
+    return [...bindings, ...this.browserContext.initScripts, ...this.initScripts];
   }
   getBinding(name) {
     return this._pageBindings.get(name) || this.browserContext._pageBindings.get(name);
@@ -639,12 +681,8 @@ class Page extends import_instrumentation.SdkObject {
     await Promise.all(this.frames().map((frame) => frame.hideHighlight().catch(() => {
     })));
   }
-  async snapshotForAI(progress, options = {}) {
-    const snapshot = await snapshotFrameForAI(progress, this.mainFrame(), options);
-    return { full: snapshot.full.join("\n"), incremental: snapshot.incremental?.join("\n") };
-  }
-  allBindings() {
-    return [...this.browserContext._pageBindings.values(), ...this._pageBindings.values()];
+  async setDockTile(image) {
+    await this.delegate.setDockTile(image);
   }
 }
 const WorkerEvent = {
@@ -673,70 +711,54 @@ class Worker extends import_instrumentation.SdkObject {
     if (this.existingExecutionContext)
       this._executionContextPromise.resolve(this.existingExecutionContext);
   }
+  _prepareContextForRestart() {
+    if (this.existingExecutionContext)
+      this.existingExecutionContext.contextDestroyed("Service worker restarted");
+    this.existingExecutionContext = null;
+    this._workerScriptLoaded = false;
+    this._executionContextPromise = new import_manualPromise.ManualPromise();
+  }
   didClose() {
     if (this.existingExecutionContext)
       this.existingExecutionContext.contextDestroyed("Worker was closed");
     this.emit(Worker.Events.Close, this);
     this.openScope.close(new Error("Worker closed"));
   }
-  async evaluateExpression(expression, isFunction, arg, isolatedContext) {
-    let context = await this._executionContextPromise;
-    if (context.constructor.name === "FrameExecutionContext") {
-      const frame = context.frame;
-      if (frame) {
-        if (isolatedContext) context = await frame._utilityContext();
-        else if (!isolatedContext) context = await frame._mainContext();
-      }
-    }
-    return js.evaluateExpression(context, expression, { returnByValue: true, isFunction }, arg);
-  }
-  async evaluateExpressionHandle(expression, isFunction, arg, isolatedContext) {
-    let context = await this._executionContextPromise;
-    if (context.constructor.name === "FrameExecutionContext") {
-      const frame = this._context.frame;
-      if (frame) {
-        if (isolatedContext) context = await frame._utilityContext();
-        else if (!isolatedContext) context = await frame._mainContext();
-      }
-    }
-    return js.evaluateExpression(context, expression, { returnByValue: false, isFunction }, arg);
+  async evaluateExpression(expression, isFunction, arg) {
+    return js.evaluateExpression(await this._executionContextPromise, expression, { returnByValue: true, isFunction }, arg);
+  }
+  async evaluateExpressionHandle(expression, isFunction, arg) {
+    return js.evaluateExpression(await this._executionContextPromise, expression, { returnByValue: false, isFunction }, arg);
   }
 }
-class PageBinding {
-  constructor(name, playwrightFunction, needsHandle) {
+class PageBinding extends import_disposable.DisposableObject {
+  static {
+    this.kController = "__playwright__binding__controller__";
+  }
+  static {
+    this.kBindingName = "__playwright__binding__";
+  }
+  static createInitScript(browserContext) {
+    return new InitScript(browserContext, `
+      (() => {
+        const module = {};
+        ${rawBindingsControllerSource.source}
+        const property = '${PageBinding.kController}';
+        if (!globalThis[property])
+          globalThis[property] = new (module.exports.BindingsController())(globalThis, '${PageBinding.kBindingName}');
+      })();
+    `);
+  }
+  constructor(parent, name, playwrightFunction, needsHandle) {
+    super(parent);
     this.name = name;
     this.playwrightFunction = playwrightFunction;
-    this.source = (0, import_pageBinding.createPageBindingScript)(name, needsHandle);
+    this.initScript = new InitScript(parent, `globalThis['${PageBinding.kController}'].addBinding(${JSON.stringify(name)}, ${needsHandle})`);
     this.needsHandle = needsHandle;
+    this.cleanupScript = `globalThis['${PageBinding.kController}'].removeBinding(${JSON.stringify(name)})`;
   }
   static async dispatch(page, payload, context) {
     const { name, seq, serializedArgs } = JSON.parse(payload);
-    const deliver = async (deliverPayload) => {
-      let deliveryError;
-      try {
-        await context.evaluate(import_pageBinding.deliverBindingResult, deliverPayload);
-        return;
-      } catch (e) {
-        deliveryError = e;
-      }
-      const frame = context.frame;
-      if (!frame) {
-        import_debugLogger.debugLogger.log("error", deliveryError);
-        return;
-      }
-      const mainContext = await frame._mainContext().catch(() => null);
-      const utilityContext = await frame._utilityContext().catch(() => null);
-      for (const ctx of [mainContext, utilityContext]) {
-        if (!ctx || ctx === context)
-          continue;
-        try {
-          await ctx.evaluate(import_pageBinding.deliverBindingResult, deliverPayload);
-          return;
-        } catch {
-        }
-      }
-      import_debugLogger.debugLogger.log("error", deliveryError);
-    };
     try {
       (0, import_utils.assert)(context.world);
       const binding = page.getBinding(name);
@@ -744,38 +766,62 @@ class PageBinding {
         throw new Error(`Function "${name}" is not exposed`);
       let result;
       if (binding.needsHandle) {
-        const handle = await context.evaluateHandle(import_pageBinding.takeBindingHandle, { name, seq }).catch((e) => null);
-        result = await binding.playwrightFunction({ frame: context.frame, page, context: page._browserContext }, handle);
+        const handle = await context.evaluateExpressionHandle(`arg => globalThis['${PageBinding.kController}'].takeBindingHandle(arg)`, { isFunction: true }, { name, seq }).catch((e) => null);
+        result = await binding.playwrightFunction({ frame: context.frame, page, context: page.browserContext }, handle);
       } else {
         if (!Array.isArray(serializedArgs))
           throw new Error(`serializedArgs is not an array. This can happen when Array.prototype.toJSON is defined incorrectly`);
         const args = serializedArgs.map((a) => (0, import_utilityScriptSerializers.parseEvaluationResultValue)(a));
-        result = await binding.playwrightFunction({ frame: context.frame, page, context: page._browserContext }, ...args);
+        result = await binding.playwrightFunction({ frame: context.frame, page, context: page.browserContext }, ...args);
       }
-      await deliver({ name, seq, result });
+      context.evaluateExpressionHandle(`arg => globalThis['${PageBinding.kController}'].deliverBindingResult(arg)`, { isFunction: true }, { name, seq, result }).catch((e) => import_debugLogger.debugLogger.log("error", e));
     } catch (error) {
-      await deliver({ name, seq, error });
+      context.evaluateExpressionHandle(`arg => globalThis['${PageBinding.kController}'].deliverBindingResult(arg)`, { isFunction: true }, { name, seq, error }).catch((e) => import_debugLogger.debugLogger.log("error", e));
     }
   }
+  async dispose() {
+    await this.parent.removeExposedBinding(this);
+  }
 }
-class InitScript {
-  constructor(source) {
-    this.source = `(() => { ${source} })();`;
+class InitScript extends import_disposable.DisposableObject {
+  constructor(owner, source) {
+    super(owner);
+    this.source = `(() => {
+      ${source}
+    })();`;
+  }
+  async dispose() {
+    await this.parent.removeInitScript(this);
   }
 }
-async function snapshotFrameForAI(progress, frame, options = {}) {
+async function ariaSnapshotForFrame(progress, frame, options = {}) {
   const snapshot = await frame.retryWithProgressAndTimeouts(progress, [1e3, 2e3, 4e3, 8e3], async (continuePolling) => {
     try {
       const context = await progress.race(frame._utilityContext());
       const injectedScript = await progress.race(context.injectedScript());
       const snapshotOrRetry = await progress.race(injectedScript.evaluate((injected, options2) => {
+        if (options2.info) {
+          const element = injected.querySelector(options2.info.parsed, injected.document, options2.info.strict);
+          if (!element)
+            return false;
+          return injected.incrementalAriaSnapshot(element, options2);
+        }
         const node = injected.document.body;
         if (!node)
           return true;
-        return injected.incrementalAriaSnapshot(node, { mode: "ai", ...options2 });
-      }, { refPrefix: frame.seq ? "f" + frame.seq : "", track: options.track, doNotRenderActive: options.doNotRenderActive }));
+        return injected.incrementalAriaSnapshot(node, options2);
+      }, {
+        mode: options.mode ?? "default",
+        refPrefix: frame.seq ? "f" + frame.seq : "",
+        track: options.track,
+        doNotRenderActive: options.doNotRenderActive,
+        info: options.info,
+        depth: options.depth
+      }));
       if (snapshotOrRetry === true)
         return continuePolling;
+      if (snapshotOrRetry === false)
+        throw new import_dom.NonRecoverableDOMError(`Selector "${(0, import_selectorParser.stringifySelector)(options.info.parsed)}" does not match any element`);
       return snapshotOrRetry;
     } catch (e) {
       if (frame.isNonRetriableError(e))
@@ -783,18 +829,23 @@ async function snapshotFrameForAI(progress, frame, options = {}) {
       return continuePolling;
     }
   });
-  const childSnapshotPromises = snapshot.iframeRefs.map((ref) => snapshotFrameRefForAI(progress, frame, ref, options));
+  const renderedIframeRefs = snapshot.iframeRefs.filter((ref) => ref in snapshot.iframeDepths);
+  const childSnapshotPromises = renderedIframeRefs.map((ref) => {
+    const iframeDepth = snapshot.iframeDepths[ref];
+    const childDepth = options.depth ? options.depth - iframeDepth - 1 : void 0;
+    return ariaSnapshotFrameRef(progress, frame, ref, { ...options, depth: childDepth });
+  });
   const childSnapshots = await Promise.all(childSnapshotPromises);
   const full = [];
   let incremental;
   if (snapshot.incremental !== void 0) {
     incremental = snapshot.incremental.split("\n");
-    for (let i = 0; i < snapshot.iframeRefs.length; i++) {
+    for (let i = 0; i < renderedIframeRefs.length; i++) {
       const childSnapshot = childSnapshots[i];
       if (childSnapshot.incremental)
         incremental.push(...childSnapshot.incremental);
       else if (childSnapshot.full.length)
-        incremental.push("- <changed> iframe [ref=" + snapshot.iframeRefs[i] + "]:", ...childSnapshot.full.map((l) => "  " + l));
+        incremental.push("- <changed> iframe [ref=" + renderedIframeRefs[i] + "]:", ...childSnapshot.full.map((l) => "  " + l));
     }
   }
   for (const line of snapshot.full.split("\n")) {
@@ -805,20 +856,20 @@ async function snapshotFrameForAI(progress, frame, options = {}) {
     }
     const leadingSpace = match[1];
     const ref = match[2];
-    const childSnapshot = childSnapshots[snapshot.iframeRefs.indexOf(ref)] ?? { full: [] };
+    const childSnapshot = childSnapshots[renderedIframeRefs.indexOf(ref)] ?? { full: [] };
     full.push(childSnapshot.full.length ? line + ":" : line);
     full.push(...childSnapshot.full.map((l) => leadingSpace + "  " + l));
   }
   return { full, incremental };
 }
-async function snapshotFrameRefForAI(progress, parentFrame, frameRef, options) {
+async function ariaSnapshotFrameRef(progress, parentFrame, frameRef, options) {
   const frameSelector = `aria-ref=${frameRef} >> internal:control=enter-frame`;
   const frameBodySelector = `${frameSelector} >> body`;
   const child = await progress.race(parentFrame.selectors.resolveFrameForSelector(frameBodySelector, { strict: true }));
   if (!child)
     return { full: [] };
   try {
-    return await snapshotFrameForAI(progress, child.frame, options);
+    return await ariaSnapshotForFrame(progress, child.frame, { ...options, info: void 0 });
   } catch {
     return { full: [] };
   }
@@ -834,5 +885,6 @@ function ensureArrayLimit(array, limit) {
   Page,
   PageBinding,
   Worker,
-  WorkerEvent
+  WorkerEvent,
+  ariaSnapshotForFrame
 });

package/lib/server/progress.js

@@ -39,10 +39,16 @@ class ProgressController {
   static createForSdkObject(sdkObject, callMetadata) {
     const logName = sdkObject.logName || "api";
     return new ProgressController(callMetadata, (message) => {
+      if (logName === "api" && sdkObject.attribution.playwright?.options.isInternalPlaywright)
+        return;
       import_utils.debugLogger.log(logName, message);
       sdkObject.instrumentation.onCallLog(sdkObject, callMetadata, logName, message);
     });
   }
+  static runInternalTask(task, timeout) {
+    const progress = new ProgressController();
+    return progress.run(task, timeout);
+  }
   async abort(error) {
     if (this._state === "running") {
       error[kAbortErrorSymbol] = true;

package/lib/server/recorder/recorderApp.js

@@ -125,7 +125,7 @@ class RecorderApp {
         if (source) {
           if (source.isRecorded)
             this._selectedGeneratorId = source.id;
-          this._recorder.setLanguage(source.language);
+          await this._recorder.setLanguage(source.language);
         }
       },
       setAutoExpect: async (params) => {
@@ -133,7 +133,7 @@ class RecorderApp {
         this._updateActions();
       },
       setMode: async (params) => {
-        this._recorder.setMode(params.mode);
+        await this._recorder.setMode(params.mode);
       },
       resume: async () => {
         this._recorder.resume();
@@ -146,9 +146,9 @@ class RecorderApp {
       },
       highlightRequested: async (params) => {
         if (params.selector)
-          this._recorder.setHighlightedSelector(params.selector);
+          await this._recorder.setHighlightedSelector(params.selector);
         if (params.ariaTemplate)
-          this._recorder.setHighlightedAriaTemplate(params.ariaTemplate);
+          await this._recorder.setHighlightedAriaTemplate(params.ariaTemplate);
       }
     };
     await this._page.exposeBinding(progress, "sendCommand", false, async (_, data) => {
@@ -181,6 +181,7 @@ class RecorderApp {
       return;
     inspectedContext[recorderAppSymbol] = true;
     const sdkLanguage = inspectedContext._browser.sdkLanguage();
+    const isChromium = inspectedContext._browser.options.browserType === "chromium";
     const headed = !!inspectedContext._browser.options.headful;
     const recorderPlaywright = require("../playwright").createPlaywright({ sdkLanguage: "javascript", isInternalPlaywright: true });
     const { context: appContext, page } = await (0, import_launchApp2.launchApp)(recorderPlaywright.chromium, {
@@ -192,9 +193,9 @@ class RecorderApp {
         headless: !!process.env.PWTEST_CLI_HEADLESS || (0, import_debug.isUnderTest)() && !headed,
         cdpPort: (0, import_debug.isUnderTest)() ? 0 : void 0,
         handleSIGINT: params.handleSIGINT,
-        executablePath: inspectedContext._browser.options.isChromium ? inspectedContext._browser.options.customExecutablePath : void 0,
+        executablePath: isChromium ? inspectedContext._browser.options.customExecutablePath : void 0,
         // Use the same channel as the inspected context to guarantee that the browser is installed.
-        channel: inspectedContext._browser.options.isChromium ? inspectedContext._browser.options.channel : void 0
+        channel: isChromium ? inspectedContext._browser.options.channel : void 0
       }
     });
     const controller = new import_progress.ProgressController();
@@ -206,8 +207,8 @@ class RecorderApp {
       sdkLanguage: inspectedContext._browser.sdkLanguage(),
       wsEndpointForTest: inspectedContext._browser.options.wsEndpoint,
       headed: !!inspectedContext._browser.options.headful,
-      executablePath: inspectedContext._browser.options.isChromium ? inspectedContext._browser.options.customExecutablePath : void 0,
-      channel: inspectedContext._browser.options.isChromium ? inspectedContext._browser.options.channel : void 0,
+      executablePath: isChromium ? inspectedContext._browser.options.customExecutablePath : void 0,
+      channel: isChromium ? inspectedContext._browser.options.channel : void 0,
       ...params
     };
     const recorderApp = new RecorderApp(recorder, appParams, page, appContext._browser.options.wsEndpoint);