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

package/lib/remote/playwrightConnection.js

@@ -33,15 +33,14 @@ var import_profiler = require("../server/utils/profiler");
 var import_utils = require("../utils");
 var import_debugLogger = require("../server/utils/debugLogger");
 class PlaywrightConnection {
-  constructor(lock, clientType, ws, options, preLaunched, id, onClose) {
+  constructor(lock, clientType, ws, options, playwright, preLaunched, id, onClose) {
     this._cleanups = [];
     this._disconnected = false;
     this._ws = ws;
+    this._playwright = playwright;
     this._preLaunched = preLaunched;
     this._options = options;
     options.launchOptions = filterLaunchOptions(options.launchOptions, options.allowFSPaths);
-    if (clientType === "reuse-browser" || clientType === "pre-launched-browser-or-android")
-      (0, import_assert.assert)(preLaunched.playwright);
     if (clientType === "pre-launched-browser-or-android")
       (0, import_assert.assert)(preLaunched.browser || preLaunched.androidDevice);
     this._onClose = onClose;
@@ -78,9 +77,9 @@ class PlaywrightConnection {
     this._root = new import_server.RootDispatcher(this._dispatcherConnection, async (scope, options2) => {
       await (0, import_profiler.startProfiling)();
       if (clientType === "reuse-browser")
-        return await this._initReuseBrowsersMode(scope);
+        return await this._initReuseBrowsersMode(scope, options2);
       if (clientType === "pre-launched-browser-or-android")
-        return this._preLaunched.browser ? await this._initPreLaunchedBrowserMode(scope) : await this._initPreLaunchedAndroidMode(scope);
+        return this._preLaunched.browser ? await this._initPreLaunchedBrowserMode(scope, options2) : await this._initPreLaunchedAndroidMode(scope);
       if (clientType === "launch-browser")
         return await this._initLaunchBrowserMode(scope, options2);
       throw new Error("Unsupported client type: " + clientType);
@@ -88,8 +87,7 @@ class PlaywrightConnection {
   }
   async _initLaunchBrowserMode(scope, options) {
     import_debugLogger.debugLogger.log("server", `[${this._id}] engaged launch mode for "${this._options.browserName}"`);
-    const playwright = (0, import_server.createPlaywright)({ sdkLanguage: options.sdkLanguage, isServer: true });
-    const ownedSocksProxy = await this._createOwnedSocksProxy(playwright);
+    const ownedSocksProxy = await this._createOwnedSocksProxy();
     let browserName = this._options.browserName;
     if ("bidi" === browserName) {
       if (this._options.launchOptions?.channel?.toLocaleLowerCase().includes("firefox"))
@@ -97,30 +95,29 @@ class PlaywrightConnection {
       else
         browserName = "bidiChromium";
     }
-    const browser = await playwright[browserName].launch((0, import_instrumentation.serverSideCallMetadata)(), this._options.launchOptions);
-    this._cleanups.push(async () => {
-      for (const browser2 of playwright.allBrowsers())
-        await browser2.close({ reason: "Connection terminated" });
-    });
+    const browser = await this._playwright[browserName].launch((0, import_instrumentation.serverSideCallMetadata)(), this._options.launchOptions);
+    browser.options.sdkLanguage = options.sdkLanguage;
+    this._cleanups.push(() => browser.close({ reason: "Connection terminated" }));
     browser.on(import_browser.Browser.Events.Disconnected, () => {
       this.close({ code: 1001, reason: "Browser closed" });
     });
-    return new import_server.PlaywrightDispatcher(scope, playwright, { socksProxy: ownedSocksProxy, preLaunchedBrowser: browser });
+    return new import_server.PlaywrightDispatcher(scope, this._playwright, { socksProxy: ownedSocksProxy, preLaunchedBrowser: browser, denyLaunch: true });
   }
-  async _initPreLaunchedBrowserMode(scope) {
+  async _initPreLaunchedBrowserMode(scope, options) {
     import_debugLogger.debugLogger.log("server", `[${this._id}] engaged pre-launched (browser) mode`);
-    const playwright = this._preLaunched.playwright;
     this._preLaunched.socksProxy?.setPattern(this._options.socksProxyPattern);
     const browser = this._preLaunched.browser;
+    browser.options.sdkLanguage = options.sdkLanguage;
     browser.on(import_browser.Browser.Events.Disconnected, () => {
       this.close({ code: 1001, reason: "Browser closed" });
     });
-    const playwrightDispatcher = new import_server.PlaywrightDispatcher(scope, playwright, {
+    const playwrightDispatcher = new import_server.PlaywrightDispatcher(scope, this._playwright, {
       socksProxy: this._preLaunched.socksProxy,
       preLaunchedBrowser: browser,
-      sharedBrowser: this._options.sharedBrowser
+      sharedBrowser: this._options.sharedBrowser,
+      denyLaunch: true
     });
-    for (const b of playwright.allBrowsers()) {
+    for (const b of this._playwright.allBrowsers()) {
       if (b !== browser)
         await b.close({ reason: "Connection terminated" });
     }
@@ -129,38 +126,35 @@ class PlaywrightConnection {
   }
   async _initPreLaunchedAndroidMode(scope) {
     import_debugLogger.debugLogger.log("server", `[${this._id}] engaged pre-launched (Android) mode`);
-    const playwright = this._preLaunched.playwright;
     const androidDevice = this._preLaunched.androidDevice;
     androidDevice.on(import_android.AndroidDevice.Events.Close, () => {
       this.close({ code: 1001, reason: "Android device disconnected" });
     });
-    const playwrightDispatcher = new import_server.PlaywrightDispatcher(scope, playwright, { preLaunchedAndroidDevice: androidDevice });
+    const playwrightDispatcher = new import_server.PlaywrightDispatcher(scope, this._playwright, { preLaunchedAndroidDevice: androidDevice, denyLaunch: true });
     this._cleanups.push(() => playwrightDispatcher.cleanup());
     return playwrightDispatcher;
   }
   _initDebugControllerMode() {
     import_debugLogger.debugLogger.log("server", `[${this._id}] engaged reuse controller mode`);
-    const playwright = this._preLaunched.playwright;
-    return new import_debugControllerDispatcher.DebugControllerDispatcher(this._dispatcherConnection, playwright.debugController);
+    return new import_debugControllerDispatcher.DebugControllerDispatcher(this._dispatcherConnection, this._playwright.debugController);
   }
-  async _initReuseBrowsersMode(scope) {
+  async _initReuseBrowsersMode(scope, options) {
     import_debugLogger.debugLogger.log("server", `[${this._id}] engaged reuse browsers mode for ${this._options.browserName}`);
-    const playwright = this._preLaunched.playwright;
     const requestedOptions = launchOptionsHash(this._options.launchOptions);
-    let browser = playwright.allBrowsers().find((b) => {
+    let browser = this._playwright.allBrowsers().find((b) => {
       if (b.options.name !== this._options.browserName)
         return false;
       const existingOptions = launchOptionsHash(b.options.originalLaunchOptions);
       return existingOptions === requestedOptions;
     });
-    for (const b of playwright.allBrowsers()) {
+    for (const b of this._playwright.allBrowsers()) {
       if (b === browser)
         continue;
       if (b.options.name === this._options.browserName && b.options.channel === this._options.launchOptions.channel)
         await b.close({ reason: "Connection terminated" });
     }
     if (!browser) {
-      browser = await playwright[this._options.browserName || "chromium"].launch((0, import_instrumentation.serverSideCallMetadata)(), {
+      browser = await this._playwright[this._options.browserName || "chromium"].launch((0, import_instrumentation.serverSideCallMetadata)(), {
         ...this._options.launchOptions,
         headless: !!process.env.PW_DEBUG_CONTROLLER_HEADLESS
       });
@@ -168,8 +162,9 @@ class PlaywrightConnection {
         this.close({ code: 1001, reason: "Browser closed" });
       });
     }
+    browser.options.sdkLanguage = options.sdkLanguage;
     this._cleanups.push(async () => {
-      for (const browser2 of playwright.allBrowsers()) {
+      for (const browser2 of this._playwright.allBrowsers()) {
         for (const context of browser2.contexts()) {
           if (!context.pages().length)
             await context.close({ reason: "Connection terminated" });
@@ -180,16 +175,18 @@ class PlaywrightConnection {
           await browser2.close({ reason: "Connection terminated" });
       }
     });
-    const playwrightDispatcher = new import_server.PlaywrightDispatcher(scope, playwright, { preLaunchedBrowser: browser });
+    const playwrightDispatcher = new import_server.PlaywrightDispatcher(scope, this._playwright, { preLaunchedBrowser: browser, denyLaunch: true });
     return playwrightDispatcher;
   }
-  async _createOwnedSocksProxy(playwright) {
-    if (!this._options.socksProxyPattern)
+  async _createOwnedSocksProxy() {
+    if (!this._options.socksProxyPattern) {
+      this._options.launchOptions.socksProxyPort = void 0;
       return;
+    }
     const socksProxy = new import_socksProxy.SocksProxy();
     socksProxy.setPattern(this._options.socksProxyPattern);
-    playwright.options.socksProxyPort = await socksProxy.listen(0);
-    import_debugLogger.debugLogger.log("server", `[${this._id}] started socks proxy on port ${playwright.options.socksProxyPort}`);
+    this._options.launchOptions.socksProxyPort = await socksProxy.listen(0);
+    import_debugLogger.debugLogger.log("server", `[${this._id}] started socks proxy on port ${this._options.launchOptions.socksProxyPort}`);
     this._cleanups.push(() => socksProxy.close());
     return socksProxy;
   }

package/lib/remote/playwrightServer.js

@@ -23,7 +23,6 @@ __export(playwrightServer_exports, {
 module.exports = __toCommonJS(playwrightServer_exports);
 var import_playwrightConnection = require("./playwrightConnection");
 var import_playwright = require("../server/playwright");
-var import_debugLogger = require("../server/utils/debugLogger");
 var import_semaphore = require("../utils/isomorphic/semaphore");
 var import_time = require("../utils/isomorphic/time");
 var import_wsServer = require("../server/utils/wsServer");
@@ -33,9 +32,10 @@ class PlaywrightServer {
   constructor(options) {
     this._options = options;
     if (options.preLaunchedBrowser)
-      this._preLaunchedPlaywright = options.preLaunchedBrowser.attribution.playwright;
+      this._playwright = options.preLaunchedBrowser.attribution.playwright;
     if (options.preLaunchedAndroidDevice)
-      this._preLaunchedPlaywright = options.preLaunchedAndroidDevice._android.attribution.playwright;
+      this._playwright = options.preLaunchedAndroidDevice._android.attribution.playwright;
+    this._playwright ??= (0, import_playwright.createPlaywright)({ sdkLanguage: "javascript", isServer: true });
     const browserSemaphore = new import_semaphore.Semaphore(this._options.maxConnections);
     const controllerSemaphore = new import_semaphore.Semaphore(1);
     const reuseBrowserSemaphore = new import_semaphore.Semaphore(1);
@@ -75,10 +75,6 @@ ${uaError}` };
         } catch (e) {
         }
         const isExtension = this._options.mode === "extension";
-        if (isExtension) {
-          if (!this._preLaunchedPlaywright)
-            this._preLaunchedPlaywright = (0, import_playwright.createPlaywright)({ sdkLanguage: "javascript", isServer: true });
-        }
         let clientType = "launch-browser";
         let semaphore = browserSemaphore;
         if (isExtension && url.searchParams.has("debug-controller")) {
@@ -102,8 +98,8 @@ ${uaError}` };
             allowFSPaths: this._options.mode === "extension",
             sharedBrowser: this._options.mode === "launchServerShared"
           },
+          this._playwright,
           {
-            playwright: this._preLaunchedPlaywright,
             browser: this._options.preLaunchedBrowser,
             androidDevice: this._options.preLaunchedAndroidDevice,
             socksProxy: this._options.preLaunchedSocksProxy
@@ -111,12 +107,6 @@ ${uaError}` };
           id,
           () => semaphore.release()
         );
-      },
-      onClose: async () => {
-        import_debugLogger.debugLogger.log("server", "closing browsers");
-        if (this._preLaunchedPlaywright)
-          await Promise.all(this._preLaunchedPlaywright.allBrowsers().map((browser) => browser.close({ reason: "Playwright Server stopped" })));
-        import_debugLogger.debugLogger.log("server", "closed browsers");
       }
     });
   }

package/lib/server/bidi/bidiChromium.js

@@ -130,12 +130,12 @@ class BidiChromium extends import_browserType.BrowserType {
     if (proxy) {
       const proxyURL = new URL(proxy.server);
       const isSocks = proxyURL.protocol === "socks5:";
-      if (isSocks && !this.attribution.playwright.options.socksProxyPort) {
+      if (isSocks && !options.socksProxyPort) {
         chromeArguments.push(`--host-resolver-rules="MAP * ~NOTFOUND , EXCLUDE ${proxyURL.hostname}"`);
       }
       chromeArguments.push(`--proxy-server=${proxy.server}`);
       const proxyBypassRules = [];
-      if (this.attribution.playwright.options.socksProxyPort)
+      if (options.socksProxyPort)
         proxyBypassRules.push("<-loopback>");
       if (proxy.bypass)
         proxyBypassRules.push(...proxy.bypass.split(",").map((t) => t.trim()).map((t) => t.startsWith(".") ? "*" + t : t));

package/lib/server/browser.js

@@ -45,6 +45,9 @@ class Browser extends import_instrumentation.SdkObject {
       Disconnected: "disconnected"
     };
   }
+  sdkLanguage() {
+    return this.options.sdkLanguage || this.attribution.playwright.options.sdkLanguage;
+  }
   async newContext(metadata, options) {
     (0, import_browserContext.validateBrowserContextOptions)(options, this.options);
     let clientCertificatesProxy;

package/lib/server/browserType.js

@@ -265,8 +265,8 @@ class BrowserType extends import_instrumentation.SdkObject {
       headless = false;
     if (downloadsPath && !import_path.default.isAbsolute(downloadsPath))
       downloadsPath = import_path.default.join(process.cwd(), downloadsPath);
-    if (this.attribution.playwright.options.socksProxyPort)
-      proxy = { server: `socks5://127.0.0.1:${this.attribution.playwright.options.socksProxyPort}` };
+    if (options.socksProxyPort)
+      proxy = { server: `socks5://127.0.0.1:${options.socksProxyPort}` };
     return { ...options, devtools, headless, downloadsPath, proxy };
   }
   _createUserDataDirArgMisuseError(userDataDirArg) {

package/lib/server/chromium/chromium.js

@@ -295,12 +295,12 @@ class Chromium extends import_browserType.BrowserType {
     if (proxy) {
       const proxyURL = new URL(proxy.server);
       const isSocks = proxyURL.protocol === "socks5:";
-      if (isSocks && !this.attribution.playwright.options.socksProxyPort) {
+      if (isSocks && !options.socksProxyPort) {
         chromeArguments.push(`--host-resolver-rules="MAP * ~NOTFOUND , EXCLUDE ${proxyURL.hostname}"`);
       }
       chromeArguments.push(`--proxy-server=${proxy.server}`);
       const proxyBypassRules = [];
-      if (this.attribution.playwright.options.socksProxyPort)
+      if (options.socksProxyPort)
         proxyBypassRules.push("<-loopback>");
       if (proxy.bypass)
         proxyBypassRules.push(...proxy.bypass.split(",").map((t) => t.trim()).map((t) => t.startsWith(".") ? "*" + t : t));

package/lib/server/chromium/crPage.js

@@ -736,7 +736,7 @@ class FrameSession {
   }
   async _createVideoRecorder(screencastId, options) {
     (0, import_assert.assert)(!this._screencastId);
-    const ffmpegPath = import_registry.registry.findExecutable("ffmpeg").executablePathOrDie(this._page.attribution.playwright.options.sdkLanguage);
+    const ffmpegPath = import_registry.registry.findExecutable("ffmpeg").executablePathOrDie(this._page.browserContext._browser.sdkLanguage());
     this._videoRecorder = await import_videoRecorder.VideoRecorder.launch(this._crPage._page, ffmpegPath, options);
     this._screencastId = screencastId;
   }

package/lib/server/dispatchers/androidDispatcher.js

@@ -29,9 +29,10 @@ var import_android = require("../android/android");
 var import_eventsHelper = require("../utils/eventsHelper");
 var import_instrumentation = require("../instrumentation");
 class AndroidDispatcher extends import_dispatcher.Dispatcher {
-  constructor(scope, android) {
+  constructor(scope, android, denyLaunch) {
     super(scope, android, "Android", {});
     this._type_Android = true;
+    this._denyLaunch = denyLaunch;
   }
   async devices(params) {
     const devices = await this._object.devices(params);
@@ -136,6 +137,8 @@ class AndroidDeviceDispatcher extends import_dispatcher.Dispatcher {
     await this._object.push(params.file, params.path, params.mode);
   }
   async launchBrowser(params) {
+    if (this.parentScope()._denyLaunch)
+      throw new Error(`Launching more browsers is not allowed.`);
     const context = await this._object.launchBrowser(params.pkg, params);
     return { context: import_browserContextDispatcher.BrowserContextDispatcher.from(this, context) };
   }
@@ -143,6 +146,8 @@ class AndroidDeviceDispatcher extends import_dispatcher.Dispatcher {
     await this._object.close();
   }
   async connectToWebView(params) {
+    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)) };
   }
 }

package/lib/server/dispatchers/browserTypeDispatcher.js

@@ -25,24 +25,31 @@ var import_browserContextDispatcher = require("./browserContextDispatcher");
 var import_browserDispatcher = require("./browserDispatcher");
 var import_dispatcher = require("./dispatcher");
 class BrowserTypeDispatcher extends import_dispatcher.Dispatcher {
-  constructor(scope, browserType) {
+  constructor(scope, browserType, denyLaunch) {
     super(scope, browserType, "BrowserType", {
       executablePath: browserType.executablePath(),
       name: browserType.name()
     });
     this._type_BrowserType = true;
+    this._denyLaunch = denyLaunch;
   }
   async launch(params, metadata) {
+    if (this._denyLaunch)
+      throw new Error(`Launching more browsers is not allowed.`);
     const browser = await this._object.launch(metadata, params);
     return { browser: new import_browserDispatcher.BrowserDispatcher(this, browser) };
   }
   async launchPersistentContext(params, metadata) {
+    if (this._denyLaunch)
+      throw new Error(`Launching more browsers is not allowed.`);
     const browserContext = await this._object.launchPersistentContext(metadata, params.userDataDir, params);
     const browserDispatcher = new import_browserDispatcher.BrowserDispatcher(this, browserContext._browser);
     const contextDispatcher = import_browserContextDispatcher.BrowserContextDispatcher.from(browserDispatcher, browserContext);
     return { browser: browserDispatcher, context: contextDispatcher };
   }
   async connectOverCDP(params, metadata) {
+    if (this._denyLaunch)
+      throw new Error(`Launching more browsers is not allowed.`);
     const browser = await this._object.connectOverCDP(metadata, params.endpointURL, params);
     const browserDispatcher = new import_browserDispatcher.BrowserDispatcher(this, browser);
     return {

package/lib/server/dispatchers/electronDispatcher.js

@@ -27,11 +27,14 @@ var import_dispatcher = require("./dispatcher");
 var import_jsHandleDispatcher = require("./jsHandleDispatcher");
 var import_electron = require("../electron/electron");
 class ElectronDispatcher extends import_dispatcher.Dispatcher {
-  constructor(scope, electron) {
+  constructor(scope, electron, denyLaunch) {
     super(scope, electron, "Electron", {});
     this._type_Electron = true;
+    this._denyLaunch = denyLaunch;
   }
   async launch(params) {
+    if (this._denyLaunch)
+      throw new Error(`Launching more browsers is not allowed.`);
     const electronApplication = await this._object.launch(params);
     return { electronApplication: new ElectronApplicationDispatcher(this, electronApplication) };
   }

package/lib/server/dispatchers/playwrightDispatcher.js

@@ -35,12 +35,13 @@ var import_instrumentation = require("../instrumentation");
 var import_eventsHelper = require("../utils/eventsHelper");
 class PlaywrightDispatcher extends import_dispatcher.Dispatcher {
   constructor(scope, playwright, options = {}) {
-    const chromium = new import_browserTypeDispatcher.BrowserTypeDispatcher(scope, playwright.chromium);
-    const firefox = new import_browserTypeDispatcher.BrowserTypeDispatcher(scope, playwright.firefox);
-    const webkit = new import_browserTypeDispatcher.BrowserTypeDispatcher(scope, playwright.webkit);
-    const bidiChromium = new import_browserTypeDispatcher.BrowserTypeDispatcher(scope, playwright.bidiChromium);
-    const bidiFirefox = new import_browserTypeDispatcher.BrowserTypeDispatcher(scope, playwright.bidiFirefox);
-    const android = new import_androidDispatcher.AndroidDispatcher(scope, playwright.android);
+    const denyLaunch = options.denyLaunch ?? false;
+    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 android = new import_androidDispatcher.AndroidDispatcher(scope, playwright.android, denyLaunch);
     const initializer = {
       chromium,
       firefox,
@@ -48,7 +49,7 @@ class PlaywrightDispatcher extends import_dispatcher.Dispatcher {
       bidiChromium,
       bidiFirefox,
       android,
-      electron: new import_electronDispatcher.ElectronDispatcher(scope, playwright.electron),
+      electron: new import_electronDispatcher.ElectronDispatcher(scope, playwright.electron, denyLaunch),
       utils: playwright.options.isServer ? void 0 : new import_localUtilsDispatcher.LocalUtilsDispatcher(scope, playwright),
       socksSupport: options.socksProxy ? new SocksSupportDispatcher(scope, playwright, options.socksProxy) : void 0
     };

package/lib/server/dom.js

@@ -79,7 +79,7 @@ class FrameExecutionContext extends js.ExecutionContext {
       const selectorsRegistry = this.frame._page.browserContext.selectors();
       for (const [name, { source: source2 }] of selectorsRegistry._engines)
         customEngines.push({ name, source: `(${source2})` });
-      const sdkLanguage = this.frame.attribution.playwright.options.sdkLanguage;
+      const sdkLanguage = this.frame._page.browserContext._browser.sdkLanguage();
       const options = {
         isUnderTest: (0, import_utils.isUnderTest)(),
         sdkLanguage,
@@ -305,7 +305,7 @@ class ElementHandle extends js.JSHandle {
       }
       if (!options.skipActionPreChecks && !options.force)
         await this._frame._page.performActionPreChecks(progress);
-      const result = await action();
+      const result = await action(retry);
       ++retry;
       if (result === "error:notvisible") {
         if (options.force)
@@ -336,21 +336,15 @@ class ElementHandle extends js.JSHandle {
   }
   async _retryPointerAction(progress, actionName, waitForEnabled, action, options) {
     const skipActionPreChecks = actionName === "move and up";
-    const scrollOptions = [
-      void 0,
-      { block: "end", inline: "end" },
-      { block: "center", inline: "center" },
-      { block: "start", inline: "start" }
-    ];
-    let scrollOptionIndex = 0;
-    return await this._retryAction(progress, actionName, async () => {
-      const forceScrollOptions = scrollOptions[scrollOptionIndex % scrollOptions.length];
-      const result = await this._performPointerAction(progress, actionName, waitForEnabled, action, forceScrollOptions, options);
-      if (typeof result === "object" && "hasPositionStickyOrFixed" in result && result.hasPositionStickyOrFixed)
-        ++scrollOptionIndex;
-      else
-        scrollOptionIndex = 0;
-      return result;
+    return await this._retryAction(progress, actionName, async (retry) => {
+      const scrollOptions = [
+        void 0,
+        { block: "end", inline: "end" },
+        { block: "center", inline: "center" },
+        { block: "start", inline: "start" }
+      ];
+      const forceScrollOptions = scrollOptions[retry % scrollOptions.length];
+      return await this._performPointerAction(progress, actionName, waitForEnabled, action, forceScrollOptions, options);
     }, { ...options, skipActionPreChecks });
   }
   async _performPointerAction(progress, actionName, waitForEnabled, action, forceScrollOptions, options) {
@@ -414,7 +408,7 @@ class ElementHandle extends js.JSHandle {
         const error = handle.rawValue();
         if (error === "error:notconnected")
           return error;
-        return JSON.parse(error);
+        return { hitTargetDescription: error };
       }
       hitTargetInterceptionHandle = handle;
       progress.cleanupWhenAborted(() => {

package/lib/server/frameSelectors.js

@@ -102,7 +102,7 @@ class FrameSelectors {
     for (const chunk of frameChunks) {
       (0, import_selectorParser.visitAllSelectorParts)(chunk, (part, nested) => {
         if (nested && part.name === "internal:control" && part.body === "enter-frame") {
-          const locator = (0, import_utils.asLocator)(this.frame._page.attribution.playwright.options.sdkLanguage, selector);
+          const locator = (0, import_utils.asLocator)(this.frame._page.browserContext._browser.sdkLanguage(), selector);
           throw new import_selectorParser.InvalidSelectorError(`Frame locators are not allowed inside composite locators, while querying "${locator}"`);
         }
       });

package/lib/server/frames.js

@@ -1434,7 +1434,7 @@ class Frame extends import_instrumentation.SdkObject {
     });
   }
   _asLocator(selector) {
-    return (0, import_utils.asLocator)(this._page.attribution.playwright.options.sdkLanguage, selector);
+    return (0, import_utils.asLocator)(this._page.browserContext._browser.sdkLanguage(), selector);
   }
 }
 class SignalBarrier {

package/lib/server/page.js

@@ -348,11 +348,11 @@ class Page extends import_instrumentation.SdkObject {
       }
       if (handler.resolved) {
         ++this._locatorHandlerRunningCounter;
-        progress.log(`  found ${(0, import_utils2.asLocator)(this.attribution.playwright.options.sdkLanguage, handler.selector)}, intercepting action to run the handler`);
+        progress.log(`  found ${(0, import_utils2.asLocator)(this.browserContext._browser.sdkLanguage(), handler.selector)}, intercepting action to run the handler`);
         const promise = handler.resolved.then(async () => {
           progress.throwIfAborted();
           if (!handler.noWaitAfter) {
-            progress.log(`  locator handler has finished, waiting for ${(0, import_utils2.asLocator)(this.attribution.playwright.options.sdkLanguage, handler.selector)} to be hidden`);
+            progress.log(`  locator handler has finished, waiting for ${(0, import_utils2.asLocator)(this.browserContext._browser.sdkLanguage(), handler.selector)} to be hidden`);
             await this.mainFrame().waitForSelectorInternal(progress, handler.selector, false, { state: "hidden" });
           } else {
             progress.log(`  locator handler has finished`);

package/lib/server/recorder/contextRecorder.js

@@ -57,7 +57,7 @@ class ContextRecorder extends import_events.EventEmitter {
     this._params = params;
     this._delegate = delegate;
     this._recorderSources = [];
-    const language = params.language || context.attribution.playwright.options.sdkLanguage;
+    const language = params.language || context._browser.sdkLanguage();
     this.setOutput(language, params.outputFile);
     const languageGeneratorOptions = {
       browserName: context._browser.options.name,

package/lib/server/recorder/recorderApp.js

@@ -109,7 +109,7 @@ class RecorderApp extends import_events.EventEmitter {
     };
   }
   static async _open(recorder, inspectedContext) {
-    const sdkLanguage = inspectedContext.attribution.playwright.options.sdkLanguage;
+    const sdkLanguage = inspectedContext._browser.sdkLanguage();
     const headed = !!inspectedContext._browser.options.headful;
     const recorderPlaywright = require("../playwright").createPlaywright({ sdkLanguage: "javascript", isInternalPlaywright: true });
     const { context, page } = await (0, import_launchApp2.launchApp)(recorderPlaywright.chromium, {

package/lib/server/trace/recorder/tracing.js

@@ -78,7 +78,7 @@ class Tracing extends import_instrumentation.SdkObject {
       platform: process.platform,
       wallTime: 0,
       monotonicTime: 0,
-      sdkLanguage: context.attribution.playwright.options.sdkLanguage,
+      sdkLanguage: this._sdkLanguage(),
       testIdAttributeName,
       contextId: context.guid
     };
@@ -90,6 +90,9 @@ class Tracing extends import_instrumentation.SdkObject {
       this._contextCreatedEvent.options = context._options;
     }
   }
+  _sdkLanguage() {
+    return this._context instanceof import_browserContext.BrowserContext ? this._context._browser.sdkLanguage() : this._context.attribution.playwright.options.sdkLanguage;
+  }
   async resetForReuse() {
     await this.stopChunk({ mode: "discard" }).catch(() => {
     });
@@ -101,7 +104,7 @@ class Tracing extends import_instrumentation.SdkObject {
       throw new Error("Cannot start tracing while stopping");
     if (this._state)
       throw new Error("Tracing has been already started");
-    this._contextCreatedEvent.sdkLanguage = this._context.attribution.playwright.options.sdkLanguage;
+    this._contextCreatedEvent.sdkLanguage = this._sdkLanguage();
     const traceName = options.name || (0, import_crypto.createGuid)();
     const tracesDir = this._createTracesDirIfNeeded();
     this._state = {

package/lib/server/trace/viewer/traceViewer.js

@@ -148,7 +148,6 @@ async function openTraceViewerApp(url, browserName, options) {
   const traceViewerPlaywright = (0, import_playwright.createPlaywright)({ sdkLanguage: "javascript", isInternalPlaywright: true });
   const traceViewerBrowser = (0, import_utils2.isUnderTest)() ? "chromium" : browserName;
   const { context, page } = await (0, import_launchApp2.launchApp)(traceViewerPlaywright[traceViewerBrowser], {
-    // TODO: store language in the trace.
     sdkLanguage: traceViewerPlaywright.options.sdkLanguage,
     windowSize: { width: 1280, height: 800 },
     persistentContextOptions: {

package/lib/server/utils/wsServer.js

@@ -112,7 +112,6 @@ class WSServer {
     this._wsServer = void 0;
     this.server = void 0;
     import_debugLogger.debugLogger.log("server", "closed server");
-    await this._delegate.onClose?.();
   }
 }
 // Annotate the CommonJS export names for ESM import in node:

package/lib/utils/isomorphic/protocolMetainfo.js

@@ -22,7 +22,7 @@ __export(protocolMetainfo_exports, {
 });
 module.exports = __toCommonJS(protocolMetainfo_exports);
 const methodMetainfo = /* @__PURE__ */ new Map([
-  ["APIRequestContext.fetch", { title: 'Fetch "{url}"' }],
+  ["APIRequestContext.fetch", { title: '{method} "{url}"' }],
   ["APIRequestContext.fetchResponseBody", { internal: true }],
   ["APIRequestContext.fetchLog", { internal: true }],
   ["APIRequestContext.storageState", { internal: true }],