playwright-core 1.55.0-alpha-2025-07-29 → 1.55.0-alpha-2025-07-30

package/lib/server/browserContext.js

@@ -258,10 +258,14 @@ if (navigator.serviceWorker) navigator.serviceWorker.register = async () => { co
     const binding = new import_page2.PageBinding(name, playwrightBinding, needsHandle);
     binding.forClient = forClient;
     this._pageBindings.set(name, binding);
-    progress.cleanupWhenAborted(() => this._pageBindings.delete(name));
-    await progress.race(this.doAddInitScript(binding.initScript));
-    await progress.race(this.safeNonStallingEvaluateInAllFrames(binding.initScript.source, "main"));
-    return binding;
+    try {
+      await progress.race(this.doAddInitScript(binding.initScript));
+      await progress.race(this.safeNonStallingEvaluateInAllFrames(binding.initScript.source, "main"));
+      return binding;
+    } catch (error) {
+      this._pageBindings.delete(name);
+      throw error;
+    }
   }
   async removeExposedBindings(bindings) {
     bindings = bindings.filter((binding) => this._pageBindings.get(binding.name) === binding);
@@ -291,20 +295,26 @@ if (navigator.serviceWorker) navigator.serviceWorker.register = async () => { co
   async setExtraHTTPHeaders(progress, headers) {
     const oldHeaders = this._options.extraHTTPHeaders;
     this._options.extraHTTPHeaders = headers;
-    progress.cleanupWhenAborted(async () => {
+    try {
+      await progress.race(this.doUpdateExtraHTTPHeaders());
+    } catch (error) {
       this._options.extraHTTPHeaders = oldHeaders;
-      await this.doUpdateExtraHTTPHeaders();
-    });
-    await progress.race(this.doUpdateExtraHTTPHeaders());
+      this.doUpdateExtraHTTPHeaders().catch(() => {
+      });
+      throw error;
+    }
   }
   async setOffline(progress, offline) {
     const oldOffline = this._options.offline;
     this._options.offline = offline;
-    progress.cleanupWhenAborted(async () => {
+    try {
+      await progress.race(this.doUpdateOffline());
+    } catch (error) {
       this._options.offline = oldOffline;
-      await this.doUpdateOffline();
-    });
-    await progress.race(this.doUpdateOffline());
+      this.doUpdateOffline().catch(() => {
+      });
+      throw error;
+    }
   }
   async _loadDefaultContextAsIs(progress) {
     if (!this.possiblyUninitializedPages().length) {
@@ -353,13 +363,18 @@ if (navigator.serviceWorker) navigator.serviceWorker.register = async () => { co
   async addInitScript(progress, source) {
     const initScript = new import_page.InitScript(source);
     this.initScripts.push(initScript);
-    progress?.cleanupWhenAborted(() => this.removeInitScripts([initScript]));
-    const promise = this.doAddInitScript(initScript);
-    if (progress)
-      await progress.race(promise);
-    else
-      await promise;
-    return initScript;
+    try {
+      const promise = this.doAddInitScript(initScript);
+      if (progress)
+        await progress.race(promise);
+      else
+        await promise;
+      return initScript;
+    } catch (error) {
+      this.removeInitScripts([initScript]).catch(() => {
+      });
+      throw error;
+    }
   }
   async removeInitScripts(initScripts) {
     const set = new Set(initScripts);
@@ -419,14 +434,20 @@ if (navigator.serviceWorker) navigator.serviceWorker.register = async () => { co
     await this._closePromise;
   }
   async newPage(progress, isServerSide) {
-    const page = await progress.raceWithCleanup(this.doCreateNewPage(isServerSide), (page2) => page2.close());
-    const pageOrError = await progress.race(page.waitForInitializedOrError());
-    if (pageOrError instanceof import_page2.Page) {
-      if (pageOrError.isClosed())
-        throw new Error("Page has been closed.");
-      return pageOrError;
+    const page = await progress.race(this.doCreateNewPage(isServerSide));
+    try {
+      const pageOrError = await progress.race(page.waitForInitializedOrError());
+      if (pageOrError instanceof import_page2.Page) {
+        if (pageOrError.isClosed())
+          throw new Error("Page has been closed.");
+        return pageOrError;
+      }
+      throw pageOrError;
+    } catch (error) {
+      await page.close({ reason: "Failed to create page" }).catch(() => {
+      });
+      throw error;
     }
-    throw pageOrError;
   }
   addVisitedOrigin(origin) {
     this._origins.add(origin);
@@ -457,18 +478,21 @@ if (navigator.serviceWorker) navigator.serviceWorker.register = async () => { co
     }
     if (originsToSave.size) {
       const page = await this.newPage(progress, true);
-      await page.addRequestInterceptor(progress, (route) => {
-        route.fulfill({ body: "<html></html>" }).catch(() => {
-        });
-      }, "prepend");
-      for (const origin of originsToSave) {
-        const frame = page.mainFrame();
-        await frame.gotoImpl(progress, origin, {});
-        const storage = await progress.race(frame.evaluateExpression(collectScript, { world: "utility" }));
-        if (storage.localStorage.length || storage.indexedDB?.length)
-          result.origins.push({ origin, localStorage: storage.localStorage, indexedDB: storage.indexedDB });
+      try {
+        await page.addRequestInterceptor(progress, (route) => {
+          route.fulfill({ body: "<html></html>" }).catch(() => {
+          });
+        }, "prepend");
+        for (const origin of originsToSave) {
+          const frame = page.mainFrame();
+          await frame.gotoImpl(progress, origin, {});
+          const storage = await progress.race(frame.evaluateExpression(collectScript, { world: "utility" }));
+          if (storage.localStorage.length || storage.indexedDB?.length)
+            result.origins.push({ origin, localStorage: storage.localStorage, indexedDB: storage.indexedDB });
+        }
+      } finally {
+        await page.close();
       }
-      await page.close();
     }
     return result;
   }
@@ -483,26 +507,29 @@ if (navigator.serviceWorker) navigator.serviceWorker.register = async () => { co
       route.fulfill({ body: "<html></html>" }).catch(() => {
       });
     };
-    progress.cleanupWhenAborted(() => page.removeRequestInterceptor(interceptor));
     await page.addRequestInterceptor(progress, interceptor, "prepend");
-    for (const origin of /* @__PURE__ */ new Set([...oldOrigins, ...newOrigins.keys()])) {
-      const frame = page.mainFrame();
-      await frame.gotoImpl(progress, origin, {});
-      await progress.race(frame.resetStorageForCurrentOriginBestEffort(newOrigins.get(origin)));
+    try {
+      for (const origin of /* @__PURE__ */ new Set([...oldOrigins, ...newOrigins.keys()])) {
+        const frame = page.mainFrame();
+        await frame.gotoImpl(progress, origin, {});
+        await progress.race(frame.resetStorageForCurrentOriginBestEffort(newOrigins.get(origin)));
+      }
+      this._origins = /* @__PURE__ */ new Set([...newOrigins.keys()]);
+    } finally {
+      await page.removeRequestInterceptor(interceptor);
     }
-    await page.removeRequestInterceptor(interceptor);
-    this._origins = /* @__PURE__ */ new Set([...newOrigins.keys()]);
   }
   isSettingStorageState() {
     return this._settingStorageState;
   }
   async setStorageState(progress, state) {
+    let page;
     this._settingStorageState = true;
     try {
       if (state.cookies)
         await progress.race(this.addCookies(state.cookies));
       if (state.origins && state.origins.length) {
-        const page = await this.newPage(progress, true);
+        page = await this.newPage(progress, true);
         await page.addRequestInterceptor(progress, (route) => {
           route.fulfill({ body: "<html></html>" }).catch(() => {
           });
@@ -518,13 +545,13 @@ if (navigator.serviceWorker) navigator.serviceWorker.register = async () => { co
           })()`;
           await progress.race(frame.evaluateExpression(restoreScript, { world: "utility" }));
         }
-        await page.close();
       }
     } catch (error) {
       (0, import_stackTrace.rewriteErrorMessage)(error, `Error setting storage state:
 ` + error.message);
       throw error;
     } finally {
+      await page?.close();
       this._settingStorageState = false;
     }
   }

package/lib/server/browserType.js

@@ -77,16 +77,22 @@ class BrowserType extends import_instrumentation.SdkObject {
     const launchOptions = this._validateLaunchOptions(options);
     let clientCertificatesProxy;
     if (options.clientCertificates?.length) {
-      clientCertificatesProxy = await progress.raceWithCleanup(import_socksClientCertificatesInterceptor.ClientCertificatesProxy.create(options), (proxy) => proxy.close());
+      clientCertificatesProxy = await import_socksClientCertificatesInterceptor.ClientCertificatesProxy.create(progress, options);
       launchOptions.proxyOverride = clientCertificatesProxy.proxySettings();
       options = { ...options };
       options.internalIgnoreHTTPSErrors = true;
     }
-    const browser = await this._innerLaunchWithRetries(progress, launchOptions, options, import_helper.helper.debugProtocolLogger(), userDataDir).catch((e) => {
-      throw this._rewriteStartupLog(e);
-    });
-    browser._defaultContext._clientCertificatesProxy = clientCertificatesProxy;
-    return browser._defaultContext;
+    try {
+      const browser = await this._innerLaunchWithRetries(progress, launchOptions, options, import_helper.helper.debugProtocolLogger(), userDataDir).catch((e) => {
+        throw this._rewriteStartupLog(e);
+      });
+      browser._defaultContext._clientCertificatesProxy = clientCertificatesProxy;
+      return browser._defaultContext;
+    } catch (error) {
+      await clientCertificatesProxy?.close().catch(() => {
+      });
+      throw error;
+    }
   }
   async _innerLaunchWithRetries(progress, options, persistent, protocolLogger, userDataDir) {
     try {
@@ -104,34 +110,40 @@ class BrowserType extends import_instrumentation.SdkObject {
     options.proxy = options.proxy ? (0, import_browserContext.normalizeProxySettings)(options.proxy) : void 0;
     const browserLogsCollector = new import_debugLogger.RecentLogsCollector();
     const { browserProcess, userDataDir, artifactsDir, transport } = await this._launchProcess(progress, options, !!persistent, browserLogsCollector, maybeUserDataDir);
-    if (options.__testHookBeforeCreateBrowser)
-      await progress.race(options.__testHookBeforeCreateBrowser());
-    const browserOptions = {
-      name: this._name,
-      isChromium: this._name === "chromium",
-      channel: options.channel,
-      slowMo: options.slowMo,
-      persistent,
-      headful: !options.headless,
-      artifactsDir,
-      downloadsPath: options.downloadsPath || artifactsDir,
-      tracesDir: options.tracesDir || artifactsDir,
-      browserProcess,
-      customExecutablePath: options.executablePath,
-      proxy: options.proxy,
-      protocolLogger,
-      browserLogsCollector,
-      wsEndpoint: transport instanceof import_transport.WebSocketTransport ? transport.wsEndpoint : void 0,
-      originalLaunchOptions: options
-    };
-    if (persistent)
-      (0, import_browserContext.validateBrowserContextOptions)(persistent, browserOptions);
-    copyTestHooks(options, browserOptions);
-    const browser = await progress.race(this.connectToTransport(transport, browserOptions, browserLogsCollector));
-    browser._userDataDirForTest = userDataDir;
-    if (persistent && !options.ignoreAllDefaultArgs)
-      await browser._defaultContext._loadDefaultContext(progress);
-    return browser;
+    try {
+      if (options.__testHookBeforeCreateBrowser)
+        await progress.race(options.__testHookBeforeCreateBrowser());
+      const browserOptions = {
+        name: this._name,
+        isChromium: this._name === "chromium",
+        channel: options.channel,
+        slowMo: options.slowMo,
+        persistent,
+        headful: !options.headless,
+        artifactsDir,
+        downloadsPath: options.downloadsPath || artifactsDir,
+        tracesDir: options.tracesDir || artifactsDir,
+        browserProcess,
+        customExecutablePath: options.executablePath,
+        proxy: options.proxy,
+        protocolLogger,
+        browserLogsCollector,
+        wsEndpoint: transport instanceof import_transport.WebSocketTransport ? transport.wsEndpoint : void 0,
+        originalLaunchOptions: options
+      };
+      if (persistent)
+        (0, import_browserContext.validateBrowserContextOptions)(persistent, browserOptions);
+      copyTestHooks(options, browserOptions);
+      const browser = await progress.race(this.connectToTransport(transport, browserOptions, browserLogsCollector));
+      browser._userDataDirForTest = userDataDir;
+      if (persistent && !options.ignoreAllDefaultArgs)
+        await browser._defaultContext._loadDefaultContext(progress);
+      return browser;
+    } catch (error) {
+      await browserProcess.close().catch(() => {
+      });
+      throw error;
+    }
   }
   async _prepareToLaunch(options, isPersistent, userDataDir) {
     const {
@@ -182,7 +194,6 @@ class BrowserType extends import_instrumentation.SdkObject {
     } = options;
     const env = options.env ? (0, import_processLauncher.envArrayToObject)(options.env) : process.env;
     const prepared = await progress.race(this._prepareToLaunch(options, isPersistent, userDataDir));
-    progress.cleanupWhenAborted(() => (0, import_fileUtils.removeFolders)(prepared.tempDirectories));
     let transport = void 0;
     let browserProcess = void 0;
     const exitPromise = new import_manualPromise.ManualPromise();
@@ -202,7 +213,11 @@ class BrowserType extends import_instrumentation.SdkObject {
       attemptToGracefullyClose: async () => {
         if (options.__testHookGracefullyClose)
           await options.__testHookGracefullyClose();
-        this.attemptToGracefullyCloseBrowser(transport);
+        if (transport) {
+          this.attemptToGracefullyCloseBrowser(transport);
+        } else {
+          throw new Error("Force-killing the browser because no transport is available to gracefully close it.");
+        }
       },
       onExit: (exitCode, signal) => {
         exitPromise.resolve();
@@ -230,19 +245,23 @@ class BrowserType extends import_instrumentation.SdkObject {
       close: () => closeOrKill(options.__testHookBrowserCloseTimeout || import_time.DEFAULT_PLAYWRIGHT_TIMEOUT),
       kill
     };
-    progress.cleanupWhenAborted(() => closeOrKill(import_time.DEFAULT_PLAYWRIGHT_TIMEOUT));
-    const { wsEndpoint } = await progress.race([
-      this.waitForReadyState(options, browserLogsCollector),
-      exitPromise.then(() => ({ wsEndpoint: void 0 }))
-    ]);
-    if (options.cdpPort !== void 0 || !this.supportsPipeTransport()) {
-      transport = await import_transport.WebSocketTransport.connect(progress, wsEndpoint);
-    } else {
-      const stdio = launchedProcess.stdio;
-      transport = new import_pipeTransport.PipeTransport(stdio[3], stdio[4]);
+    try {
+      const { wsEndpoint } = await progress.race([
+        this.waitForReadyState(options, browserLogsCollector),
+        exitPromise.then(() => ({ wsEndpoint: void 0 }))
+      ]);
+      if (options.cdpPort !== void 0 || !this.supportsPipeTransport()) {
+        transport = await import_transport.WebSocketTransport.connect(progress, wsEndpoint);
+      } else {
+        const stdio = launchedProcess.stdio;
+        transport = new import_pipeTransport.PipeTransport(stdio[3], stdio[4]);
+      }
+      return { browserProcess, artifactsDir: prepared.artifactsDir, userDataDir: prepared.userDataDir, transport };
+    } catch (error) {
+      await closeOrKill(import_time.DEFAULT_PLAYWRIGHT_TIMEOUT).catch(() => {
+      });
+      throw error;
     }
-    progress.cleanupWhenAborted(() => transport.close());
-    return { browserProcess, artifactsDir: prepared.artifactsDir, userDataDir: prepared.userDataDir, transport };
   }
   async _createArtifactDirs(options) {
     if (options.downloadsPath)

package/lib/server/chromium/chromium.js

@@ -72,39 +72,45 @@ class Chromium extends import_browserType.BrowserType {
     else if (headersMap && !Object.keys(headersMap).some((key) => key.toLowerCase() === "user-agent"))
       headersMap["User-Agent"] = (0, import_userAgent.getUserAgent)();
     const artifactsDir = await progress.race(import_fs.default.promises.mkdtemp(ARTIFACTS_FOLDER));
-    const wsEndpoint = await urlToWSEndpoint(progress, endpointURL, headersMap);
-    const chromeTransport = await import_transport.WebSocketTransport.connect(progress, wsEndpoint, { headers: headersMap });
-    progress.cleanupWhenAborted(() => chromeTransport.close());
-    const cleanedUp = new import_manualPromise.ManualPromise();
     const doCleanup = async () => {
       await (0, import_fileUtils.removeFolders)([artifactsDir]);
-      await onClose?.();
-      cleanedUp.resolve();
+      const cb = onClose;
+      onClose = void 0;
+      await cb?.();
     };
+    let chromeTransport;
     const doClose = async () => {
-      await chromeTransport.closeAndWait();
-      await cleanedUp;
+      await chromeTransport?.closeAndWait();
+      await doCleanup();
     };
-    const browserProcess = { close: doClose, kill: doClose };
-    const persistent = { noDefaultViewport: true };
-    const browserOptions = {
-      slowMo: options.slowMo,
-      name: "chromium",
-      isChromium: true,
-      persistent,
-      browserProcess,
-      protocolLogger: import_helper.helper.debugProtocolLogger(),
-      browserLogsCollector: new import_debugLogger.RecentLogsCollector(),
-      artifactsDir,
-      downloadsPath: options.downloadsPath || artifactsDir,
-      tracesDir: options.tracesDir || artifactsDir,
-      originalLaunchOptions: {}
-    };
-    (0, import_browserContext.validateBrowserContextOptions)(persistent, browserOptions);
-    const browser = await progress.race(import_crBrowser.CRBrowser.connect(this.attribution.playwright, chromeTransport, browserOptions));
-    browser._isCollocatedWithServer = false;
-    browser.on(import_browser.Browser.Events.Disconnected, doCleanup);
-    return browser;
+    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,
+        persistent,
+        browserProcess,
+        protocolLogger: import_helper.helper.debugProtocolLogger(),
+        browserLogsCollector: new import_debugLogger.RecentLogsCollector(),
+        artifactsDir,
+        downloadsPath: options.downloadsPath || artifactsDir,
+        tracesDir: options.tracesDir || artifactsDir,
+        originalLaunchOptions: {}
+      };
+      (0, import_browserContext.validateBrowserContextOptions)(persistent, browserOptions);
+      const browser = await progress.race(import_crBrowser.CRBrowser.connect(this.attribution.playwright, chromeTransport, browserOptions));
+      browser._isCollocatedWithServer = false;
+      browser.on(import_browser.Browser.Events.Disconnected, doCleanup);
+      return browser;
+    } catch (error) {
+      await doClose().catch(() => {
+      });
+      throw error;
+    }
   }
   _createDevTools() {
     const directory = import_registry.registry.findExecutable("chromium").directory;

package/lib/server/chromium/crCoverage.js

@@ -23,21 +23,20 @@ __export(crCoverage_exports, {
 module.exports = __toCommonJS(crCoverage_exports);
 var import_utils = require("../../utils");
 var import_eventsHelper = require("../utils/eventsHelper");
+var import_progress = require("../progress");
 class CRCoverage {
   constructor(client) {
     this._jsCoverage = new JSCoverage(client);
     this._cssCoverage = new CSSCoverage(client);
   }
   async startJSCoverage(progress, options) {
-    progress.cleanupWhenAborted(() => this._jsCoverage.stop());
-    await progress.race(this._jsCoverage.start(options));
+    await (0, import_progress.raceUncancellableOperationWithCleanup)(progress, () => this._jsCoverage.start(options), () => this._jsCoverage.stop());
   }
   async stopJSCoverage() {
     return await this._jsCoverage.stop();
   }
   async startCSSCoverage(progress, options) {
-    progress.cleanupWhenAborted(() => this._cssCoverage.stop());
-    await progress.race(this._cssCoverage.start(options));
+    await (0, import_progress.raceUncancellableOperationWithCleanup)(progress, () => this._cssCoverage.start(options), () => this._cssCoverage.stop());
   }
   async stopCSSCoverage() {
     return await this._cssCoverage.stop();

package/lib/server/chromium/videoRecorder.js

@@ -22,13 +22,11 @@ __export(videoRecorder_exports, {
 });
 module.exports = __toCommonJS(videoRecorder_exports);
 var import_utils = require("../../utils");
-var import_instrumentation = require("../instrumentation");
 var import_page = require("../page");
 var import_processLauncher = require("../utils/processLauncher");
-var import_progress = require("../progress");
 const fps = 25;
 class VideoRecorder {
-  constructor(page, ffmpegPath, progress) {
+  constructor(page, ffmpegPath) {
     this._process = null;
     this._gracefullyClose = null;
     this._lastWritePromise = Promise.resolve();
@@ -37,47 +35,40 @@ class VideoRecorder {
     this._lastWriteTimestamp = 0;
     this._frameQueue = [];
     this._isStopped = false;
-    this._progress = progress;
     this._ffmpegPath = ffmpegPath;
     page.on(import_page.Page.Events.ScreencastFrame, (frame) => this.writeFrame(frame.buffer, frame.frameSwapWallTime / 1e3));
   }
   static async launch(page, ffmpegPath, options) {
     if (!options.outputFile.endsWith(".webm"))
       throw new Error("File must have .webm extension");
-    const controller = new import_progress.ProgressController((0, import_instrumentation.serverSideCallMetadata)(), page);
-    controller.setLogName("browser");
-    return await controller.run(async (progress) => {
-      const recorder = new VideoRecorder(page, ffmpegPath, progress);
-      progress.cleanupWhenAborted(() => recorder.stop());
-      await recorder._launch(options);
-      return recorder;
-    });
+    const recorder = new VideoRecorder(page, ffmpegPath);
+    await recorder._launch(options);
+    return recorder;
   }
   async _launch(options) {
     const w = options.width;
     const h = options.height;
     const args = `-loglevel error -f image2pipe -avioflags direct -fpsprobesize 0 -probesize 32 -analyzeduration 0 -c:v mjpeg -i pipe:0 -y -an -r ${fps} -c:v vp8 -qmin 0 -qmax 50 -crf 8 -deadline realtime -speed 8 -b:v 1M -threads 1 -vf pad=${w}:${h}:0:0:gray,crop=${w}:${h}:0:0`.split(" ");
     args.push(options.outputFile);
-    const progress = this._progress;
     const { launchedProcess, gracefullyClose } = await (0, import_processLauncher.launchProcess)({
       command: this._ffmpegPath,
       args,
       stdio: "stdin",
-      log: (message) => progress.log(message),
+      log: (message) => import_utils.debugLogger.log("browser", message),
       tempDirectories: [],
       attemptToGracefullyClose: async () => {
-        progress.log("Closing stdin...");
+        import_utils.debugLogger.log("browser", "Closing stdin...");
         launchedProcess.stdin.end();
       },
       onExit: (exitCode, signal) => {
-        progress.log(`ffmpeg onkill exitCode=${exitCode} signal=${signal}`);
+        import_utils.debugLogger.log("browser", `ffmpeg onkill exitCode=${exitCode} signal=${signal}`);
       }
     });
     launchedProcess.stdin.on("finish", () => {
-      progress.log("ffmpeg finished input.");
+      import_utils.debugLogger.log("browser", "ffmpeg finished input.");
     });
     launchedProcess.stdin.on("error", () => {
-      progress.log("ffmpeg error.");
+      import_utils.debugLogger.log("browser", "ffmpeg error.");
     });
     this._process = launchedProcess;
     this._gracefullyClose = gracefullyClose;
@@ -104,7 +95,7 @@ class VideoRecorder {
   async _sendFrame(frame) {
     return new Promise((f) => this._process.stdin.write(frame, f)).then((error) => {
       if (error)
-        this._progress.log(`ffmpeg failed to write: ${String(error)}`);
+        import_utils.debugLogger.log("browser", `ffmpeg failed to write: ${String(error)}`);
     });
   }
   async stop() {

package/lib/server/codegen/jsonl.js

@@ -34,7 +34,8 @@ class JsonlLanguageGenerator {
     const entry = {
       ...actionInContext.action,
       ...actionInContext.frame,
-      locator
+      locator,
+      ariaSnapshot: void 0
     };
     return JSON.stringify(entry);
   }

package/lib/server/debugController.js

@@ -65,17 +65,6 @@ class DebugController extends import_instrumentation.SdkObject {
       this._trackHierarchyListener = void 0;
     }
   }
-  async resetForReuse(progress) {
-    const contexts = /* @__PURE__ */ new Set();
-    for (const page of this._playwright.allPages())
-      contexts.add(page.browserContext);
-    for (const context of contexts)
-      await context.resetForReuse(progress, null);
-  }
-  async navigate(progress, url) {
-    for (const p of this._playwright.allPages())
-      await p.mainFrame().goto(progress, url);
-  }
   async setRecorderMode(progress, params) {
     await progress.race(this._closeBrowsersWithoutPages());
     if (params.mode === "none") {
@@ -120,10 +109,8 @@ class DebugController extends import_instrumentation.SdkObject {
   async hideHighlight(progress) {
     for (const recorder of await progress.race(this._allRecorders()))
       recorder.hideHighlightedSelector();
-    await this._playwright.hideHighlight();
-  }
-  allBrowsers() {
-    return [...this._playwright.allBrowsers()];
+    await Promise.all(this._playwright.allPages().map((p) => p.hideHighlight().catch(() => {
+    })));
   }
   async resume(progress) {
     for (const recorder of await progress.race(this._allRecorders()))
@@ -132,9 +119,6 @@ class DebugController extends import_instrumentation.SdkObject {
   kill() {
     (0, import_processLauncher.gracefullyProcessExitDoNotHang)(0);
   }
-  async closeAllBrowsers() {
-    await Promise.all(this.allBrowsers().map((browser) => browser.close({ reason: "Close all browsers requested" })));
-  }
   _emitSnapshot(initial) {
     const pageCount = this._playwright.allPages().length;
     if (initial && !pageCount)

package/lib/server/dispatchers/debugControllerDispatcher.js

@@ -52,12 +52,6 @@ class DebugControllerDispatcher extends import_dispatcher.Dispatcher {
   async setReportStateChanged(params, progress) {
     this._object.setReportStateChanged(params.enabled);
   }
-  async resetForReuse(params, progress) {
-    await this._object.resetForReuse(progress);
-  }
-  async navigate(params, progress) {
-    await this._object.navigate(progress, params.url);
-  }
   async setRecorderMode(params, progress) {
     await this._object.setRecorderMode(progress, params);
   }
@@ -73,9 +67,6 @@ class DebugControllerDispatcher extends import_dispatcher.Dispatcher {
   async kill(params, progress) {
     this._object.kill();
   }
-  async closeAllBrowsers(params, progress) {
-    await this._object.closeAllBrowsers();
-  }
   _onDispose() {
     import_utils.eventsHelper.removeEventListeners(this._listeners);
     this._object.dispose();

package/lib/server/dispatchers/localUtilsDispatcher.js

@@ -40,7 +40,6 @@ var import_jsonPipeDispatcher = require("../dispatchers/jsonPipeDispatcher");
 var import_socksInterceptor = require("../socksInterceptor");
 var import_transport = require("../transport");
 var import_network = require("../utils/network");
-var import_urlMatch = require("../../utils/isomorphic/urlMatch");
 class LocalUtilsDispatcher extends import_dispatcher.Dispatcher {
   constructor(scope, playwright) {
     const localUtils2 = new import_instrumentation.SdkObject(playwright, "localUtils", "localUtils");
@@ -112,10 +111,6 @@ class LocalUtilsDispatcher extends import_dispatcher.Dispatcher {
     pipe.on("close", () => transport.close());
     return { pipe, headers: transport.headers };
   }
-  async globToRegex(params, progress) {
-    const regex = (0, import_urlMatch.resolveGlobToRegexPattern)(params.baseURL, params.glob, params.webSocketUrl);
-    return { regex };
-  }
 }
 async function urlToWSEndpoint(progress, endpointURL) {
   if (endpointURL.startsWith("ws"))