playwright-core 1.54.0-alpha-2025-06-20 → 1.54.0-alpha-1750421372000

package/lib/server/browser.js

@@ -27,6 +27,7 @@ var import_download = require("./download");
 var import_instrumentation = require("./instrumentation");
 var import_page = require("./page");
 var import_socksClientCertificatesInterceptor = require("./socksClientCertificatesInterceptor");
+var import_progress = require("./progress");
 class Browser extends import_instrumentation.SdkObject {
   constructor(parent, options) {
     super(parent, "browser");
@@ -48,25 +49,25 @@ class Browser extends import_instrumentation.SdkObject {
   sdkLanguage() {
     return this.options.sdkLanguage || this.attribution.playwright.options.sdkLanguage;
   }
-  async newContext(metadata, options) {
+  newContextFromMetadata(metadata, options) {
+    const controller = new import_progress.ProgressController(metadata, this, "strict");
+    return controller.run((progress) => this.newContext(progress, options));
+  }
+  async newContext(progress, options) {
     (0, import_browserContext.validateBrowserContextOptions)(options, this.options);
     let clientCertificatesProxy;
     if (options.clientCertificates?.length) {
-      clientCertificatesProxy = new import_socksClientCertificatesInterceptor.ClientCertificatesProxy(options);
+      clientCertificatesProxy = await progress.raceWithCleanup(import_socksClientCertificatesInterceptor.ClientCertificatesProxy.create(options), (proxy) => proxy.close());
       options = { ...options };
-      options.proxyOverride = await clientCertificatesProxy.listen();
+      options.proxyOverride = clientCertificatesProxy.proxySettings();
       options.internalIgnoreHTTPSErrors = true;
     }
-    let context;
-    try {
-      context = await this.doCreateNewContext(options);
-    } catch (error) {
-      await clientCertificatesProxy?.close();
-      throw error;
-    }
+    const context = await progress.raceWithCleanup(this.doCreateNewContext(options), (context2) => context2.close({ reason: "Failed to create context" }));
     context._clientCertificatesProxy = clientCertificatesProxy;
+    if (options.__testHookBeforeSetStorageState)
+      await progress.race(options.__testHookBeforeSetStorageState());
     if (options.storageState)
-      await context.setStorageState(metadata, options.storageState);
+      await context.setStorageState(progress, options.storageState);
     this.emit(Browser.Events.Context, context);
     return context;
   }
@@ -75,7 +76,7 @@ class Browser extends import_instrumentation.SdkObject {
     if (!this._contextForReuse || hash !== this._contextForReuse.hash || !this._contextForReuse.context.canResetForReuse()) {
       if (this._contextForReuse)
         await this._contextForReuse.context.close({ reason: "Context reused" });
-      this._contextForReuse = { context: await this.newContext(metadata, params), hash };
+      this._contextForReuse = { context: await this.newContextFromMetadata(metadata, params), hash };
       return { context: this._contextForReuse.context, needsReset: false };
     }
     await this._contextForReuse.context.stopPendingOperations("Context recreated");

package/lib/server/browserContext.js

@@ -160,11 +160,11 @@ if (navigator.serviceWorker) navigator.serviceWorker.register = async () => { co
     return JSON.stringify(paramsCopy);
   }
   async resetForReuse(metadata, params) {
-    const controller = new import_progress.ProgressController(metadata, this);
+    const controller = new import_progress.ProgressController(metadata, this, "strict");
     return controller.run((progress) => this.resetForReuseImpl(progress, params));
   }
   async resetForReuseImpl(progress, params) {
-    await this.tracing.resetForReuse();
+    await progress.race(this.tracing.resetForReuse());
     if (params) {
       for (const key of paramsThatAllowContextReuse)
         this._options[key] = params[key];
@@ -180,18 +180,21 @@ if (navigator.serviceWorker) navigator.serviceWorker.register = async () => { co
       page = void 0;
     }
     await page?.mainFrame().gotoImpl(progress, "about:blank", {});
-    await this._resetStorage();
-    await this.clock.resetForReuse();
-    if (this._options.permissions)
-      await this.grantPermissions(this._options.permissions);
-    else
-      await this.clearPermissions();
-    await this.setExtraHTTPHeaders(this._options.extraHTTPHeaders || []);
-    await this.setGeolocation(this._options.geolocation);
-    await this.setOffline(!!this._options.offline);
-    await this.setUserAgent(this._options.userAgent);
-    await this.clearCache();
-    await this._resetCookies();
+    await this._resetStorage(progress);
+    const resetOptions = async () => {
+      await this.clock.resetForReuse();
+      if (this._options.permissions)
+        await this.grantPermissions(this._options.permissions);
+      else
+        await this.clearPermissions();
+      await this.setExtraHTTPHeaders(this._options.extraHTTPHeaders || []);
+      await this.setGeolocation(this._options.geolocation);
+      await this.setOffline(!!this._options.offline);
+      await this.setUserAgent(this._options.userAgent);
+      await this.clearCache();
+      await this._resetCookies();
+    };
+    await progress.race(resetOptions());
     await page?.resetForReuse(progress);
   }
   _browserClosed() {
@@ -297,13 +300,12 @@ if (navigator.serviceWorker) navigator.serviceWorker.register = async () => { co
   async _loadDefaultContextAsIs(progress) {
     if (!this.possiblyUninitializedPages().length) {
       const waitForEvent = import_helper.helper.waitForEvent(progress, this, BrowserContext.Events.Page);
-      progress.cleanupWhenAborted(() => waitForEvent.dispose);
       await Promise.race([waitForEvent.promise, this._closePromise]);
     }
     const page = this.possiblyUninitializedPages()[0];
     if (!page)
       return;
-    const pageOrError = await page.waitForInitializedOrError();
+    const pageOrError = await progress.race(page.waitForInitializedOrError());
     if (pageOrError instanceof Error)
       throw pageOrError;
     await page.mainFrame()._waitForLoadState(progress, "load");
@@ -315,7 +317,7 @@ if (navigator.serviceWorker) navigator.serviceWorker.register = async () => { co
       return;
     const browserName = this._browser.options.name;
     if (this._options.isMobile && browserName === "chromium" || this._options.locale && browserName === "webkit") {
-      await this.newPage(progress.metadata);
+      await this.newPage(progress, false);
       await defaultPage.close();
     }
   }
@@ -402,9 +404,13 @@ if (navigator.serviceWorker) navigator.serviceWorker.register = async () => { co
     }
     await this._closePromise;
   }
-  async newPage(metadata) {
-    const page = await this.doCreateNewPage(metadata.isServerSide);
-    const pageOrError = await page.waitForInitializedOrError();
+  newPageFromMetadata(metadata) {
+    const contoller = new import_progress.ProgressController(metadata, this, "strict");
+    return contoller.run((progress) => this.newPage(progress, false));
+  }
+  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.");
@@ -415,7 +421,11 @@ if (navigator.serviceWorker) navigator.serviceWorker.register = async () => { co
   addVisitedOrigin(origin) {
     this._origins.add(origin);
   }
-  async storageState(indexedDB = false) {
+  storageState(indexedDB = false) {
+    const controller = new import_progress.ProgressController((0, import_instrumentation.serverSideCallMetadata)(), this, "strict");
+    return controller.run((progress) => this.storageStateImpl(progress, indexedDB));
+  }
+  async storageStateImpl(progress, indexedDB) {
     const result = {
       cookies: await this.cookies(),
       origins: []
@@ -440,16 +450,15 @@ if (navigator.serviceWorker) navigator.serviceWorker.register = async () => { co
       }
     }
     if (originsToSave.size) {
-      const internalMetadata = (0, import_instrumentation.serverSideCallMetadata)();
-      const page = await this.newPage(internalMetadata);
-      page.addRequestInterceptor((route) => {
+      const page = await this.newPage(progress, true);
+      await progress.race(page.addRequestInterceptor((route) => {
         route.fulfill({ body: "<html></html>" }).catch(() => {
         });
-      }, "prepend");
+      }, "prepend"));
       for (const origin of originsToSave) {
         const frame = page.mainFrame();
-        await frame.goto(internalMetadata, origin, { timeout: 0 });
-        const storage = await frame.evaluateExpression(collectScript, { world: "utility" });
+        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 });
       }
@@ -457,28 +466,23 @@ if (navigator.serviceWorker) navigator.serviceWorker.register = async () => { co
     }
     return result;
   }
-  async _resetStorage() {
+  async _resetStorage(progress) {
     const oldOrigins = this._origins;
     const newOrigins = new Map(this._options.storageState?.origins?.map((p) => [p.origin, p]) || []);
     if (!oldOrigins.size && !newOrigins.size)
       return;
     let page = this.pages()[0];
-    const internalMetadata = (0, import_instrumentation.serverSideCallMetadata)();
-    page = page || await this.newPage({
-      ...internalMetadata,
-      // Do not mark this page as internal, because we will leave it for later reuse
-      // as a user-visible page.
-      isServerSide: false
-    });
+    page = page || await this.newPage(progress, false);
     const interceptor = (route) => {
       route.fulfill({ body: "<html></html>" }).catch(() => {
       });
     };
-    await page.addRequestInterceptor(interceptor, "prepend");
+    progress.cleanupWhenAborted(() => page.removeRequestInterceptor(interceptor));
+    await progress.race(page.addRequestInterceptor(interceptor, "prepend"));
     for (const origin of /* @__PURE__ */ new Set([...oldOrigins, ...newOrigins.keys()])) {
       const frame = page.mainFrame();
-      await frame.goto(internalMetadata, origin, { timeout: 0 });
-      await frame.resetStorageForCurrentOriginBestEffort(newOrigins.get(origin));
+      await frame.gotoImpl(progress, origin, {});
+      await progress.race(frame.resetStorageForCurrentOriginBestEffort(newOrigins.get(origin)));
     }
     await page.removeRequestInterceptor(interceptor);
     this._origins = /* @__PURE__ */ new Set([...newOrigins.keys()]);
@@ -491,28 +495,27 @@ if (navigator.serviceWorker) navigator.serviceWorker.register = async () => { co
   isSettingStorageState() {
     return this._settingStorageState;
   }
-  async setStorageState(metadata, state) {
+  async setStorageState(progress, state) {
     this._settingStorageState = true;
     try {
       if (state.cookies)
-        await this.addCookies(state.cookies);
+        await progress.race(this.addCookies(state.cookies));
       if (state.origins && state.origins.length) {
-        const internalMetadata = (0, import_instrumentation.serverSideCallMetadata)();
-        const page = await this.newPage(internalMetadata);
-        await page.addRequestInterceptor((route) => {
+        const page = await this.newPage(progress, true);
+        await progress.race(page.addRequestInterceptor((route) => {
           route.fulfill({ body: "<html></html>" }).catch(() => {
           });
-        }, "prepend");
+        }, "prepend"));
         for (const originState of state.origins) {
           const frame = page.mainFrame();
-          await frame.goto(metadata, originState.origin, { timeout: 0 });
+          await frame.gotoImpl(progress, originState.origin, {});
           const restoreScript = `(() => {
             const module = {};
             ${rawStorageSource.source}
             const script = new (module.exports.StorageScript())(${this._browser.options.name === "firefox"});
             return script.restore(${JSON.stringify(originState)});
           })()`;
-          await frame.evaluateExpression(restoreScript, { world: "utility" });
+          await progress.race(frame.evaluateExpression(restoreScript, { world: "utility" }));
         }
         await page.close();
       }

package/lib/server/browserType.js

@@ -67,7 +67,7 @@ class BrowserType extends import_instrumentation.SdkObject {
   }
   async launch(metadata, options, protocolLogger) {
     options = this._validateLaunchOptions(options);
-    const controller = new import_progress.ProgressController(metadata, this);
+    const controller = new import_progress.ProgressController(metadata, this, "strict");
     const browser = await controller.run((progress) => {
       const seleniumHubUrl = options.__testHookSeleniumRemoteURL || process.env.SELENIUM_REMOTE_URL;
       if (seleniumHubUrl)
@@ -80,16 +80,15 @@ class BrowserType extends import_instrumentation.SdkObject {
   }
   async launchPersistentContext(metadata, userDataDir, options) {
     const launchOptions = this._validateLaunchOptions(options);
-    const controller = new import_progress.ProgressController(metadata, this);
+    const controller = new import_progress.ProgressController(metadata, this, "strict");
     const browser = await controller.run(async (progress) => {
       let clientCertificatesProxy;
       if (options.clientCertificates?.length) {
-        clientCertificatesProxy = new import_socksClientCertificatesInterceptor.ClientCertificatesProxy(options);
-        launchOptions.proxyOverride = await clientCertificatesProxy?.listen();
+        clientCertificatesProxy = await progress.raceWithCleanup(import_socksClientCertificatesInterceptor.ClientCertificatesProxy.create(options), (proxy) => proxy.close());
+        launchOptions.proxyOverride = clientCertificatesProxy.proxySettings();
         options = { ...options };
         options.internalIgnoreHTTPSErrors = true;
       }
-      progress.cleanupWhenAborted(() => clientCertificatesProxy?.close());
       const browser2 = await this._innerLaunchWithRetries(progress, launchOptions, options, import_helper.helper.debugProtocolLogger(), userDataDir).catch((e) => {
         throw this._rewriteStartupLog(e);
       });
@@ -115,7 +114,7 @@ class BrowserType extends import_instrumentation.SdkObject {
     const browserLogsCollector = new import_debugLogger.RecentLogsCollector();
     const { browserProcess, userDataDir, artifactsDir, transport } = await this._launchProcess(progress, options, !!persistent, browserLogsCollector, maybeUserDataDir);
     if (options.__testHookBeforeCreateBrowser)
-      await options.__testHookBeforeCreateBrowser();
+      await progress.race(options.__testHookBeforeCreateBrowser());
     const browserOptions = {
       name: this._name,
       isChromium: this._name === "chromium",
@@ -137,23 +136,19 @@ class BrowserType extends import_instrumentation.SdkObject {
     if (persistent)
       (0, import_browserContext.validateBrowserContextOptions)(persistent, browserOptions);
     copyTestHooks(options, browserOptions);
-    const browser = await this.connectToTransport(transport, browserOptions, browserLogsCollector);
+    const browser = await progress.race(this.connectToTransport(transport, browserOptions, browserLogsCollector));
     browser._userDataDirForTest = userDataDir;
     if (persistent && !options.ignoreAllDefaultArgs)
       await browser._defaultContext._loadDefaultContext(progress);
     return browser;
   }
-  async _launchProcess(progress, options, isPersistent, browserLogsCollector, userDataDir) {
+  async _prepareToLaunch(options, isPersistent, userDataDir) {
     const {
       ignoreDefaultArgs,
       ignoreAllDefaultArgs,
       args = [],
-      executablePath = null,
-      handleSIGINT = true,
-      handleSIGTERM = true,
-      handleSIGHUP = true
+      executablePath = null
     } = options;
-    const env = options.env ? (0, import_processLauncher.envArrayToObject)(options.env) : process.env;
     await this._createArtifactDirs(options);
     const tempDirectories = [];
     const artifactsDir = await import_fs.default.promises.mkdtemp(import_path.default.join(import_os.default.tmpdir(), "playwright-artifacts-"));
@@ -186,13 +181,24 @@ class BrowserType extends import_instrumentation.SdkObject {
       executable = registryExecutable.executablePathOrDie(this.attribution.playwright.options.sdkLanguage);
       await import_registry.registry.validateHostRequirementsForExecutablesIfNeeded([registryExecutable], this.attribution.playwright.options.sdkLanguage);
     }
+    return { executable, browserArguments, userDataDir, artifactsDir, tempDirectories };
+  }
+  async _launchProcess(progress, options, isPersistent, browserLogsCollector, userDataDir) {
+    const {
+      handleSIGINT = true,
+      handleSIGTERM = true,
+      handleSIGHUP = true
+    } = 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();
     const { launchedProcess, gracefullyClose, kill } = await (0, import_processLauncher.launchProcess)({
-      command: executable,
-      args: browserArguments,
-      env: this.amendEnvironment(env, userDataDir, executable, browserArguments),
+      command: prepared.executable,
+      args: prepared.browserArguments,
+      env: this.amendEnvironment(env, prepared.userDataDir, prepared.executable, prepared.browserArguments),
       handleSIGINT,
       handleSIGTERM,
       handleSIGHUP,
@@ -201,7 +207,7 @@ class BrowserType extends import_instrumentation.SdkObject {
         browserLogsCollector.log(message);
       },
       stdio: "pipe",
-      tempDirectories,
+      tempDirectories: prepared.tempDirectories,
       attemptToGracefullyClose: async () => {
         if (options.__testHookGracefullyClose)
           await options.__testHookGracefullyClose();
@@ -234,7 +240,7 @@ class BrowserType extends import_instrumentation.SdkObject {
       kill
     };
     progress.cleanupWhenAborted(() => closeOrKill(progress.timeUntilDeadline()));
-    const { wsEndpoint } = await Promise.race([
+    const { wsEndpoint } = await progress.race([
       this.waitForReadyState(options, browserLogsCollector),
       exitPromise.then(() => ({ wsEndpoint: void 0 }))
     ]);
@@ -244,7 +250,8 @@ class BrowserType extends import_instrumentation.SdkObject {
       const stdio = launchedProcess.stdio;
       transport = new import_pipeTransport.PipeTransport(stdio[3], stdio[4]);
     }
-    return { browserProcess, artifactsDir, userDataDir, transport };
+    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

@@ -62,7 +62,7 @@ class Chromium extends import_browserType.BrowserType {
       this._devtools = this._createDevTools();
   }
   async connectOverCDP(metadata, endpointURL, options) {
-    const controller = new import_progress.ProgressController(metadata, this);
+    const controller = new import_progress.ProgressController(metadata, this, "strict");
     return controller.run(async (progress) => {
       return await this._connectOverCDPInternal(progress, endpointURL, options);
     }, options.timeout);
@@ -75,10 +75,10 @@ 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 artifactsDir = await import_fs.default.promises.mkdtemp(ARTIFACTS_FOLDER);
+    const artifactsDir = await progress.race(import_fs.default.promises.mkdtemp(ARTIFACTS_FOLDER));
     const wsEndpoint = await urlToWSEndpoint(progress, endpointURL, headersMap);
-    progress.throwIfAborted();
     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]);
@@ -105,8 +105,7 @@ class Chromium extends import_browserType.BrowserType {
       originalLaunchOptions: { timeout: options.timeout }
     };
     (0, import_browserContext.validateBrowserContextOptions)(persistent, browserOptions);
-    progress.throwIfAborted();
-    const browser = await import_crBrowser.CRBrowser.connect(this.attribution.playwright, chromeTransport, 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;
@@ -158,7 +157,7 @@ class Chromium extends import_browserType.BrowserType {
     transport.send(message);
   }
   async _launchWithSeleniumHub(progress, hubUrl, options) {
-    await this._createArtifactDirs(options);
+    await progress.race(this._createArtifactDirs(options));
     if (!hubUrl.endsWith("/"))
       hubUrl = hubUrl + "/";
     const args = this._innerDefaultArgs(options);
@@ -340,12 +339,15 @@ async function urlToWSEndpoint(progress, endpointURL, headers) {
     return endpointURL;
   progress.log(`<ws preparing> retrieving websocket url from ${endpointURL}`);
   const url = new URL(endpointURL);
+  if (!url.pathname.endsWith("/"))
+    url.pathname = url.pathname + "/";
   url.pathname += "json/version/";
   const httpURL = url.toString();
   const json = await (0, import_network.fetchData)(
     {
       url: httpURL,
-      headers
+      headers,
+      timeout: progress.timeUntilDeadline()
     },
     async (_, resp) => new Error(`Unexpected status ${resp.statusCode} when connecting to ${httpURL}.
 This does not look like a DevTools server, try connecting via ws://.`)

package/lib/server/chromium/videoRecorder.js

@@ -44,10 +44,11 @@ class VideoRecorder {
   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);
+    const controller = new import_progress.ProgressController((0, import_instrumentation.serverSideCallMetadata)(), page, "strict");
     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;
     });

package/lib/server/debugController.js

@@ -92,7 +92,7 @@ class DebugController extends import_instrumentation.SdkObject {
     if (!pages.length) {
       const [browser] = this._playwright.allBrowsers();
       const { context } = await browser.newContextForReuse({}, internalMetadata);
-      await context.newPage(internalMetadata);
+      await context.newPageFromMetadata(internalMetadata);
     }
     if (params.testIdAttributeName) {
       for (const page of this._playwright.allPages())

package/lib/server/dispatchers/androidDispatcher.js

@@ -136,19 +136,19 @@ class AndroidDeviceDispatcher extends import_dispatcher.Dispatcher {
   async push(params) {
     await this._object.push(params.file, params.path, params.mode);
   }
-  async launchBrowser(params) {
+  async launchBrowser(params, metadata) {
     if (this.parentScope()._denyLaunch)
       throw new Error(`Launching more browsers is not allowed.`);
-    const context = await this._object.launchBrowser(params.pkg, params);
+    const context = await this._object.launchBrowser(metadata, params.pkg, params);
     return { context: import_browserContextDispatcher.BrowserContextDispatcher.from(this, context) };
   }
   async close(params) {
     await this._object.close();
   }
-  async connectToWebView(params) {
+  async connectToWebView(params, metadata) {
     if (this.parentScope()._denyLaunch)
       throw new Error(`Launching more browsers is not allowed.`);
-    return { context: import_browserContextDispatcher.BrowserContextDispatcher.from(this, await this._object.connectToWebView(params.socketName)) };
+    return { context: import_browserContextDispatcher.BrowserContextDispatcher.from(this, await this._object.connectToWebView(metadata, params.socketName)) };
   }
 }
 class SocketSdkObject extends import_instrumentation.SdkObject {

package/lib/server/dispatchers/browserContextDispatcher.js

@@ -221,7 +221,7 @@ class BrowserContextDispatcher extends import_dispatcher.Dispatcher {
     this._bindings.push(binding);
   }
   async newPage(params, metadata) {
-    return { page: import_pageDispatcher.PageDispatcher.from(this, await this._context.newPage(metadata)) };
+    return { page: import_pageDispatcher.PageDispatcher.from(this, await this._context.newPageFromMetadata(metadata)) };
   }
   async cookies(params) {
     return { cookies: await this._context.cookies(params.urls) };

package/lib/server/dispatchers/browserDispatcher.js

@@ -48,13 +48,13 @@ class BrowserDispatcher extends import_dispatcher.Dispatcher {
   }
   async newContext(params, metadata) {
     if (!this._options.isolateContexts) {
-      const context2 = await this._object.newContext(metadata, params);
+      const context2 = await this._object.newContextFromMetadata(metadata, params);
       const contextDispatcher2 = import_browserContextDispatcher.BrowserContextDispatcher.from(this, context2);
       return { context: contextDispatcher2 };
     }
     if (params.recordVideo)
       params.recordVideo.dir = this._object.options.artifactsDir;
-    const context = await this._object.newContext(metadata, params);
+    const context = await this._object.newContextFromMetadata(metadata, params);
     this._isolatedContexts.add(context);
     context.on(import_browserContext.BrowserContext.Events.Close, () => this._isolatedContexts.delete(context));
     const contextDispatcher = import_browserContextDispatcher.BrowserContextDispatcher.from(this, context);

package/lib/server/dispatchers/electronDispatcher.js

@@ -32,10 +32,10 @@ class ElectronDispatcher extends import_dispatcher.Dispatcher {
     this._type_Electron = true;
     this._denyLaunch = denyLaunch;
   }
-  async launch(params) {
+  async launch(params, metadata) {
     if (this._denyLaunch)
       throw new Error(`Launching more browsers is not allowed.`);
-    const electronApplication = await this._object.launch(params);
+    const electronApplication = await this._object.launch(metadata, params);
     return { electronApplication: new ElectronApplicationDispatcher(this, electronApplication) };
   }
 }

package/lib/server/dispatchers/frameDispatcher.js

@@ -196,7 +196,7 @@ class FrameDispatcher extends import_dispatcher.Dispatcher {
     return await this._frame.waitForTimeout(metadata, params.timeout);
   }
   async waitForFunction(params, metadata) {
-    return { handle: import_elementHandlerDispatcher.ElementHandleDispatcher.fromJSOrElementHandle(this, await this._frame._waitForFunctionExpression(metadata, params.expression, params.isFunction, (0, import_jsHandleDispatcher.parseArgument)(params.arg), params)) };
+    return { handle: import_elementHandlerDispatcher.ElementHandleDispatcher.fromJSOrElementHandle(this, await this._frame.waitForFunctionExpression(metadata, params.expression, params.isFunction, (0, import_jsHandleDispatcher.parseArgument)(params.arg), params)) };
   }
   async title(params, metadata) {
     return { value: await this._frame.title() };

package/lib/server/dispatchers/localUtilsDispatcher.js

@@ -79,7 +79,7 @@ class LocalUtilsDispatcher extends import_dispatcher.Dispatcher {
     return await localUtils.addStackToTracingNoReply(this._stackSessions, params);
   }
   async connect(params, metadata) {
-    const controller = new import_progress.ProgressController(metadata, this._object);
+    const controller = new import_progress.ProgressController(metadata, this._object, "strict");
     return await controller.run(async (progress) => {
       const wsHeaders = {
         "User-Agent": (0, import_userAgent.getUserAgent)(),
@@ -138,7 +138,6 @@ async function urlToWSEndpoint(progress, endpointURL) {
     return new Error(`Unexpected status ${response.statusCode} when connecting to ${fetchUrl.toString()}.
 This does not look like a Playwright server, try connecting via ws://.`);
   });
-  progress.throwIfAborted();
   const wsUrl = new URL(endpointURL);
   let wsEndpointPath = JSON.parse(json).wsEndpointPath;
   if (wsEndpointPath.startsWith("/"))

package/lib/server/dispatchers/playwrightDispatcher.js

@@ -39,15 +39,15 @@ class PlaywrightDispatcher extends import_dispatcher.Dispatcher {
     const chromium = new import_browserTypeDispatcher.BrowserTypeDispatcher(scope, playwright.chromium, denyLaunch);
     const firefox = new import_browserTypeDispatcher.BrowserTypeDispatcher(scope, playwright.firefox, denyLaunch);
     const webkit = new import_browserTypeDispatcher.BrowserTypeDispatcher(scope, playwright.webkit, denyLaunch);
-    const bidiChromium = new import_browserTypeDispatcher.BrowserTypeDispatcher(scope, playwright.bidiChromium, denyLaunch);
-    const bidiFirefox = new import_browserTypeDispatcher.BrowserTypeDispatcher(scope, playwright.bidiFirefox, denyLaunch);
+    const _bidiChromium = new import_browserTypeDispatcher.BrowserTypeDispatcher(scope, playwright._bidiChromium, denyLaunch);
+    const _bidiFirefox = new import_browserTypeDispatcher.BrowserTypeDispatcher(scope, playwright._bidiFirefox, denyLaunch);
     const android = new import_androidDispatcher.AndroidDispatcher(scope, playwright.android, denyLaunch);
     const initializer = {
       chromium,
       firefox,
       webkit,
-      bidiChromium,
-      bidiFirefox,
+      _bidiChromium,
+      _bidiFirefox,
       android,
       electron: new import_electronDispatcher.ElectronDispatcher(scope, playwright.electron, denyLaunch),
       utils: playwright.options.isServer ? void 0 : new import_localUtilsDispatcher.LocalUtilsDispatcher(scope, playwright),
@@ -55,23 +55,7 @@ class PlaywrightDispatcher extends import_dispatcher.Dispatcher {
     };
     let browserDispatcher;
     if (options.preLaunchedBrowser) {
-      let browserTypeDispatcher;
-      switch (options.preLaunchedBrowser.options.name) {
-        case "chromium":
-          browserTypeDispatcher = chromium;
-          break;
-        case "firefox":
-          browserTypeDispatcher = firefox;
-          break;
-        case "webkit":
-          browserTypeDispatcher = webkit;
-          break;
-        case "bidi":
-          browserTypeDispatcher = options.preLaunchedBrowser.options.channel?.includes("firefox") ? bidiFirefox : bidiChromium;
-          break;
-        default:
-          throw new Error(`Unknown browser name: ${options.preLaunchedBrowser.options.name}`);
-      }
+      const browserTypeDispatcher = initializer[options.preLaunchedBrowser.options.name];
       browserDispatcher = new import_browserDispatcher.BrowserDispatcher(browserTypeDispatcher, options.preLaunchedBrowser, {
         ignoreStopAndKill: true,
         isolateContexts: !options.sharedBrowser

package/lib/server/dom.js

@@ -43,7 +43,6 @@ var js = __toESM(require("./javascript"));
 var import_progress = require("./progress");
 var import_utils = require("../utils");
 var import_fileUploadUtils = require("./fileUploadUtils");
-var import_protocolError = require("./protocolError");
 var rawInjectedScriptSource = __toESM(require("../generated/injectedScriptSource"));
 class NonRecoverableDOMError extends Error {
 }
@@ -124,7 +123,7 @@ class ElementHandle extends js.JSHandle {
       const utility = await this._frame._utilityContext();
       return await utility.evaluate(pageFunction, [await utility.injectedScript(), this, arg]);
     } catch (e) {
-      if ((0, import_progress.isAbortError)(e) || js.isJavaScriptErrorInEvaluate(e) || (0, import_protocolError.isSessionClosedError)(e))
+      if (this._frame.isNonRetriableError(e))
         throw e;
       return "error:notconnected";
     }
@@ -134,7 +133,7 @@ class ElementHandle extends js.JSHandle {
       const utility = await this._frame._utilityContext();
       return await utility.evaluateHandle(pageFunction, [await utility.injectedScript(), this, arg]);
     } catch (e) {
-      if ((0, import_progress.isAbortError)(e) || js.isJavaScriptErrorInEvaluate(e) || (0, import_protocolError.isSessionClosedError)(e))
+      if (this._frame.isNonRetriableError(e))
         throw e;
       return "error:notconnected";
     }
@@ -732,7 +731,7 @@ class ElementHandle extends js.JSHandle {
     return await this.evaluateInUtility(([injected, element, options2]) => injected.ariaSnapshot(element, options2), options);
   }
   async screenshot(metadata, options) {
-    const controller = new import_progress.ProgressController(metadata, this);
+    const controller = new import_progress.ProgressController(metadata, this, "strict");
     return controller.run(
       (progress) => this._page.screenshotter.screenshotElement(progress, this, options),
       options.timeout