playwright 1.56.0-alpha-2025-09-08 → 1.56.0-alpha-1757456950000

package/README.md

@@ -1,6 +1,6 @@
 # 🎭 Playwright
 
-[![npm version](https://img.shields.io/npm/v/playwright.svg)](https://www.npmjs.com/package/playwright) <!-- GEN:chromium-version-badge -->[![Chromium version](https://img.shields.io/badge/chromium-140.0.7339.41-blue.svg?logo=google-chrome)](https://www.chromium.org/Home)<!-- GEN:stop --> <!-- GEN:firefox-version-badge -->[![Firefox version](https://img.shields.io/badge/firefox-141.0-blue.svg?logo=firefoxbrowser)](https://www.mozilla.org/en-US/firefox/new/)<!-- GEN:stop --> <!-- GEN:webkit-version-badge -->[![WebKit version](https://img.shields.io/badge/webkit-26.0-blue.svg?logo=safari)](https://webkit.org/)<!-- GEN:stop --> [![Join Discord](https://img.shields.io/badge/join-discord-informational)](https://aka.ms/playwright/discord)
+[![npm version](https://img.shields.io/npm/v/playwright.svg)](https://www.npmjs.com/package/playwright) <!-- GEN:chromium-version-badge -->[![Chromium version](https://img.shields.io/badge/chromium-141.0.7390.7-blue.svg?logo=google-chrome)](https://www.chromium.org/Home)<!-- GEN:stop --> <!-- GEN:firefox-version-badge -->[![Firefox version](https://img.shields.io/badge/firefox-141.0-blue.svg?logo=firefoxbrowser)](https://www.mozilla.org/en-US/firefox/new/)<!-- GEN:stop --> <!-- GEN:webkit-version-badge -->[![WebKit version](https://img.shields.io/badge/webkit-26.0-blue.svg?logo=safari)](https://webkit.org/)<!-- GEN:stop --> [![Join Discord](https://img.shields.io/badge/join-discord-informational)](https://aka.ms/playwright/discord)
 
 ## [Documentation](https://playwright.dev) | [API reference](https://playwright.dev/docs/api/class-playwright)
 
@@ -8,7 +8,7 @@ Playwright is a framework for Web Testing and Automation. It allows testing [Chr
 
 |          | Linux | macOS | Windows |
 |   :---   | :---: | :---: | :---:   |
-| Chromium <!-- GEN:chromium-version -->140.0.7339.41<!-- GEN:stop --> | :white_check_mark: | :white_check_mark: | :white_check_mark: |
+| Chromium <!-- GEN:chromium-version -->141.0.7390.7<!-- GEN:stop --> | :white_check_mark: | :white_check_mark: | :white_check_mark: |
 | WebKit <!-- GEN:webkit-version -->26.0<!-- GEN:stop --> | :white_check_mark: | :white_check_mark: | :white_check_mark: |
 | Firefox <!-- GEN:firefox-version -->141.0<!-- GEN:stop --> | :white_check_mark: | :white_check_mark: | :white_check_mark: |
 

package/lib/index.js

@@ -222,7 +222,7 @@ const playwrightFixtures = {
     if ((0, import_utils.debugMode)() === "inspector")
       testInfo._setDebugMode();
     playwright._defaultContextOptions = _combinedContextOptions;
-    playwright._defaultContextTimeout = process.env.PLAYWRIGHT_DEBUGGER_ENABLED ? 5e3 : actionTimeout || 0;
+    playwright._defaultContextTimeout = testInfo._pauseOnError() ? 5e3 : actionTimeout || 0;
     playwright._defaultContextNavigationTimeout = navigationTimeout || 0;
     await use();
     playwright._defaultContextOptions = void 0;
@@ -262,6 +262,9 @@ const playwrightFixtures = {
           tracingGroupSteps.push(step);
       },
       onApiCallRecovery: (data, error, channelOwner, recoveryHandlers) => {
+        const testInfo2 = (0, import_globals.currentTestInfo)();
+        if (!testInfo2 || !testInfo2._pauseOnError())
+          return;
         const step = data.userData;
         if (!step)
           return;

package/lib/mcp/program.js

@@ -39,8 +39,9 @@ var import_browserContextFactory = require("./browser/browserContextFactory");
 var import_proxyBackend = require("./sdk/proxyBackend");
 var import_browserServerBackend = require("./browser/browserServerBackend");
 var import_extensionContextFactory = require("./extension/extensionContextFactory");
+var import_host = require("./vscode/host");
 function decorateCommand(command, version) {
-  command.option("--allowed-origins <origins>", "semicolon-separated list of origins to allow the browser to request. Default is to allow all.", import_config.semicolonSeparatedList).option("--blocked-origins <origins>", "semicolon-separated list of origins to block the browser from requesting. Blocklist is evaluated before allowlist. If used without the allowlist, requests not matching the blocklist are still allowed.", import_config.semicolonSeparatedList).option("--block-service-workers", "block service workers").option("--browser <browser>", "browser or chrome channel to use, possible values: chrome, firefox, webkit, msedge.").option("--caps <caps>", "comma-separated list of additional capabilities to enable, possible values: vision, pdf.", import_config.commaSeparatedList).option("--cdp-endpoint <endpoint>", "CDP endpoint to connect to.").option("--cdp-header <headers...>", "CDP headers to send with the connect request, multiple can be specified.", import_config.headerParser).option("--config <path>", "path to the configuration file.").option("--device <device>", 'device to emulate, for example: "iPhone 15"').option("--executable-path <path>", "path to the browser executable.").option("--extension", 'Connect to a running browser instance (Edge/Chrome only). Requires the "Playwright MCP Bridge" browser extension to be installed.').option("--headless", "run browser in headless mode, headed by default").option("--host <host>", "host to bind server to. Default is localhost. Use 0.0.0.0 to bind to all interfaces.").option("--ignore-https-errors", "ignore https errors").option("--isolated", "keep the browser profile in memory, do not save it to disk.").option("--image-responses <mode>", 'whether to send image responses to the client. Can be "allow" or "omit", Defaults to "allow".').option("--no-sandbox", "disable the sandbox for all process types that are normally sandboxed.").option("--output-dir <path>", "path to the directory for output files.").option("--port <port>", "port to listen on for SSE transport.").option("--proxy-bypass <bypass>", 'comma-separated domains to bypass proxy, for example ".com,chromium.org,.domain.com"').option("--proxy-server <proxy>", 'specify proxy server, for example "http://myproxy:3128" or "socks5://myproxy:8080"').option("--save-session", "Whether to save the Playwright MCP session into the output directory.").option("--save-trace", "Whether to save the Playwright Trace of the session into the output directory.").option("--secrets <path>", "path to a file containing secrets in the dotenv format", import_config.dotenvFileLoader).option("--storage-state <path>", "path to the storage state file for isolated sessions.").option("--timeout-action <timeout>", "specify action timeout in milliseconds, defaults to 5000ms", import_config.numberParser).option("--timeout-navigation <timeout>", "specify navigation timeout in milliseconds, defaults to 60000ms", import_config.numberParser).option("--user-agent <ua string>", "specify user agent string").option("--user-data-dir <path>", "path to the user data directory. If not specified, a temporary directory will be created.").option("--viewport-size <size>", 'specify browser viewport size in pixels, for example "1280, 720"').addOption(new import_utilsBundle.ProgramOption("--connect-tool", "Allow to switch between different browser connection methods.").hideHelp()).addOption(new import_utilsBundle.ProgramOption("--vision", "Legacy option, use --caps=vision instead").hideHelp()).action(async (options) => {
+  command.option("--allowed-origins <origins>", "semicolon-separated list of origins to allow the browser to request. Default is to allow all.", import_config.semicolonSeparatedList).option("--blocked-origins <origins>", "semicolon-separated list of origins to block the browser from requesting. Blocklist is evaluated before allowlist. If used without the allowlist, requests not matching the blocklist are still allowed.", import_config.semicolonSeparatedList).option("--block-service-workers", "block service workers").option("--browser <browser>", "browser or chrome channel to use, possible values: chrome, firefox, webkit, msedge.").option("--caps <caps>", "comma-separated list of additional capabilities to enable, possible values: vision, pdf.", import_config.commaSeparatedList).option("--cdp-endpoint <endpoint>", "CDP endpoint to connect to.").option("--cdp-header <headers...>", "CDP headers to send with the connect request, multiple can be specified.", import_config.headerParser).option("--config <path>", "path to the configuration file.").option("--device <device>", 'device to emulate, for example: "iPhone 15"').option("--executable-path <path>", "path to the browser executable.").option("--extension", 'Connect to a running browser instance (Edge/Chrome only). Requires the "Playwright MCP Bridge" browser extension to be installed.').option("--headless", "run browser in headless mode, headed by default").option("--host <host>", "host to bind server to. Default is localhost. Use 0.0.0.0 to bind to all interfaces.").option("--ignore-https-errors", "ignore https errors").option("--isolated", "keep the browser profile in memory, do not save it to disk.").option("--image-responses <mode>", 'whether to send image responses to the client. Can be "allow" or "omit", Defaults to "allow".').option("--no-sandbox", "disable the sandbox for all process types that are normally sandboxed.").option("--output-dir <path>", "path to the directory for output files.").option("--port <port>", "port to listen on for SSE transport.").option("--proxy-bypass <bypass>", 'comma-separated domains to bypass proxy, for example ".com,chromium.org,.domain.com"').option("--proxy-server <proxy>", 'specify proxy server, for example "http://myproxy:3128" or "socks5://myproxy:8080"').option("--save-session", "Whether to save the Playwright MCP session into the output directory.").option("--save-trace", "Whether to save the Playwright Trace of the session into the output directory.").option("--secrets <path>", "path to a file containing secrets in the dotenv format", import_config.dotenvFileLoader).option("--storage-state <path>", "path to the storage state file for isolated sessions.").option("--timeout-action <timeout>", "specify action timeout in milliseconds, defaults to 5000ms", import_config.numberParser).option("--timeout-navigation <timeout>", "specify navigation timeout in milliseconds, defaults to 60000ms", import_config.numberParser).option("--user-agent <ua string>", "specify user agent string").option("--user-data-dir <path>", "path to the user data directory. If not specified, a temporary directory will be created.").option("--viewport-size <size>", 'specify browser viewport size in pixels, for example "1280, 720"').addOption(new import_utilsBundle.ProgramOption("--connect-tool", "Allow to switch between different browser connection methods.").hideHelp()).addOption(new import_utilsBundle.ProgramOption("--vscode", "VS Code tools.").hideHelp()).addOption(new import_utilsBundle.ProgramOption("--vision", "Legacy option, use --caps=vision instead").hideHelp()).action(async (options) => {
     setupExitWatchdog();
     if (options.vision) {
       console.error("The --vision option is deprecated, use --caps=vision instead");
@@ -59,6 +60,10 @@ function decorateCommand(command, version) {
       await mcpServer.start(serverBackendFactory, config.server);
       return;
     }
+    if (options.vscode) {
+      await (0, import_host.runVSCodeTools)(config);
+      return;
+    }
     if (options.connectTool) {
       const providers = [
         {

package/lib/mcp/sdk/mdb.js

@@ -150,7 +150,7 @@ async function runMainBackend(backendFactory, options) {
     return url;
   await mcpServer.connect(factory, new mcpBundle.StdioServerTransport(), false);
 }
-async function runOnPauseBackendLoop(mdbUrl, backend, introMessage) {
+async function runOnPauseBackendLoop(backend, introMessage) {
   const wrappedBackend = new OnceTimeServerBackendWrapper(backend);
   const factory = {
     name: "on-pause-backend",
@@ -163,7 +163,7 @@ async function runOnPauseBackendLoop(mdbUrl, backend, introMessage) {
   const url = mcpHttp.httpAddressToString(httpServer.address());
   const client = new mcpBundle.Client({ name: "Internal client", version: "0.0.0" });
   client.setRequestHandler(mcpBundle.PingRequestSchema, () => ({}));
-  const transport = new mcpBundle.StreamableHTTPClientTransport(new URL(mdbUrl));
+  const transport = new mcpBundle.StreamableHTTPClientTransport(new URL(process.env.PLAYWRIGHT_DEBUGGER_MCP));
   await client.connect(transport);
   const pushToolsResult = await client.callTool({
     name: pushToolsSchema.name,

package/lib/mcp/test/browserBackend.js

@@ -34,6 +34,7 @@ __export(browserBackend_exports, {
 module.exports = __toCommonJS(browserBackend_exports);
 var mcp = __toESM(require("../sdk/exports"));
 var mcpBundle = __toESM(require("../sdk/bundle"));
+var import_globals = require("../../common/globals");
 var import_browserTools = require("./browserTools");
 var import_util = require("../../util");
 const tools = [import_browserTools.snapshot, import_browserTools.pickLocator, import_browserTools.evaluate];
@@ -71,7 +72,8 @@ const doneToolSchema = mcp.defineToolSchema({
   type: "destructive"
 });
 async function runBrowserBackendOnError(page, message) {
-  if (!process.env.PLAYWRIGHT_DEBUGGER_ENABLED)
+  const testInfo = (0, import_globals.currentTestInfo)();
+  if (!testInfo || !testInfo._pauseOnError())
     return;
   const snapshot2 = await page._snapshotForAI();
   const introMessage = `### Paused on error:
@@ -82,7 +84,7 @@ ${snapshot2}
 
 ### Task
 Try recovering from the error prior to continuing, use following tools to recover: ${tools.map((tool) => tool.schema.name).join(", ")}`;
-  await mcp.runOnPauseBackendLoop(process.env.PLAYWRIGHT_MDB_URL, new BrowserBackend(page), introMessage);
+  await mcp.runOnPauseBackendLoop(new BrowserBackend(page), introMessage);
 }
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {

package/lib/mcp/test/testTools.js

@@ -64,7 +64,7 @@ const runTests = (0, import_testTool.defineTestTool)({
     title: "Run tests",
     description: "Run tests",
     inputSchema: import_bundle.z.object({
-      locations: import_bundle.z.array(import_bundle.z.string()).describe('Folder, file or location to run: "test/e2e" or "test/e2e/file.spec.ts" or "test/e2e/file.spec.ts:20"'),
+      locations: import_bundle.z.array(import_bundle.z.string()).optional().describe('Folder, file or location to run: "test/e2e" or "test/e2e/file.spec.ts" or "test/e2e/file.spec.ts:20"'),
       projects: import_bundle.z.array(import_bundle.z.string()).optional().describe('Projects to run, projects from playwright.config.ts, by default runs all projects. Running with "chromium" is a good start')
     }),
     type: "readOnly"
@@ -112,15 +112,13 @@ const debugTest = (0, import_testTool.defineTestTool)({
     const configDir = context.configLocation.configDir;
     const reporter = new import_list.default({ configDir, screen });
     const testRunner = await context.createTestRunner();
-    process.env.PLAYWRIGHT_DEBUGGER_ENABLED = "1";
     const result = await testRunner.runTests(reporter, {
-      headed: true,
+      headed: !context.options?.headless,
       testIds: [params.test.id],
       // For automatic recovery
       timeout: 0,
-      workers: 1
-    }).finally(() => {
-      process.env.PLAYWRIGHT_DEBUGGER_ENABLED = void 0;
+      workers: 1,
+      pauseOnError: true
     });
     const text = stream.content();
     return {

package/lib/mcp/vscode/host.js

@@ -0,0 +1,189 @@
+"use strict";
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var host_exports = {};
+__export(host_exports, {
+  runVSCodeTools: () => runVSCodeTools
+});
+module.exports = __toCommonJS(host_exports);
+var import_path = __toESM(require("path"));
+var mcpBundle = __toESM(require("../sdk/bundle"));
+var mcpServer = __toESM(require("../sdk/server"));
+var import_log = require("../log");
+var import_browserServerBackend = require("../browser/browserServerBackend");
+var import_browserContextFactory = require("../browser/browserContextFactory");
+const packageJSON = require("../../../package.json");
+const { z, zodToJsonSchema } = mcpBundle;
+const contextSwitchOptions = z.object({
+  connectionString: z.string().optional().describe("The connection string to use to connect to the browser"),
+  lib: z.string().optional().describe("The library to use for the connection"),
+  debugController: z.boolean().optional().describe("Enable the debug controller")
+});
+class VSCodeProxyBackend {
+  constructor(_config, _defaultTransportFactory) {
+    this._config = _config;
+    this._defaultTransportFactory = _defaultTransportFactory;
+    this.name = "Playwright MCP Client Switcher";
+    this.version = packageJSON.version;
+    this._roots = [];
+    this._contextSwitchTool = this._defineContextSwitchTool();
+  }
+  async initialize(server, clientVersion, roots) {
+    this._clientVersion = clientVersion;
+    this._roots = roots;
+    const transport = await this._defaultTransportFactory(this);
+    await this._setCurrentClient(transport);
+  }
+  async listTools() {
+    const response = await this._currentClient.listTools();
+    return [
+      ...response.tools,
+      this._contextSwitchTool
+    ];
+  }
+  async callTool(name, args) {
+    if (name === this._contextSwitchTool.name)
+      return this._callContextSwitchTool(args);
+    return await this._currentClient.callTool({
+      name,
+      arguments: args
+    });
+  }
+  serverClosed(server) {
+    void this._currentClient?.close().catch(import_log.logUnhandledError);
+  }
+  onContext(context) {
+    this._context = context;
+    context.on("close", () => {
+      this._context = void 0;
+    });
+  }
+  async _getDebugControllerURL() {
+    if (!this._context)
+      return;
+    const browser = this._context.browser();
+    if (!browser || !browser._launchServer)
+      return;
+    if (this._browser !== browser)
+      this._browserServer = void 0;
+    if (!this._browserServer)
+      this._browserServer = await browser._launchServer({ _debugController: true });
+    const url = new URL(this._browserServer.wsEndpoint());
+    url.searchParams.set("debug-controller", "1");
+    return url.toString();
+  }
+  async _callContextSwitchTool(params) {
+    if (params.debugController) {
+      const url = await this._getDebugControllerURL();
+      const lines = [`### Result`];
+      if (url) {
+        lines.push(`URL: ${url}`);
+        lines.push(`Version: ${packageJSON.version}`);
+      } else {
+        lines.push(`No open browsers.`);
+      }
+      return { content: [{ type: "text", text: lines.join("\n") }] };
+    }
+    if (!params.connectionString || !params.lib) {
+      const transport = await this._defaultTransportFactory(this);
+      await this._setCurrentClient(transport);
+      return {
+        content: [{ type: "text", text: "### Result\nSuccessfully disconnected.\n" }]
+      };
+    }
+    await this._setCurrentClient(
+      new mcpBundle.StdioClientTransport({
+        command: process.execPath,
+        cwd: process.cwd(),
+        args: [
+          import_path.default.join(__dirname, "main.js"),
+          JSON.stringify(this._config),
+          params.connectionString,
+          params.lib
+        ]
+      })
+    );
+    return {
+      content: [{ type: "text", text: "### Result\nSuccessfully connected.\n" }]
+    };
+  }
+  _defineContextSwitchTool() {
+    return {
+      name: "browser_connect",
+      description: "Do not call, this tool is used in the integration with the Playwright VS Code Extension and meant for programmatic usage only.",
+      inputSchema: zodToJsonSchema(contextSwitchOptions, { strictUnions: true }),
+      annotations: {
+        title: "Connect to a browser running in VS Code.",
+        readOnlyHint: true,
+        openWorldHint: false
+      }
+    };
+  }
+  async _setCurrentClient(transport) {
+    await this._currentClient?.close();
+    this._currentClient = void 0;
+    const client = new mcpBundle.Client(this._clientVersion);
+    client.registerCapabilities({
+      roots: {
+        listRoots: true
+      }
+    });
+    client.setRequestHandler(mcpBundle.ListRootsRequestSchema, () => ({ roots: this._roots }));
+    client.setRequestHandler(mcpBundle.PingRequestSchema, () => ({}));
+    await client.connect(transport);
+    this._currentClient = client;
+  }
+}
+async function runVSCodeTools(config) {
+  const serverBackendFactory = {
+    name: "Playwright w/ vscode",
+    nameInConfig: "playwright-vscode",
+    version: packageJSON.version,
+    create: () => new VSCodeProxyBackend(
+      config,
+      (delegate) => mcpServer.wrapInProcess(
+        new import_browserServerBackend.BrowserServerBackend(
+          config,
+          {
+            async createContext(clientInfo, abortSignal, toolName) {
+              const context = await (0, import_browserContextFactory.contextFactory)(config).createContext(clientInfo, abortSignal, toolName);
+              delegate.onContext(context.browserContext);
+              return context;
+            }
+          }
+        )
+      )
+    )
+  };
+  await mcpServer.start(serverBackendFactory, config.server);
+  return;
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  runVSCodeTools
+});

package/lib/mcp/vscode/main.js

@@ -0,0 +1,77 @@
+"use strict";
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var mcpBundle = __toESM(require("../sdk/bundle"));
+var mcpServer = __toESM(require("../sdk/server"));
+var import_browserServerBackend = require("../browser/browserServerBackend");
+class VSCodeBrowserContextFactory {
+  constructor(_config, _playwright, _connectionString) {
+    this._config = _config;
+    this._playwright = _playwright;
+    this._connectionString = _connectionString;
+    this.name = "vscode";
+    this.description = "Connect to a browser running in the Playwright VS Code extension";
+  }
+  async createContext(clientInfo, abortSignal) {
+    let launchOptions = this._config.browser.launchOptions;
+    if (this._config.browser.userDataDir) {
+      launchOptions = {
+        ...launchOptions,
+        ...this._config.browser.contextOptions,
+        userDataDir: this._config.browser.userDataDir
+      };
+    }
+    const connectionString = new URL(this._connectionString);
+    connectionString.searchParams.set("launch-options", JSON.stringify(launchOptions));
+    const browserType = this._playwright.chromium;
+    const browser = await browserType.connect(connectionString.toString());
+    const context = browser.contexts()[0] ?? await browser.newContext(this._config.browser.contextOptions);
+    return {
+      browserContext: context,
+      close: async () => {
+        await browser.close();
+      }
+    };
+  }
+}
+async function main(config, connectionString, lib) {
+  const playwright = await import(lib).then((mod) => mod.default ?? mod);
+  const factory = new VSCodeBrowserContextFactory(config, playwright, connectionString);
+  await mcpServer.connect(
+    {
+      name: "Playwright MCP",
+      nameInConfig: "playwright-vscode",
+      create: () => new import_browserServerBackend.BrowserServerBackend(config, factory),
+      version: "unused"
+    },
+    new mcpBundle.StdioServerTransport(),
+    false
+  );
+}
+void (async () => {
+  await main(
+    JSON.parse(process.argv[2]),
+    process.argv[3],
+    process.argv[4]
+  );
+})();

package/lib/program.js

@@ -151,6 +151,7 @@ function addBrowserMCPServerCommand(program3) {
 function addTestMCPServerCommand(program3) {
   const command = program3.command("run-test-mcp-server", { hidden: true });
   command.description("Interact with the test runner over MCP");
+  command.option("--headless", "run browser in headless mode, headed by default");
   command.option("-c, --config <file>", `Configuration file, or a test directory with optional "playwright.config.{m,c}?{js,ts}"`);
   command.option("--host <host>", "host to bind server to. Default is localhost. Use 0.0.0.0 to bind to all interfaces.");
   command.option("--port <port>", "port to listen on for SSE transport.");
@@ -160,7 +161,7 @@ function addTestMCPServerCommand(program3) {
       name: "Playwright Test Runner",
       nameInConfig: "playwright-test-runner",
       version: packageJSON.version,
-      create: () => new import_testBackend.TestServerBackend(resolvedLocation, { muteConsole: options.port === void 0 })
+      create: () => new import_testBackend.TestServerBackend(resolvedLocation, { muteConsole: options.port === void 0, headless: options.headless })
     };
     const mdbUrl = await (0, import_exports.runMainBackend)(backendFactory, { port: options.port === void 0 ? void 0 : +options.port });
     if (mdbUrl)

package/lib/runner/dispatcher.js

@@ -158,7 +158,7 @@ class Dispatcher {
   _createWorker(testGroup, parallelIndex, loaderData) {
     const projectConfig = this._config.projects.find((p) => p.id === testGroup.projectId);
     const outputDir = projectConfig.project.outputDir;
-    const worker = new import_workerHost.WorkerHost(testGroup, parallelIndex, loaderData, this._extraEnvByProjectId.get(testGroup.projectId) || {}, outputDir);
+    const worker = new import_workerHost.WorkerHost(testGroup, parallelIndex, loaderData, this._extraEnvByProjectId.get(testGroup.projectId) || {}, outputDir, this._failureTracker.pauseOnError());
     const handleOutput = (params) => {
       const chunk = chunkFromParams(params);
       if (worker.didFail()) {
@@ -363,7 +363,7 @@ class JobDispatcher {
     }
   }
   _onDone(params) {
-    if (!this._remainingByTestId.size && !this._failedTests.size && !params.fatalErrors.length && !params.skipTestsDueToSetupFailure.length && !params.fatalUnknownTestIds && !params.unexpectedExitError) {
+    if (!this._remainingByTestId.size && !this._failedTests.size && !params.fatalErrors.length && !params.skipTestsDueToSetupFailure.length && !params.fatalUnknownTestIds && !params.unexpectedExitError && !params.stoppedDueToUnhandledErrorInTestFail) {
       this._finished({ didFail: false });
       return;
     }

package/lib/runner/failureTracker.js

@@ -22,10 +22,11 @@ __export(failureTracker_exports, {
 });
 module.exports = __toCommonJS(failureTracker_exports);
 class FailureTracker {
-  constructor(_config) {
+  constructor(_config, options) {
     this._config = _config;
     this._failureCount = 0;
     this._hasWorkerErrors = false;
+    this._pauseOnError = options?.pauseOnError ?? false;
   }
   onRootSuite(rootSuite) {
     this._rootSuite = rootSuite;
@@ -37,6 +38,9 @@ class FailureTracker {
   onWorkerError() {
     this._hasWorkerErrors = true;
   }
+  pauseOnError() {
+    return this._pauseOnError;
+  }
   hasReachedMaxFailures() {
     return this.maxFailures() > 0 && this._failureCount >= this.maxFailures();
   }

package/lib/runner/tasks.js

@@ -60,14 +60,14 @@ var import_compilationCache = require("../transform/compilationCache");
 var import_util2 = require("../util");
 const readDirAsync = (0, import_util.promisify)(import_fs.default.readdir);
 class TestRun {
-  constructor(config, reporter) {
+  constructor(config, reporter, options) {
     this.rootSuite = void 0;
     this.phases = [];
     this.projectFiles = /* @__PURE__ */ new Map();
     this.projectSuites = /* @__PURE__ */ new Map();
     this.config = config;
     this.reporter = reporter;
-    this.failureTracker = new import_failureTracker.FailureTracker(config);
+    this.failureTracker = new import_failureTracker.FailureTracker(config, options);
   }
 }
 async function runTasks(testRun, tasks, globalTimeout, cancelPromise) {

package/lib/runner/testRunner.js

@@ -270,7 +270,7 @@ class TestRunner extends import_events.default {
       (0, import_tasks.createLoadTask)("out-of-process", { filterOnly: true, failOnLoadErrors: false, doNotRunDepsOutsideProjectFilter: true }),
       ...(0, import_tasks.createRunTestsTasks)(config)
     ];
-    const testRun = new import_tasks.TestRun(config, reporter);
+    const testRun = new import_tasks.TestRun(config, reporter, { pauseOnError: params.pauseOnError });
     const run = (0, import_tasks.runTasks)(testRun, tasks, 0, stop).then(async (status) => {
       this._testRun = void 0;
       return status;

package/lib/runner/workerHost.js

@@ -39,7 +39,7 @@ var import_ipc = require("../common/ipc");
 var import_folders = require("../isomorphic/folders");
 let lastWorkerIndex = 0;
 class WorkerHost extends import_processHost.ProcessHost {
-  constructor(testGroup, parallelIndex, config, extraEnv, outputDir) {
+  constructor(testGroup, parallelIndex, config, extraEnv, outputDir, pauseOnError) {
     const workerIndex = lastWorkerIndex++;
     super(require.resolve("../worker/workerMain.js"), `worker-${workerIndex}`, {
       ...extraEnv,
@@ -56,7 +56,8 @@ class WorkerHost extends import_processHost.ProcessHost {
       repeatEachIndex: testGroup.repeatEachIndex,
       projectId: testGroup.projectId,
       config,
-      artifactsDir: import_path.default.join(outputDir, (0, import_folders.artifactsFolderName)(workerIndex))
+      artifactsDir: import_path.default.join(outputDir, (0, import_folders.artifactsFolderName)(workerIndex)),
+      pauseOnError
     };
   }
   async start() {

package/lib/worker/testInfo.js

@@ -67,6 +67,7 @@ class TestInfoImpl {
     this._startWallTime = Date.now();
     this._requireFile = test?._requireFile ?? "";
     this._uniqueSymbol = Symbol("testInfoUniqueSymbol");
+    this._workerParams = workerParams;
     this.repeatEachIndex = workerParams.repeatEachIndex;
     this.retry = retry;
     this.workerIndex = workerParams.workerIndex;
@@ -443,6 +444,9 @@ ${(0, import_utils.stringifyStackFrames)(step.boxedStack).join("\n")}`;
   setTimeout(timeout) {
     this._timeoutManager.setTimeout(timeout);
   }
+  _pauseOnError() {
+    return this._workerParams.pauseOnError;
+  }
 }
 class TestStepInfoImpl {
   constructor(testInfo, stepId, title, parentStep) {

package/lib/worker/workerMain.js

@@ -43,6 +43,9 @@ class WorkerMain extends import_process.ProcessRunner {
     this._fatalErrors = [];
     // The stage of the full cleanup. Once "finished", we can safely stop running anything.
     this._didRunFullCleanup = false;
+    // Whether the worker was stopped due to an unhandled error in a test marked with test.fail().
+    // This should force dispatcher to use a new worker instead.
+    this._stoppedDueToUnhandledErrorInTestFail = false;
     // Whether the worker was requested to stop.
     this._isStopped = false;
     // This promise resolves once the single "run test group" call finishes.
@@ -154,8 +157,10 @@ class WorkerMain extends import_process.ProcessRunner {
     }
     const isExpectError = error instanceof Error && !!error.matcherResult;
     const shouldContinueInThisWorker = this._currentTest.expectedStatus === "failed" && isExpectError;
-    if (!shouldContinueInThisWorker)
+    if (!shouldContinueInThisWorker) {
+      this._stoppedDueToUnhandledErrorInTestFail = true;
       void this._stop();
+    }
   }
   async _loadIfNeeded() {
     if (this._config)
@@ -204,7 +209,8 @@ class WorkerMain extends import_process.ProcessRunner {
       const donePayload = {
         fatalErrors: this._fatalErrors,
         skipTestsDueToSetupFailure: [],
-        fatalUnknownTestIds
+        fatalUnknownTestIds,
+        stoppedDueToUnhandledErrorInTestFail: this._stoppedDueToUnhandledErrorInTestFail
       };
       for (const test of this._skipRemainingTestsInSuite?.allTests() || []) {
         if (entries.has(test.id))

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "playwright",
-  "version": "1.56.0-alpha-2025-09-08",
+  "version": "1.56.0-alpha-1757456950000",
   "description": "A high-level API to automate web browsers",
   "repository": {
     "type": "git",
@@ -64,7 +64,7 @@
   },
   "license": "Apache-2.0",
   "dependencies": {
-    "playwright-core": "1.56.0-alpha-2025-09-08"
+    "playwright-core": "1.56.0-alpha-1757456950000"
   },
   "optionalDependencies": {
     "fsevents": "2.3.2"