playwright-core 1.56.0-alpha-2025-10-01 → 1.56.0-beta-1759412259000

package/browsers.json

@@ -27,13 +27,13 @@
     },
     {
       "name": "firefox",
-      "revision": "1492",
+      "revision": "1495",
       "installByDefault": true,
       "browserVersion": "142.0.1"
     },
     {
       "name": "firefox-beta",
-      "revision": "1487",
+      "revision": "1490",
       "installByDefault": false,
       "browserVersion": "143.0b10"
     },

package/lib/browserServerImpl.js

@@ -49,8 +49,8 @@ class BrowserServerLauncherImpl {
     const playwright = (0, import_playwright.createPlaywright)({ sdkLanguage: "javascript", isServer: true });
     const metadata = { id: "", startTime: 0, endTime: 0, type: "Internal", method: "", params: {}, log: [], internal: true };
     const validatorContext = {
-      tChannelImpl: (names, arg, path) => {
-        throw new validatorPrimitives.ValidationError(`${path}: channels are not expected in launchServer`);
+      tChannelImpl: (names, arg, path2) => {
+        throw new validatorPrimitives.ValidationError(`${path2}: channels are not expected in launchServer`);
       },
       binary: "buffer",
       isUnderTest: import_debug.isUnderTest
@@ -82,11 +82,8 @@ class BrowserServerLauncherImpl {
       (0, import_stackTrace.rewriteErrorMessage)(e, `${e.message} Failed to launch browser.${log}`);
       throw e;
     }
-    return this.launchServerOnExistingBrowser(browser, options);
-  }
-  async launchServerOnExistingBrowser(browser, options) {
     const path = options.wsPath ? options.wsPath.startsWith("/") ? options.wsPath : `/${options.wsPath}` : `/${(0, import_crypto.createGuid)()}`;
-    const server = new import_playwrightServer.PlaywrightServer({ mode: options._sharedBrowser ? "launchServerShared" : "launchServer", path, maxConnections: Infinity, preLaunchedBrowser: browser, debugController: options._debugController });
+    const server = new import_playwrightServer.PlaywrightServer({ mode: options._sharedBrowser ? "launchServerShared" : "launchServer", path, maxConnections: Infinity, preLaunchedBrowser: browser });
     const wsEndpoint = await server.listen(options.port, options.host);
     const browserServer = new import_utilsBundle.ws.EventEmitter();
     browserServer.process = () => browser.options.browserProcess.process;

package/lib/client/browser.js

@@ -120,16 +120,6 @@ class Browser extends import_channelOwner.ChannelOwner {
   async newBrowserCDPSession() {
     return import_cdpSession.CDPSession.from((await this._channel.newBrowserCDPSession()).session);
   }
-  async _launchServer(options = {}) {
-    const serverLauncher = this._browserType._serverLauncher;
-    const browserImpl = this._connection.toImpl?.(this);
-    if (!serverLauncher || !browserImpl)
-      throw new Error("Launching server is not supported");
-    return await serverLauncher.launchServerOnExistingBrowser(browserImpl, {
-      _sharedBrowser: true,
-      ...options
-    });
-  }
   async startTracing(page, options = {}) {
     this._path = options.path;
     await this._channel.startTracing({ ...options, page: page ? page._channel : void 0 });

package/lib/protocol/validator.js

@@ -450,17 +450,7 @@ import_validatorPrimitives.scheme.DebugControllerSetModeRequestedEvent = (0, imp
   mode: import_validatorPrimitives.tString
 });
 import_validatorPrimitives.scheme.DebugControllerStateChangedEvent = (0, import_validatorPrimitives.tObject)({
-  pageCount: import_validatorPrimitives.tInt,
-  browsers: (0, import_validatorPrimitives.tArray)((0, import_validatorPrimitives.tObject)({
-    id: import_validatorPrimitives.tString,
-    name: import_validatorPrimitives.tString,
-    channel: (0, import_validatorPrimitives.tOptional)(import_validatorPrimitives.tString),
-    contexts: (0, import_validatorPrimitives.tArray)((0, import_validatorPrimitives.tObject)({
-      pages: (0, import_validatorPrimitives.tArray)((0, import_validatorPrimitives.tObject)({
-        url: import_validatorPrimitives.tString
-      }))
-    }))
-  }))
+  pageCount: import_validatorPrimitives.tInt
 });
 import_validatorPrimitives.scheme.DebugControllerSourceChangedEvent = (0, import_validatorPrimitives.tObject)({
   text: import_validatorPrimitives.tString,
@@ -481,7 +471,6 @@ import_validatorPrimitives.scheme.DebugControllerSetReportStateChangedParams = (
 });
 import_validatorPrimitives.scheme.DebugControllerSetReportStateChangedResult = (0, import_validatorPrimitives.tOptional)((0, import_validatorPrimitives.tObject)({}));
 import_validatorPrimitives.scheme.DebugControllerSetRecorderModeParams = (0, import_validatorPrimitives.tObject)({
-  browserId: (0, import_validatorPrimitives.tOptional)(import_validatorPrimitives.tString),
   mode: (0, import_validatorPrimitives.tEnum)(["inspecting", "recording", "none"]),
   testIdAttributeName: (0, import_validatorPrimitives.tOptional)(import_validatorPrimitives.tString),
   generateAutoExpect: (0, import_validatorPrimitives.tOptional)(import_validatorPrimitives.tBoolean)
@@ -496,11 +485,6 @@ import_validatorPrimitives.scheme.DebugControllerHideHighlightParams = (0, impor
 import_validatorPrimitives.scheme.DebugControllerHideHighlightResult = (0, import_validatorPrimitives.tOptional)((0, import_validatorPrimitives.tObject)({}));
 import_validatorPrimitives.scheme.DebugControllerResumeParams = (0, import_validatorPrimitives.tOptional)((0, import_validatorPrimitives.tObject)({}));
 import_validatorPrimitives.scheme.DebugControllerResumeResult = (0, import_validatorPrimitives.tOptional)((0, import_validatorPrimitives.tObject)({}));
-import_validatorPrimitives.scheme.DebugControllerCloseBrowserParams = (0, import_validatorPrimitives.tObject)({
-  id: import_validatorPrimitives.tString,
-  reason: (0, import_validatorPrimitives.tOptional)(import_validatorPrimitives.tString)
-});
-import_validatorPrimitives.scheme.DebugControllerCloseBrowserResult = (0, import_validatorPrimitives.tOptional)((0, import_validatorPrimitives.tObject)({}));
 import_validatorPrimitives.scheme.DebugControllerKillParams = (0, import_validatorPrimitives.tOptional)((0, import_validatorPrimitives.tObject)({}));
 import_validatorPrimitives.scheme.DebugControllerKillResult = (0, import_validatorPrimitives.tOptional)((0, import_validatorPrimitives.tObject)({}));
 import_validatorPrimitives.scheme.SocksSupportInitializer = (0, import_validatorPrimitives.tOptional)((0, import_validatorPrimitives.tObject)({}));

package/lib/remote/playwrightServer.js

@@ -86,20 +86,6 @@ ${uaError}` };
         const isExtension = this._options.mode === "extension";
         const allowFSPaths = isExtension;
         launchOptions = filterLaunchOptions(launchOptions, allowFSPaths);
-        if (url.searchParams.has("debug-controller")) {
-          if (!(this._options.debugController || isExtension))
-            throw new Error("Debug controller is not enabled");
-          return new import_playwrightConnection.PlaywrightConnection(
-            controllerSemaphore,
-            ws,
-            true,
-            this._playwright,
-            async () => {
-              throw new Error("shouldnt be used");
-            },
-            id
-          );
-        }
         if (isExtension) {
           const connectFilter = url.searchParams.get("connect");
           if (connectFilter) {
@@ -114,6 +100,18 @@ ${uaError}` };
               id
             );
           }
+          if (url.searchParams.has("debug-controller")) {
+            return new import_playwrightConnection.PlaywrightConnection(
+              controllerSemaphore,
+              ws,
+              true,
+              this._playwright,
+              async () => {
+                throw new Error("shouldnt be used");
+              },
+              id
+            );
+          }
           return new import_playwrightConnection.PlaywrightConnection(
             reuseBrowserSemaphore,
             ws,

package/lib/server/bidi/bidiPage.js

@@ -218,6 +218,7 @@ class BidiPage {
   _onDownloadWillBegin(event) {
     if (!event.navigation)
       return;
+    this._page.frameManager.frameAbortedNavigation(event.context, "Download is starting");
     let originPage = this._page.initializedOrUndefined();
     if (!originPage && this._opener)
       originPage = this._opener._page.initializedOrUndefined();

package/lib/server/debugController.js

@@ -31,13 +31,9 @@ var import_locatorParser = require("../utils/isomorphic/locatorParser");
 var import_language = require("./codegen/language");
 var import_recorderUtils = require("./recorder/recorderUtils");
 var import_javascript = require("./codegen/javascript");
-var import_frames = require("./frames");
-var import_page = require("./page");
 class DebugController extends import_instrumentation.SdkObject {
   constructor(playwright) {
     super({ attribution: { isInternalPlaywright: true }, instrumentation: (0, import_instrumentation.createInstrumentation)() }, void 0, "DebugController");
-    this._reportState = false;
-    this._disposeListeners = /* @__PURE__ */ new Set();
     this._sdkLanguage = "javascript";
     this._generateAutoExpect = false;
     this._playwright = playwright;
@@ -58,38 +54,23 @@ class DebugController extends import_instrumentation.SdkObject {
     this.setReportStateChanged(false);
   }
   setReportStateChanged(enabled) {
-    if (this._reportState === enabled)
-      return;
-    this._reportState = enabled;
-    if (enabled) {
-      const listener = {
-        onPageOpen: (page) => {
-          this._emitSnapshot(false);
-          const handleNavigation = () => this._emitSnapshot(false);
-          page.mainFrame().on(import_frames.Frame.Events.InternalNavigation, handleNavigation);
-          const dispose = () => page.mainFrame().off(import_frames.Frame.Events.InternalNavigation, handleNavigation);
-          this._disposeListeners.add(dispose);
-          page.on(import_page.Page.Events.Close, () => this._disposeListeners.delete(dispose));
-        },
-        onPageClose: () => this._emitSnapshot(false),
-        onBrowserClose: () => {
-          this._emitSnapshot(false);
-        }
+    if (enabled && !this._trackHierarchyListener) {
+      this._trackHierarchyListener = {
+        onPageOpen: () => this._emitSnapshot(false),
+        onPageClose: () => this._emitSnapshot(false)
       };
-      this._playwright.instrumentation.addListener(listener, null);
-      this._disposeListeners.add(() => this._playwright.instrumentation.removeListener(listener));
+      this._playwright.instrumentation.addListener(this._trackHierarchyListener, null);
       this._emitSnapshot(true);
-    } else {
-      for (const dispose of this._disposeListeners)
-        dispose();
-      this._disposeListeners.clear();
+    } else if (!enabled && this._trackHierarchyListener) {
+      this._playwright.instrumentation.removeListener(this._trackHierarchyListener);
+      this._trackHierarchyListener = void 0;
     }
   }
   async setRecorderMode(progress, params) {
     await progress.race(this._closeBrowsersWithoutPages());
     this._generateAutoExpect = !!params.generateAutoExpect;
     if (params.mode === "none") {
-      for (const recorder of await progress.race(this._allRecorders(params.browserId))) {
+      for (const recorder of await progress.race(this._allRecorders())) {
         recorder.hideHighlightedSelector();
         recorder.setMode("none");
       }
@@ -104,13 +85,10 @@ class DebugController extends import_instrumentation.SdkObject {
       await context.newPage(progress);
     }
     if (params.testIdAttributeName) {
-      for (const page of this._playwright.allPages()) {
-        if (params.browserId && page.browserContext._browser.guid !== params.browserId)
-          continue;
+      for (const page of this._playwright.allPages())
         page.browserContext.selectors().setTestIdAttributeName(params.testIdAttributeName);
-      }
     }
-    for (const recorder of await progress.race(this._allRecorders(params.browserId))) {
+    for (const recorder of await progress.race(this._allRecorders())) {
       recorder.hideHighlightedSelector();
       recorder.setMode(params.mode);
     }
@@ -136,12 +114,6 @@ class DebugController extends import_instrumentation.SdkObject {
     for (const recorder of await progress.race(this._allRecorders()))
       recorder.resume();
   }
-  async closeBrowser(progress, id, reason) {
-    const browser = this._playwright.allBrowsers().find((b) => b.guid === id);
-    if (!browser)
-      return;
-    await progress.race(browser.close({ reason }));
-  }
   kill() {
     (0, import_processLauncher.gracefullyProcessExitDoNotHang)(0);
   }
@@ -149,27 +121,12 @@ class DebugController extends import_instrumentation.SdkObject {
     const pageCount = this._playwright.allPages().length;
     if (initial && !pageCount)
       return;
-    this.emit(DebugController.Events.StateChanged, {
-      pageCount,
-      browsers: this._playwright.allBrowsers().map((browser) => ({
-        id: browser.guid,
-        name: browser.options.name,
-        channel: browser.options.channel,
-        contexts: browser.contexts().map((context) => ({
-          pages: context.pages().map((page) => ({
-            url: page.mainFrame().url()
-          }))
-        }))
-      }))
-    });
+    this.emit(DebugController.Events.StateChanged, { pageCount });
   }
-  async _allRecorders(browserId) {
+  async _allRecorders() {
     const contexts = /* @__PURE__ */ new Set();
-    for (const page of this._playwright.allPages()) {
-      if (browserId && page.browserContext._browser.guid !== browserId)
-        continue;
+    for (const page of this._playwright.allPages())
       contexts.add(page.browserContext);
-    }
     const recorders = await Promise.all([...contexts].map((c) => import_recorder.Recorder.forContext(c, { omitCallTracking: true })));
     const nonNullRecorders = recorders.filter(Boolean);
     for (const recorder of recorders)

package/lib/server/dispatchers/debugControllerDispatcher.js

@@ -67,9 +67,6 @@ class DebugControllerDispatcher extends import_dispatcher.Dispatcher {
   async kill(params, progress) {
     this._object.kill();
   }
-  async closeBrowser(params, progress) {
-    await this._object.closeBrowser(progress, params.id, params.reason);
-  }
   _onDispose() {
     import_utils.eventsHelper.removeEventListeners(this._listeners);
     this._object.dispose();

package/lib/server/utils/wsServer.js

@@ -85,13 +85,8 @@ class WSServer {
       const url = new URL("http://localhost" + (request.url || ""));
       const id = String(++lastConnectionId);
       import_debugLogger.debugLogger.log("server", `[${id}] serving connection: ${request.url}`);
-      try {
-        const connection = this._delegate.onConnection(request, url, ws, id);
-        ws[kConnectionSymbol] = connection;
-      } catch (error) {
-        import_debugLogger.debugLogger.log("server", `[${id}] connection error: ${error}`);
-        ws.close(1011, String(error));
-      }
+      const connection = this._delegate.onConnection(request, url, ws, id);
+      ws[kConnectionSymbol] = connection;
     });
     return wsEndpoint;
   }

package/lib/server/webkit/wkPage.js

@@ -343,7 +343,6 @@ class WKPage {
       import_eventsHelper.eventsHelper.addEventListener(this._session, "Page.frameDetached", (event) => this._onFrameDetached(event.frameId)),
       import_eventsHelper.eventsHelper.addEventListener(this._session, "Page.willCheckNavigationPolicy", (event) => this._onWillCheckNavigationPolicy(event.frameId)),
       import_eventsHelper.eventsHelper.addEventListener(this._session, "Page.didCheckNavigationPolicy", (event) => this._onDidCheckNavigationPolicy(event.frameId, event.cancel)),
-      import_eventsHelper.eventsHelper.addEventListener(this._session, "Page.frameScheduledNavigation", (event) => this._onFrameScheduledNavigation(event.frameId, event.delay, event.targetIsCurrentFrame)),
       import_eventsHelper.eventsHelper.addEventListener(this._session, "Page.loadEventFired", (event) => this._page.frameManager.frameLifecycleEvent(event.frameId, "load")),
       import_eventsHelper.eventsHelper.addEventListener(this._session, "Page.domContentEventFired", (event) => this._page.frameManager.frameLifecycleEvent(event.frameId, "domcontentloaded")),
       import_eventsHelper.eventsHelper.addEventListener(this._session, "Runtime.executionContextCreated", (event) => this._onExecutionContextCreated(event.context)),
@@ -390,10 +389,6 @@ class WKPage {
       return;
     this._page.frameManager.frameAbortedNavigation(frameId, "Navigation canceled by policy check");
   }
-  _onFrameScheduledNavigation(frameId, delay, targetIsCurrentFrame) {
-    if (targetIsCurrentFrame)
-      this._page.frameManager.frameRequestedNavigation(frameId);
-  }
   _handleFrameTree(frameTree) {
     this._onFrameAttached(frameTree.frame.id, frameTree.frame.parentId || null);
     this._onFrameNavigated(frameTree.frame, true);

package/lib/utils/isomorphic/protocolMetainfo.js

@@ -46,7 +46,6 @@ const methodMetainfo = /* @__PURE__ */ new Map([
   ["DebugController.highlight", { internal: true }],
   ["DebugController.hideHighlight", { internal: true }],
   ["DebugController.resume", { internal: true }],
-  ["DebugController.closeBrowser", { internal: true }],
   ["DebugController.kill", { internal: true }],
   ["SocksSupport.socksConnected", { internal: true }],
   ["SocksSupport.socksFailed", { internal: true }],