playwright 1.55.0-alpha-2025-08-13 → 1.55.0-alpha-2025-08-14

package/lib/index.js

@@ -258,6 +258,11 @@ const playwrightFixtures = {
         if (data.apiName === "tracing.group")
           tracingGroupSteps.push(step);
       },
+      onApiCallRecovery: (data, error, recoveryHandlers) => {
+        const step = data.userData;
+        if (step)
+          recoveryHandlers.push(() => step.recoverFromStepError(error));
+      },
       onApiCallEnd: (data) => {
         if (data.apiName === "tracing.group")
           return;

package/lib/isomorphic/testServerConnection.js

@@ -63,6 +63,7 @@ class TestServerConnection {
     this._onStdioEmitter = new events.EventEmitter();
     this._onTestFilesChangedEmitter = new events.EventEmitter();
     this._onLoadTraceRequestedEmitter = new events.EventEmitter();
+    this._onRecoverFromStepErrorEmitter = new events.EventEmitter();
     this._lastId = 0;
     this._callbacks = /* @__PURE__ */ new Map();
     this._isClosed = false;
@@ -71,6 +72,7 @@ class TestServerConnection {
     this.onStdio = this._onStdioEmitter.event;
     this.onTestFilesChanged = this._onTestFilesChangedEmitter.event;
     this.onLoadTraceRequested = this._onLoadTraceRequestedEmitter.event;
+    this.onRecoverFromStepError = this._onRecoverFromStepErrorEmitter.event;
     this._transport = transport;
     this._transport.onmessage((data) => {
       const message = JSON.parse(data);
@@ -127,6 +129,8 @@ class TestServerConnection {
       this._onTestFilesChangedEmitter.fire(params);
     else if (method === "loadTraceRequested")
       this._onLoadTraceRequestedEmitter.fire(params);
+    else if (method === "recoverFromStepError")
+      this._onRecoverFromStepErrorEmitter.fire(params);
   }
   async initialize(params) {
     await this._sendMessage("initialize", params);
@@ -197,6 +201,9 @@ class TestServerConnection {
   async closeGracefully(params) {
     await this._sendMessage("closeGracefully", params);
   }
+  async resumeAfterStepError(params) {
+    await this._sendMessage("resumeAfterStepError", params);
+  }
   close() {
     try {
       this._transport.close();

package/lib/matchers/expect.js

@@ -234,18 +234,31 @@ class ExpectMetaInfoProxyHandler {
         infectParentStepsWithError: this._info.isSoft
       };
       const step = testInfo._addStep(stepInfo);
-      const reportStepError = (e) => {
+      const reportStepError = (isAsync, e) => {
         const jestError = (0, import_matcherHint.isJestError)(e) ? e : null;
-        const error = jestError ? new import_matcherHint.ExpectError(jestError, customMessage, stackFrames) : e;
+        const expectError = jestError ? new import_matcherHint.ExpectError(jestError, customMessage, stackFrames) : void 0;
         if (jestError?.matcherResult.suggestedRebaseline) {
           step.complete({ suggestedRebaseline: jestError?.matcherResult.suggestedRebaseline });
           return;
         }
+        const error = expectError ?? e;
         step.complete({ error });
-        if (this._info.isSoft)
-          testInfo._failWithError(error);
-        else
-          throw error;
+        if (!isAsync || !expectError) {
+          if (this._info.isSoft)
+            testInfo._failWithError(error);
+          else
+            throw error;
+          return;
+        }
+        return (async () => {
+          const recoveryResult = await step.recoverFromStepError(expectError);
+          if (recoveryResult.status === "recovered")
+            return recoveryResult.value;
+          if (this._info.isSoft)
+            testInfo._failWithError(expectError);
+          else
+            throw expectError;
+        })();
       };
       const finalizer = () => {
         step.complete({});
@@ -255,11 +268,11 @@ class ExpectMetaInfoProxyHandler {
         const callback = () => matcher.call(target, ...args);
         const result = (0, import_utils.currentZone)().with("stepZone", step).run(callback);
         if (result instanceof Promise)
-          return result.then(finalizer).catch(reportStepError);
+          return result.then(finalizer).catch(reportStepError.bind(null, true));
         finalizer();
         return result;
       } catch (e) {
-        reportStepError(e);
+        void reportStepError(false, e);
       }
     };
   }

package/lib/reporters/markdown.js

@@ -74,7 +74,6 @@ class MarkdownReporter {
     const skipped = summary.skipped ? `, ${summary.skipped} skipped` : "";
     const didNotRun = summary.didNotRun ? `, ${summary.didNotRun} did not run` : "";
     lines.push(`**${summary.expected} passed${skipped}${didNotRun}**`);
-    lines.push(`:heavy_check_mark::heavy_check_mark::heavy_check_mark:`);
     lines.push(``);
     await this.publishReport(lines.join("\n"));
   }
@@ -135,10 +134,11 @@ class MarkdownReporter {
 function formatTestTitle(rootDir, test) {
   const [, projectName, , ...titles] = test.titlePath();
   const relativeTestPath = import_path.default.relative(rootDir, test.location.file);
-  const location = `${relativeTestPath}:${test.location.line}:${test.location.column}`;
+  const location = `${relativeTestPath}:\u200B${test.location.line}:${test.location.column}`;
   const projectTitle = projectName ? `[${projectName}] \u203A ` : "";
   const testTitle = `${projectTitle}${location} \u203A ${titles.join(" \u203A ")}`;
   const extraTags = test.tags.filter((t) => !testTitle.includes(t));
-  return `${testTitle}${extraTags.length ? " " + extraTags.join(" ") : ""}`;
+  const formattedTags = extraTags.map((t) => `\`${t}\``).join(" ");
+  return `${testTitle}${extraTags.length ? " " + formattedTags : ""}`;
 }
 var markdown_default = MarkdownReporter;

package/lib/runner/dispatcher.js

@@ -158,7 +158,8 @@ 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 recoverFromStepErrors = this._failureTracker.canRecoverFromStepError();
+    const worker = new import_workerHost.WorkerHost(testGroup, parallelIndex, loaderData, recoverFromStepErrors, this._extraEnvByProjectId.get(testGroup.projectId) || {}, outputDir);
     const handleOutput = (params) => {
       const chunk = chunkFromParams(params);
       if (worker.didFail()) {
@@ -311,6 +312,24 @@ class JobDispatcher {
     steps.delete(params.stepId);
     this._reporter.onStepEnd?.(test, result, step);
   }
+  _onStepRecoverFromError(resumeAfterStepError, params) {
+    const data = this._dataByTestId.get(params.testId);
+    if (!data) {
+      resumeAfterStepError({ stepId: params.stepId, status: "failed" });
+      return;
+    }
+    const { steps } = data;
+    const step = steps.get(params.stepId);
+    if (!step) {
+      resumeAfterStepError({ stepId: params.stepId, status: "failed" });
+      return;
+    }
+    const testError = {
+      ...params.error,
+      location: step.location
+    };
+    this._failureTracker.recoverFromStepError(params.stepId, testError, resumeAfterStepError);
+  }
   _onAttach(params) {
     const data = this._dataByTestId.get(params.testId);
     if (!data) {
@@ -436,11 +455,13 @@ class JobDispatcher {
       })
     };
     worker.runTestGroup(runPayload);
+    const resumeAfterStepError = worker.resumeAfterStepError.bind(worker);
     this._listeners = [
       import_utils.eventsHelper.addEventListener(worker, "testBegin", this._onTestBegin.bind(this)),
       import_utils.eventsHelper.addEventListener(worker, "testEnd", this._onTestEnd.bind(this)),
       import_utils.eventsHelper.addEventListener(worker, "stepBegin", this._onStepBegin.bind(this)),
       import_utils.eventsHelper.addEventListener(worker, "stepEnd", this._onStepEnd.bind(this)),
+      import_utils.eventsHelper.addEventListener(worker, "stepRecoverFromError", this._onStepRecoverFromError.bind(this, resumeAfterStepError)),
       import_utils.eventsHelper.addEventListener(worker, "attach", this._onAttach.bind(this)),
       import_utils.eventsHelper.addEventListener(worker, "done", this._onDone.bind(this)),
       import_utils.eventsHelper.addEventListener(worker, "exit", this.onExit.bind(this))

package/lib/runner/failureTracker.js

@@ -27,6 +27,12 @@ class FailureTracker {
     this._failureCount = 0;
     this._hasWorkerErrors = false;
   }
+  canRecoverFromStepError() {
+    return !!this._recoverFromStepErrorHandler;
+  }
+  setRecoverFromStepErrorHandler(recoverFromStepErrorHandler) {
+    this._recoverFromStepErrorHandler = recoverFromStepErrorHandler;
+  }
   onRootSuite(rootSuite) {
     this._rootSuite = rootSuite;
   }
@@ -34,6 +40,14 @@ class FailureTracker {
     if (test.outcome() === "unexpected" && test.results.length > test.retries)
       ++this._failureCount;
   }
+  recoverFromStepError(stepId, error, resumeAfterStepError) {
+    if (!this._recoverFromStepErrorHandler) {
+      resumeAfterStepError({ stepId, status: "failed" });
+      return;
+    }
+    void this._recoverFromStepErrorHandler(stepId, error).then(resumeAfterStepError).catch(() => {
+    });
+  }
   onWorkerError() {
     this._hasWorkerErrors = true;
   }

package/lib/runner/testRunner.js

@@ -0,0 +1,372 @@
+"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 testRunner_exports = {};
+__export(testRunner_exports, {
+  TestRunner: () => TestRunner,
+  TestRunnerEvent: () => TestRunnerEvent
+});
+module.exports = __toCommonJS(testRunner_exports);
+var import_events = __toESM(require("events"));
+var import_fs = __toESM(require("fs"));
+var import_path = __toESM(require("path"));
+var import_server = require("playwright-core/lib/server");
+var import_utils = require("playwright-core/lib/utils");
+var import_configLoader = require("../common/configLoader");
+var import_fsWatcher = require("../fsWatcher");
+var import_teleReceiver = require("../isomorphic/teleReceiver");
+var import_gitCommitInfoPlugin = require("../plugins/gitCommitInfoPlugin");
+var import_webServerPlugin = require("../plugins/webServerPlugin");
+var import_base = require("../reporters/base");
+var import_internalReporter = require("../reporters/internalReporter");
+var import_compilationCache = require("../transform/compilationCache");
+var import_util = require("../util");
+var import_reporters = require("./reporters");
+var import_tasks = require("./tasks");
+const TestRunnerEvent = {
+  TestFilesChanged: "testFilesChanged",
+  RecoverFromStepError: "recoverFromStepError"
+};
+class TestRunner extends import_events.default {
+  constructor(configLocation, configCLIOverrides) {
+    super();
+    this._watchedProjectDirs = /* @__PURE__ */ new Set();
+    this._ignoredProjectOutputs = /* @__PURE__ */ new Set();
+    this._watchedTestDependencies = /* @__PURE__ */ new Set();
+    this._queue = Promise.resolve();
+    this._watchTestDirs = false;
+    this._populateDependenciesOnList = false;
+    this._recoverFromStepErrors = false;
+    this._resumeAfterStepErrors = /* @__PURE__ */ new Map();
+    this._configLocation = configLocation;
+    this._configCLIOverrides = configCLIOverrides;
+    this._watcher = new import_fsWatcher.Watcher((events) => {
+      const collector = /* @__PURE__ */ new Set();
+      events.forEach((f) => (0, import_compilationCache.collectAffectedTestFiles)(f.file, collector));
+      this.emit(TestRunnerEvent.TestFilesChanged, [...collector]);
+    });
+  }
+  async initialize(params) {
+    this._watchTestDirs = !!params.watchTestDirs;
+    this._populateDependenciesOnList = !!params.populateDependenciesOnList;
+    this._recoverFromStepErrors = !!params.recoverFromStepErrors;
+  }
+  resizeTerminal(params) {
+    process.stdout.columns = params.cols;
+    process.stdout.rows = params.rows;
+    process.stderr.columns = params.cols;
+    process.stderr.rows = params.rows;
+  }
+  hasSomeBrowsers() {
+    for (const browserName of ["chromium", "webkit", "firefox"]) {
+      try {
+        import_server.registry.findExecutable(browserName).executablePathOrDie("javascript");
+        return true;
+      } catch {
+      }
+    }
+    return false;
+  }
+  async installBrowsers() {
+    const executables = import_server.registry.defaultExecutables();
+    await import_server.registry.install(executables, false);
+  }
+  async runGlobalSetup(userReporters) {
+    await this.runGlobalTeardown();
+    const reporter = new import_internalReporter.InternalReporter(userReporters);
+    const config = await this._loadConfigOrReportError(reporter, this._configCLIOverrides);
+    if (!config)
+      return { status: "failed" };
+    const { status, cleanup } = await (0, import_tasks.runTasksDeferCleanup)(new import_tasks.TestRun(config, reporter), [
+      ...(0, import_tasks.createGlobalSetupTasks)(config)
+    ]);
+    if (status !== "passed")
+      await cleanup();
+    else
+      this._globalSetup = { cleanup };
+    return { status };
+  }
+  async runGlobalTeardown() {
+    const globalSetup = this._globalSetup;
+    const status = await globalSetup?.cleanup();
+    this._globalSetup = void 0;
+    return { status };
+  }
+  async startDevServer(userReporters) {
+    await this.stopDevServer();
+    const reporter = new import_internalReporter.InternalReporter(userReporters);
+    const config = await this._loadConfigOrReportError(reporter);
+    if (!config)
+      return { status: "failed" };
+    const { status, cleanup } = await (0, import_tasks.runTasksDeferCleanup)(new import_tasks.TestRun(config, reporter), [
+      (0, import_tasks.createLoadTask)("out-of-process", { failOnLoadErrors: true, filterOnly: false }),
+      (0, import_tasks.createStartDevServerTask)()
+    ]);
+    if (status !== "passed")
+      await cleanup();
+    else
+      this._devServer = { cleanup };
+    return { status };
+  }
+  async stopDevServer() {
+    const devServer = this._devServer;
+    const status = await devServer?.cleanup();
+    this._devServer = void 0;
+    return { status };
+  }
+  async clearCache() {
+    const reporter = new import_internalReporter.InternalReporter([]);
+    const config = await this._loadConfigOrReportError(reporter);
+    if (!config)
+      return;
+    await (0, import_tasks.runTasks)(new import_tasks.TestRun(config, reporter), [
+      (0, import_tasks.createClearCacheTask)(config)
+    ]);
+  }
+  async listFiles(userReporters, params) {
+    const reporter = new import_internalReporter.InternalReporter(userReporters);
+    const config = await this._loadConfigOrReportError(reporter);
+    if (!config)
+      return { status: "failed" };
+    config.cliProjectFilter = params.projects?.length ? params.projects : void 0;
+    const status = await (0, import_tasks.runTasks)(new import_tasks.TestRun(config, reporter), [
+      (0, import_tasks.createListFilesTask)(),
+      (0, import_tasks.createReportBeginTask)()
+    ]);
+    return { status };
+  }
+  async listTests(userReporters, params) {
+    let result;
+    this._queue = this._queue.then(async () => {
+      const { config, status } = await this._innerListTests(userReporters, params);
+      if (config)
+        await this._updateWatchedDirs(config);
+      result = { status };
+    }).catch(printInternalError);
+    await this._queue;
+    return result;
+  }
+  async _innerListTests(userReporters, params) {
+    const overrides = {
+      ...this._configCLIOverrides,
+      repeatEach: 1,
+      retries: 0
+    };
+    const reporter = new import_internalReporter.InternalReporter(userReporters);
+    const config = await this._loadConfigOrReportError(reporter, overrides);
+    if (!config)
+      return { status: "failed" };
+    config.cliArgs = params.locations || [];
+    config.cliGrep = params.grep;
+    config.cliGrepInvert = params.grepInvert;
+    config.cliProjectFilter = params.projects?.length ? params.projects : void 0;
+    config.cliListOnly = true;
+    const status = await (0, import_tasks.runTasks)(new import_tasks.TestRun(config, reporter), [
+      (0, import_tasks.createLoadTask)("out-of-process", { failOnLoadErrors: false, filterOnly: false, populateDependencies: this._populateDependenciesOnList }),
+      (0, import_tasks.createReportBeginTask)()
+    ]);
+    return { config, status };
+  }
+  async _updateWatchedDirs(config) {
+    this._watchedProjectDirs = /* @__PURE__ */ new Set();
+    this._ignoredProjectOutputs = /* @__PURE__ */ new Set();
+    for (const p of config.projects) {
+      this._watchedProjectDirs.add(p.project.testDir);
+      this._ignoredProjectOutputs.add(p.project.outputDir);
+    }
+    const result = await resolveCtDirs(config);
+    if (result) {
+      this._watchedProjectDirs.add(result.templateDir);
+      this._ignoredProjectOutputs.add(result.outDir);
+    }
+    if (this._watchTestDirs)
+      await this._updateWatcher(false);
+  }
+  async _updateWatcher(reportPending) {
+    await this._watcher.update([...this._watchedProjectDirs, ...this._watchedTestDependencies], [...this._ignoredProjectOutputs], reportPending);
+  }
+  async runTests(userReporters, params) {
+    let result = { status: "passed" };
+    this._queue = this._queue.then(async () => {
+      result = await this._innerRunTests(userReporters, params).catch((e) => {
+        printInternalError(e);
+        return { status: "failed" };
+      });
+    });
+    await this._queue;
+    return result;
+  }
+  async _innerRunTests(userReporters, params) {
+    await this.stopTests();
+    const overrides = {
+      ...this._configCLIOverrides,
+      repeatEach: 1,
+      retries: 0,
+      preserveOutputDir: true,
+      reporter: params.reporters ? params.reporters.map((r) => [r]) : void 0,
+      use: {
+        ...this._configCLIOverrides.use,
+        ...params.trace === "on" ? { trace: { mode: "on", sources: false, _live: true } } : {},
+        ...params.trace === "off" ? { trace: "off" } : {},
+        ...params.video === "on" || params.video === "off" ? { video: params.video } : {},
+        ...params.headed !== void 0 ? { headless: !params.headed } : {},
+        _optionContextReuseMode: params.reuseContext ? "when-possible" : void 0,
+        _optionConnectOptions: params.connectWsEndpoint ? { wsEndpoint: params.connectWsEndpoint } : void 0
+      },
+      ...params.updateSnapshots ? { updateSnapshots: params.updateSnapshots } : {},
+      ...params.updateSourceMethod ? { updateSourceMethod: params.updateSourceMethod } : {},
+      ...params.workers ? { workers: params.workers } : {}
+    };
+    if (params.trace === "on")
+      process.env.PW_LIVE_TRACE_STACKS = "1";
+    else
+      process.env.PW_LIVE_TRACE_STACKS = void 0;
+    const config = await this._loadConfigOrReportError(new import_internalReporter.InternalReporter(userReporters), overrides);
+    if (!config)
+      return { status: "failed" };
+    config.cliListOnly = false;
+    config.cliPassWithNoTests = true;
+    config.cliArgs = params.locations || [];
+    config.cliGrep = params.grep;
+    config.cliGrepInvert = params.grepInvert;
+    config.cliProjectFilter = params.projects?.length ? params.projects : void 0;
+    config.preOnlyTestFilters = [];
+    if (params.testIds) {
+      const testIdSet = new Set(params.testIds);
+      config.preOnlyTestFilters.push((test) => testIdSet.has(test.id));
+    }
+    const configReporters = await (0, import_reporters.createReporters)(config, "test", true);
+    const reporter = new import_internalReporter.InternalReporter([...configReporters, ...userReporters]);
+    const stop = new import_utils.ManualPromise();
+    const tasks = [
+      (0, import_tasks.createApplyRebaselinesTask)(),
+      (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);
+    testRun.failureTracker.setRecoverFromStepErrorHandler(this._recoverFromStepError.bind(this));
+    const run = (0, import_tasks.runTasks)(testRun, tasks, 0, stop).then(async (status) => {
+      this._testRun = void 0;
+      return status;
+    });
+    this._testRun = { run, stop };
+    return { status: await run };
+  }
+  async _recoverFromStepError(stepId, error) {
+    if (!this._recoverFromStepErrors)
+      return { stepId, status: "failed" };
+    const recoveryPromise = new import_utils.ManualPromise();
+    this._resumeAfterStepErrors.set(stepId, recoveryPromise);
+    if (!error?.message || !error?.location)
+      return { stepId, status: "failed" };
+    this.emit(TestRunnerEvent.RecoverFromStepError, stepId, error.message, error.location);
+    const recoveredResult = await recoveryPromise;
+    if (recoveredResult.stepId !== stepId)
+      return { stepId, status: "failed" };
+    return recoveredResult;
+  }
+  async resumeAfterStepError(params) {
+    const recoveryPromise = this._resumeAfterStepErrors.get(params.stepId);
+    if (recoveryPromise)
+      recoveryPromise.resolve(params);
+  }
+  async watch(params) {
+    this._watchedTestDependencies = /* @__PURE__ */ new Set();
+    for (const fileName of params.fileNames) {
+      this._watchedTestDependencies.add(fileName);
+      (0, import_compilationCache.dependenciesForTestFile)(fileName).forEach((file) => this._watchedTestDependencies.add(file));
+    }
+    await this._updateWatcher(true);
+  }
+  async findRelatedTestFiles(params) {
+    const errorReporter = (0, import_reporters.createErrorCollectingReporter)(import_base.internalScreen);
+    const reporter = new import_internalReporter.InternalReporter([errorReporter]);
+    const config = await this._loadConfigOrReportError(reporter);
+    if (!config)
+      return { errors: errorReporter.errors(), testFiles: [] };
+    const status = await (0, import_tasks.runTasks)(new import_tasks.TestRun(config, reporter), [
+      (0, import_tasks.createLoadTask)("out-of-process", { failOnLoadErrors: true, filterOnly: false, populateDependencies: true })
+    ]);
+    if (status !== "passed")
+      return { errors: errorReporter.errors(), testFiles: [] };
+    return { testFiles: (0, import_compilationCache.affectedTestFiles)(params.files) };
+  }
+  async stopTests() {
+    this._testRun?.stop?.resolve();
+    await this._testRun?.run;
+    this._resumeAfterStepErrors.clear();
+  }
+  async closeGracefully() {
+    (0, import_utils.gracefullyProcessExitDoNotHang)(0);
+  }
+  async _loadConfig(overrides) {
+    try {
+      const config = await (0, import_configLoader.loadConfig)(this._configLocation, overrides);
+      if (!this._plugins) {
+        (0, import_webServerPlugin.webServerPluginsForConfig)(config).forEach((p) => config.plugins.push({ factory: p }));
+        (0, import_gitCommitInfoPlugin.addGitCommitInfoPlugin)(config);
+        this._plugins = config.plugins || [];
+      } else {
+        config.plugins.splice(0, config.plugins.length, ...this._plugins);
+      }
+      return { config };
+    } catch (e) {
+      return { config: null, error: (0, import_util.serializeError)(e) };
+    }
+  }
+  async _loadConfigOrReportError(reporter, overrides) {
+    const { config, error } = await this._loadConfig(overrides);
+    if (config)
+      return config;
+    reporter.onConfigure(import_teleReceiver.baseFullConfig);
+    reporter.onError(error);
+    await reporter.onEnd({ status: "failed" });
+    await reporter.onExit();
+    return null;
+  }
+}
+function printInternalError(e) {
+  console.error("Internal error:", e);
+}
+async function resolveCtDirs(config) {
+  const use = config.config.projects[0].use;
+  const relativeTemplateDir = use.ctTemplateDir || "playwright";
+  const templateDir = await import_fs.default.promises.realpath(import_path.default.normalize(import_path.default.join(config.configDir, relativeTemplateDir))).catch(() => void 0);
+  if (!templateDir)
+    return null;
+  const outDir = use.ctCacheDir ? import_path.default.resolve(config.configDir, use.ctCacheDir) : import_path.default.resolve(templateDir, ".cache");
+  return {
+    outDir,
+    templateDir
+  };
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  TestRunner,
+  TestRunnerEvent
+});

package/lib/runner/testServer.js

@@ -28,31 +28,21 @@ var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__ge
 var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
 var testServer_exports = {};
 __export(testServer_exports, {
+  TestRunnerEvent: () => TestRunnerEvent,
   TestServerDispatcher: () => TestServerDispatcher,
-  resolveCtDirs: () => resolveCtDirs,
   runTestServer: () => runTestServer,
   runUIMode: () => runUIMode
 });
 module.exports = __toCommonJS(testServer_exports);
-var import_fs = __toESM(require("fs"));
-var import_path = __toESM(require("path"));
 var import_util = __toESM(require("util"));
 var import_server = require("playwright-core/lib/server");
 var import_utils = require("playwright-core/lib/utils");
 var import_utilsBundle = require("playwright-core/lib/utilsBundle");
-var import_reporters = require("./reporters");
-var import_sigIntWatcher = require("./sigIntWatcher");
-var import_tasks = require("./tasks");
 var import_configLoader = require("../common/configLoader");
-var import_fsWatcher = require("../fsWatcher");
-var import_teleReceiver = require("../isomorphic/teleReceiver");
-var import_gitCommitInfoPlugin = require("../plugins/gitCommitInfoPlugin");
-var import_webServerPlugin = require("../plugins/webServerPlugin");
-var import_base = require("../reporters/base");
-var import_internalReporter = require("../reporters/internalReporter");
 var import_list = __toESM(require("../reporters/list"));
-var import_compilationCache = require("../transform/compilationCache");
-var import_util2 = require("../util");
+var import_reporters = require("./reporters");
+var import_sigIntWatcher = require("./sigIntWatcher");
+var import_testRunner = require("./testRunner");
 const originalDebugLog = import_utilsBundle.debug.log;
 const originalStdoutWrite = process.stdout.write;
 const originalStderrWrite = process.stderr.write;
@@ -70,18 +60,15 @@ class TestServer {
     await this._dispatcher?.runGlobalTeardown();
   }
 }
+const TestRunnerEvent = {
+  TestFilesChanged: "testFilesChanged",
+  RecoverFromStepError: "recoverFromStepError"
+};
 class TestServerDispatcher {
   constructor(configLocation, configCLIOverrides) {
-    this._watchedProjectDirs = /* @__PURE__ */ new Set();
-    this._ignoredProjectOutputs = /* @__PURE__ */ new Set();
-    this._watchedTestDependencies = /* @__PURE__ */ new Set();
-    this._queue = Promise.resolve();
     this._serializer = require.resolve("./uiModeReporter");
-    this._watchTestDirs = false;
     this._closeOnDisconnect = false;
-    this._populateDependenciesOnList = false;
-    this._configLocation = configLocation;
-    this._configCLIOverrides = configCLIOverrides;
+    this._testRunner = new import_testRunner.TestRunner(configLocation, configCLIOverrides);
     this.transport = {
       onconnect: () => {
       },
@@ -91,27 +78,29 @@ class TestServerDispatcher {
           (0, import_utils.gracefullyProcessExitDoNotHang)(0);
       }
     };
-    this._watcher = new import_fsWatcher.Watcher((events) => {
-      const collector = /* @__PURE__ */ new Set();
-      events.forEach((f) => (0, import_compilationCache.collectAffectedTestFiles)(f.file, collector));
-      this._dispatchEvent("testFilesChanged", { testFiles: [...collector] });
-    });
     this._dispatchEvent = (method, params) => this.transport.sendEvent?.(method, params);
+    this._testRunner.on(TestRunnerEvent.TestFilesChanged, (testFiles) => this._dispatchEvent("testFilesChanged", { testFiles }));
+    this._testRunner.on(TestRunnerEvent.RecoverFromStepError, (stepId, message, location) => this._dispatchEvent("recoverFromStepError", { stepId, message, location }));
   }
   async _wireReporter(messageSink) {
     return await (0, import_reporters.createReporterForTestServer)(this._serializer, messageSink);
   }
-  async _collectingInternalReporter(...extraReporters) {
+  async _collectingReporter() {
     const report = [];
-    const collectingReporter = await (0, import_reporters.createReporterForTestServer)(this._serializer, (e) => report.push(e));
-    return { reporter: new import_internalReporter.InternalReporter([collectingReporter, ...extraReporters]), report };
+    return {
+      reporter: await (0, import_reporters.createReporterForTestServer)(this._serializer, (e) => report.push(e)),
+      report
+    };
   }
   async initialize(params) {
     this._serializer = params.serializer || require.resolve("./uiModeReporter");
     this._closeOnDisconnect = !!params.closeOnDisconnect;
     await this._setInterceptStdio(!!params.interceptStdio);
-    this._watchTestDirs = !!params.watchTestDirs;
-    this._populateDependenciesOnList = !!params.populateDependenciesOnList;
+    await this._testRunner.initialize({
+      watchTestDirs: !!params.watchTestDirs,
+      populateDependenciesOnList: !!params.populateDependenciesOnList,
+      recoverFromStepErrors: !!params.recoverFromStepErrors
+    });
   }
   async ping() {
   }
@@ -121,221 +110,68 @@ class TestServerDispatcher {
     (0, import_utilsBundle.open)("vscode://file/" + params.location.file + ":" + params.location.line).catch((e) => console.error(e));
   }
   async resizeTerminal(params) {
-    process.stdout.columns = params.cols;
-    process.stdout.rows = params.rows;
-    process.stderr.columns = params.cols;
-    process.stderr.rows = params.rows;
+    this._testRunner.resizeTerminal(params);
   }
   async checkBrowsers() {
-    return { hasBrowsers: hasSomeBrowsers() };
+    return { hasBrowsers: this._testRunner.hasSomeBrowsers() };
   }
   async installBrowsers() {
-    await installBrowsers();
+    await this._testRunner.installBrowsers();
   }
   async runGlobalSetup(params) {
     await this.runGlobalTeardown();
-    const { reporter, report } = await this._collectingInternalReporter(new import_list.default());
-    const config = await this._loadConfigOrReportError(reporter, this._configCLIOverrides);
-    if (!config)
-      return { status: "failed", report };
-    const { status, cleanup } = await (0, import_tasks.runTasksDeferCleanup)(new import_tasks.TestRun(config, reporter), [
-      ...(0, import_tasks.createGlobalSetupTasks)(config)
-    ]);
-    if (status !== "passed")
-      await cleanup();
-    else
-      this._globalSetup = { cleanup, report };
+    const { reporter, report } = await this._collectingReporter();
+    this._globalSetupReport = report;
+    const { status } = await this._testRunner.runGlobalSetup([reporter, new import_list.default()]);
     return { report, status };
   }
   async runGlobalTeardown() {
-    const globalSetup = this._globalSetup;
-    const status = await globalSetup?.cleanup();
-    this._globalSetup = void 0;
-    return { status, report: globalSetup?.report || [] };
+    const { status } = await this._testRunner.runGlobalTeardown();
+    const report = this._globalSetupReport || [];
+    this._globalSetupReport = void 0;
+    return { status, report };
   }
   async startDevServer(params) {
     await this.stopDevServer({});
-    const { reporter, report } = await this._collectingInternalReporter();
-    const config = await this._loadConfigOrReportError(reporter);
-    if (!config)
-      return { report, status: "failed" };
-    const { status, cleanup } = await (0, import_tasks.runTasksDeferCleanup)(new import_tasks.TestRun(config, reporter), [
-      (0, import_tasks.createLoadTask)("out-of-process", { failOnLoadErrors: true, filterOnly: false }),
-      (0, import_tasks.createStartDevServerTask)()
-    ]);
-    if (status !== "passed")
-      await cleanup();
-    else
-      this._devServer = { cleanup, report };
+    const { reporter, report } = await this._collectingReporter();
+    const { status } = await this._testRunner.startDevServer([reporter]);
     return { report, status };
   }
   async stopDevServer(params) {
-    const devServer = this._devServer;
-    const status = await devServer?.cleanup();
-    this._devServer = void 0;
-    return { status, report: devServer?.report || [] };
+    const { status } = await this._testRunner.stopDevServer();
+    const report = this._devServerReport || [];
+    this._devServerReport = void 0;
+    return { status, report };
   }
   async clearCache(params) {
-    const reporter = new import_internalReporter.InternalReporter([]);
-    const config = await this._loadConfigOrReportError(reporter);
-    if (!config)
-      return;
-    await (0, import_tasks.runTasks)(new import_tasks.TestRun(config, reporter), [
-      (0, import_tasks.createClearCacheTask)(config)
-    ]);
+    await this._testRunner.clearCache();
   }
   async listFiles(params) {
-    const { reporter, report } = await this._collectingInternalReporter();
-    const config = await this._loadConfigOrReportError(reporter);
-    if (!config)
-      return { status: "failed", report };
-    config.cliProjectFilter = params.projects?.length ? params.projects : void 0;
-    const status = await (0, import_tasks.runTasks)(new import_tasks.TestRun(config, reporter), [
-      (0, import_tasks.createListFilesTask)(),
-      (0, import_tasks.createReportBeginTask)()
-    ]);
+    const { reporter, report } = await this._collectingReporter();
+    const { status } = await this._testRunner.listFiles([reporter], params);
     return { report, status };
   }
   async listTests(params) {
-    let result;
-    this._queue = this._queue.then(async () => {
-      const { config, report, status } = await this._innerListTests(params);
-      if (config)
-        await this._updateWatchedDirs(config);
-      result = { report, status };
-    }).catch(printInternalError);
-    await this._queue;
-    return result;
-  }
-  async _innerListTests(params) {
-    const overrides = {
-      ...this._configCLIOverrides,
-      repeatEach: 1,
-      retries: 0
-    };
-    const { reporter, report } = await this._collectingInternalReporter();
-    const config = await this._loadConfigOrReportError(reporter, overrides);
-    if (!config)
-      return { report, reporter, status: "failed" };
-    config.cliArgs = params.locations || [];
-    config.cliGrep = params.grep;
-    config.cliGrepInvert = params.grepInvert;
-    config.cliProjectFilter = params.projects?.length ? params.projects : void 0;
-    config.cliListOnly = true;
-    const status = await (0, import_tasks.runTasks)(new import_tasks.TestRun(config, reporter), [
-      (0, import_tasks.createLoadTask)("out-of-process", { failOnLoadErrors: false, filterOnly: false, populateDependencies: this._populateDependenciesOnList }),
-      (0, import_tasks.createReportBeginTask)()
-    ]);
-    return { config, report, reporter, status };
-  }
-  async _updateWatchedDirs(config) {
-    this._watchedProjectDirs = /* @__PURE__ */ new Set();
-    this._ignoredProjectOutputs = /* @__PURE__ */ new Set();
-    for (const p of config.projects) {
-      this._watchedProjectDirs.add(p.project.testDir);
-      this._ignoredProjectOutputs.add(p.project.outputDir);
-    }
-    const result = await resolveCtDirs(config);
-    if (result) {
-      this._watchedProjectDirs.add(result.templateDir);
-      this._ignoredProjectOutputs.add(result.outDir);
-    }
-    if (this._watchTestDirs)
-      await this._updateWatcher(false);
-  }
-  async _updateWatcher(reportPending) {
-    await this._watcher.update([...this._watchedProjectDirs, ...this._watchedTestDependencies], [...this._ignoredProjectOutputs], reportPending);
+    const { reporter, report } = await this._collectingReporter();
+    const { status } = await this._testRunner.listTests([reporter], params);
+    return { report, status };
   }
   async runTests(params) {
-    let result = { status: "passed" };
-    this._queue = this._queue.then(async () => {
-      result = await this._innerRunTests(params).catch((e) => {
-        printInternalError(e);
-        return { status: "failed" };
-      });
-    });
-    await this._queue;
-    return result;
-  }
-  async _innerRunTests(params) {
-    await this.stopTests();
-    const overrides = {
-      ...this._configCLIOverrides,
-      repeatEach: 1,
-      retries: 0,
-      preserveOutputDir: true,
-      reporter: params.reporters ? params.reporters.map((r) => [r]) : void 0,
-      use: {
-        ...this._configCLIOverrides.use,
-        ...params.trace === "on" ? { trace: { mode: "on", sources: false, _live: true } } : {},
-        ...params.trace === "off" ? { trace: "off" } : {},
-        ...params.video === "on" || params.video === "off" ? { video: params.video } : {},
-        ...params.headed !== void 0 ? { headless: !params.headed } : {},
-        _optionContextReuseMode: params.reuseContext ? "when-possible" : void 0,
-        _optionConnectOptions: params.connectWsEndpoint ? { wsEndpoint: params.connectWsEndpoint } : void 0
-      },
-      ...params.updateSnapshots ? { updateSnapshots: params.updateSnapshots } : {},
-      ...params.updateSourceMethod ? { updateSourceMethod: params.updateSourceMethod } : {},
-      ...params.workers ? { workers: params.workers } : {}
-    };
-    if (params.trace === "on")
-      process.env.PW_LIVE_TRACE_STACKS = "1";
-    else
-      process.env.PW_LIVE_TRACE_STACKS = void 0;
     const wireReporter = await this._wireReporter((e) => this._dispatchEvent("report", e));
-    const config = await this._loadConfigOrReportError(new import_internalReporter.InternalReporter([wireReporter]), overrides);
-    if (!config)
-      return { status: "failed" };
-    config.cliListOnly = false;
-    config.cliPassWithNoTests = true;
-    config.cliArgs = params.locations || [];
-    config.cliGrep = params.grep;
-    config.cliGrepInvert = params.grepInvert;
-    config.cliProjectFilter = params.projects?.length ? params.projects : void 0;
-    config.preOnlyTestFilters = [];
-    if (params.testIds) {
-      const testIdSet = new Set(params.testIds);
-      config.preOnlyTestFilters.push((test) => testIdSet.has(test.id));
-    }
-    const configReporters = await (0, import_reporters.createReporters)(config, "test", true);
-    const reporter = new import_internalReporter.InternalReporter([...configReporters, wireReporter]);
-    const stop = new import_utils.ManualPromise();
-    const tasks = [
-      (0, import_tasks.createApplyRebaselinesTask)(),
-      (0, import_tasks.createLoadTask)("out-of-process", { filterOnly: true, failOnLoadErrors: false, doNotRunDepsOutsideProjectFilter: true }),
-      ...(0, import_tasks.createRunTestsTasks)(config)
-    ];
-    const run = (0, import_tasks.runTasks)(new import_tasks.TestRun(config, reporter), tasks, 0, stop).then(async (status) => {
-      this._testRun = void 0;
-      return status;
-    });
-    this._testRun = { run, stop };
-    return { status: await run };
+    const { status } = await this._testRunner.runTests([wireReporter], params);
+    return { status };
+  }
+  async resumeAfterStepError(params) {
+    await this._testRunner.resumeAfterStepError(params);
   }
   async watch(params) {
-    this._watchedTestDependencies = /* @__PURE__ */ new Set();
-    for (const fileName of params.fileNames) {
-      this._watchedTestDependencies.add(fileName);
-      (0, import_compilationCache.dependenciesForTestFile)(fileName).forEach((file) => this._watchedTestDependencies.add(file));
-    }
-    await this._updateWatcher(true);
+    await this._testRunner.watch(params);
   }
   async findRelatedTestFiles(params) {
-    const errorReporter = (0, import_reporters.createErrorCollectingReporter)(import_base.internalScreen);
-    const reporter = new import_internalReporter.InternalReporter([errorReporter]);
-    const config = await this._loadConfigOrReportError(reporter);
-    if (!config)
-      return { errors: errorReporter.errors(), testFiles: [] };
-    const status = await (0, import_tasks.runTasks)(new import_tasks.TestRun(config, reporter), [
-      (0, import_tasks.createLoadTask)("out-of-process", { failOnLoadErrors: true, filterOnly: false, populateDependencies: true })
-    ]);
-    if (status !== "passed")
-      return { errors: errorReporter.errors(), testFiles: [] };
-    return { testFiles: (0, import_compilationCache.affectedTestFiles)(params.files) };
+    return this._testRunner.findRelatedTestFiles(params);
   }
   async stopTests() {
-    this._testRun?.stop?.resolve();
-    await this._testRun?.run;
+    await this._testRunner.stopTests();
   }
   async _setInterceptStdio(intercept) {
     if (process.env.PWTEST_DEBUG)
@@ -362,32 +198,7 @@ class TestServerDispatcher {
     }
   }
   async closeGracefully() {
-    (0, import_utils.gracefullyProcessExitDoNotHang)(0);
-  }
-  async _loadConfig(overrides) {
-    try {
-      const config = await (0, import_configLoader.loadConfig)(this._configLocation, overrides);
-      if (!this._plugins) {
-        (0, import_webServerPlugin.webServerPluginsForConfig)(config).forEach((p) => config.plugins.push({ factory: p }));
-        (0, import_gitCommitInfoPlugin.addGitCommitInfoPlugin)(config);
-        this._plugins = config.plugins || [];
-      } else {
-        config.plugins.splice(0, config.plugins.length, ...this._plugins);
-      }
-      return { config };
-    } catch (e) {
-      return { config: null, error: (0, import_util2.serializeError)(e) };
-    }
-  }
-  async _loadConfigOrReportError(reporter, overrides) {
-    const { config, error } = await this._loadConfig(overrides);
-    if (config)
-      return config;
-    reporter.onConfigure(import_teleReceiver.baseFullConfig);
-    reporter.onError(error);
-    await reporter.onEnd({ status: "failed" });
-    await reporter.onExit();
-    return null;
+    await this._testRunner.closeGracefully();
   }
 }
 async function runUIMode(configFile, configCLIOverrides, options) {
@@ -448,39 +259,10 @@ function chunkToPayload(type, chunk) {
     return { type, buffer: chunk.toString("base64") };
   return { type, text: chunk };
 }
-function hasSomeBrowsers() {
-  for (const browserName of ["chromium", "webkit", "firefox"]) {
-    try {
-      import_server.registry.findExecutable(browserName).executablePathOrDie("javascript");
-      return true;
-    } catch {
-    }
-  }
-  return false;
-}
-async function installBrowsers() {
-  const executables = import_server.registry.defaultExecutables();
-  await import_server.registry.install(executables, false);
-}
-function printInternalError(e) {
-  console.error("Internal error:", e);
-}
-async function resolveCtDirs(config) {
-  const use = config.config.projects[0].use;
-  const relativeTemplateDir = use.ctTemplateDir || "playwright";
-  const templateDir = await import_fs.default.promises.realpath(import_path.default.normalize(import_path.default.join(config.configDir, relativeTemplateDir))).catch(() => void 0);
-  if (!templateDir)
-    return null;
-  const outDir = use.ctCacheDir ? import_path.default.resolve(config.configDir, use.ctCacheDir) : import_path.default.resolve(templateDir, ".cache");
-  return {
-    outDir,
-    templateDir
-  };
-}
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
+  TestRunnerEvent,
   TestServerDispatcher,
-  resolveCtDirs,
   runTestServer,
   runUIMode
 });

package/lib/runner/watchMode.js

@@ -31,6 +31,7 @@ __export(watchMode_exports, {
   runWatchModeLoop: () => runWatchModeLoop
 });
 module.exports = __toCommonJS(watchMode_exports);
+var import_fs = __toESM(require("fs"));
 var import_path = __toESM(require("path"));
 var import_readline = __toESM(require("readline"));
 var import_stream = require("stream");
@@ -42,6 +43,8 @@ var import_utilsBundle = require("../utilsBundle");
 var import_testServer = require("./testServer");
 var import_teleSuiteUpdater = require("../isomorphic/teleSuiteUpdater");
 var import_testServerConnection = require("../isomorphic/testServerConnection");
+var import_util = require("../util");
+var import_babelBundle = require("../transform/babelBundle");
 class InMemoryTransport extends import_stream.EventEmitter {
   constructor(send) {
     super();
@@ -113,7 +116,37 @@ async function runWatchModeLoop(configLocation, initialOptions) {
     });
   });
   testServerConnection.onReport((report2) => teleSuiteUpdater.processTestReportEvent(report2));
-  await testServerConnection.initialize({ interceptStdio: false, watchTestDirs: true, populateDependenciesOnList: true });
+  testServerConnection.onRecoverFromStepError(({ stepId, message, location }) => {
+    process.stdout.write(`
+Test error occurred.
+`);
+    process.stdout.write("\n" + createErrorCodeframe(message, location) + "\n");
+    process.stdout.write(`
+${import_utils2.colors.dim("Try recovering from the error. Press")} ${import_utils2.colors.bold("c")} ${import_utils2.colors.dim("to continue or")} ${import_utils2.colors.bold("t")} ${import_utils2.colors.dim("to throw the error")}
+`);
+    readKeyPress((text) => {
+      if (text === "c") {
+        process.stdout.write(`
+${import_utils2.colors.dim("Continuing after recovery...")}
+`);
+        testServerConnection.resumeAfterStepError({ stepId, status: "recovered", value: void 0 }).catch(() => {
+        });
+      } else if (text === "t") {
+        process.stdout.write(`
+${import_utils2.colors.dim("Throwing error...")}
+`);
+        testServerConnection.resumeAfterStepError({ stepId, status: "failed" }).catch(() => {
+        });
+      }
+      return text;
+    });
+  });
+  await testServerConnection.initialize({
+    interceptStdio: false,
+    watchTestDirs: true,
+    populateDependenciesOnList: true,
+    recoverFromStepErrors: !process.env.PWTEST_RECOVERY_DISABLED
+  });
   await testServerConnection.runGlobalSetup({});
   const { report } = await testServerConnection.listTests({});
   teleSuiteUpdater.processListReport(report);
@@ -385,6 +418,29 @@ async function toggleShowBrowser() {
 `);
   }
 }
+function createErrorCodeframe(message, location) {
+  let source;
+  try {
+    source = import_fs.default.readFileSync(location.file, "utf-8") + "\n//";
+  } catch (e) {
+    return;
+  }
+  return (0, import_babelBundle.codeFrameColumns)(
+    source,
+    {
+      start: {
+        line: location.line,
+        column: location.column
+      }
+    },
+    {
+      highlightCode: true,
+      linesAbove: 5,
+      linesBelow: 5,
+      message: (0, import_util.stripAnsiEscapes)(message).split("\n")[0] || void 0
+    }
+  );
+}
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
   runWatchModeLoop

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, recoverFromStepErrors, extraEnv, outputDir) {
     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)),
+      recoverFromStepErrors
     };
   }
   async start() {
@@ -77,6 +78,9 @@ class WorkerHost extends import_processHost.ProcessHost {
   runTestGroup(runPayload) {
     this.sendMessageNoReply({ method: "runTestGroup", params: runPayload });
   }
+  resumeAfterStepError(result) {
+    this.sendMessageNoReply({ method: "resumeAfterStepError", params: result });
+  }
   hash() {
     return this._hash;
   }

package/lib/worker/testInfo.js

@@ -43,7 +43,7 @@ var import_testTracing = require("./testTracing");
 var import_util2 = require("./util");
 var import_transform = require("../transform/transform");
 class TestInfoImpl {
-  constructor(configInternal, projectInternal, workerParams, test, retry, onStepBegin, onStepEnd, onAttach) {
+  constructor(configInternal, projectInternal, workerParams, test, retry, onStepBegin, onStepRecoverFromError, onStepEnd, onAttach) {
     this._snapshotNames = { lastAnonymousSnapshotIndex: 0, lastNamedSnapshotIndex: {} };
     this._ariaSnapshotNames = { lastAnonymousSnapshotIndex: 0, lastNamedSnapshotIndex: {} };
     this._wasInterrupted = false;
@@ -61,6 +61,7 @@ class TestInfoImpl {
     this.errors = [];
     this.testId = test?.id ?? "";
     this._onStepBegin = onStepBegin;
+    this._onStepRecoverFromError = onStepRecoverFromError;
     this._onStepEnd = onStepEnd;
     this._onAttach = onAttach;
     this._startTime = (0, import_utils.monotonicTime)();
@@ -84,6 +85,7 @@ class TestInfoImpl {
     this.fn = test?.fn ?? (() => {
     });
     this.expectedStatus = test?.expectedStatus ?? "skipped";
+    this._recoverFromStepErrorResults = workerParams.recoverFromStepErrors ? /* @__PURE__ */ new Map() : void 0;
     this._timeoutManager = new import_timeoutManager.TimeoutManager(this.project.timeout);
     if (configInternal.configCLIOverrides.debug)
       this._setDebugMode();
@@ -202,6 +204,22 @@ class TestInfoImpl {
       steps: [],
       attachmentIndices: [],
       info: new TestStepInfoImpl(this, stepId, data.title, parentStep?.info),
+      recoverFromStepError: async (error) => {
+        if (!this._recoverFromStepErrorResults)
+          return { stepId, status: "failed" };
+        const payload = {
+          testId: this.testId,
+          stepId,
+          error: (0, import_util.serializeError)(error)
+        };
+        this._onStepRecoverFromError(payload);
+        const recoveryPromise = new import_utils.ManualPromise();
+        this._recoverFromStepErrorResults.set(stepId, recoveryPromise);
+        const recoveryResult = await recoveryPromise;
+        if (recoveryResult.stepId !== stepId)
+          return { stepId, status: "failed" };
+        return recoveryResult;
+      },
       complete: (result) => {
         if (step.endWallTime)
           return;
@@ -270,6 +288,11 @@ ${(0, import_utils.stringifyStackFrames)(step.boxedStack).join("\n")}`;
     }
     return step;
   }
+  resumeAfterStepError(result) {
+    const recoveryPromise = this._recoverFromStepErrorResults?.get(result.stepId);
+    if (recoveryPromise)
+      recoveryPromise.resolve(result);
+  }
   _interrupt() {
     this._wasInterrupted = true;
     this._timeoutManager.interrupt();

package/lib/worker/workerMain.js

@@ -95,6 +95,7 @@ class WorkerMain extends import_process.ProcessRunner {
       const fakeTestInfo = new import_testInfo.TestInfoImpl(this._config, this._project, this._params, void 0, 0, () => {
       }, () => {
       }, () => {
+      }, () => {
       });
       const runnable = { type: "teardown" };
       await fakeTestInfo._runWithTimeout(runnable, () => this._loadIfNeeded()).catch(() => {
@@ -216,6 +217,9 @@ class WorkerMain extends import_process.ProcessRunner {
       this._runFinished.resolve();
     }
   }
+  resumeAfterStepError(params) {
+    this._currentTest?.resumeAfterStepError(params);
+  }
   async _runTest(test, retry, nextTest) {
     const testInfo = new import_testInfo.TestInfoImpl(
       this._config,
@@ -224,6 +228,7 @@ class WorkerMain extends import_process.ProcessRunner {
       test,
       retry,
       (stepBeginPayload) => this.dispatchEvent("stepBegin", stepBeginPayload),
+      (stepRecoverFromErrorPayload) => this.dispatchEvent("stepRecoverFromError", stepRecoverFromErrorPayload),
       (stepEndPayload) => this.dispatchEvent("stepEnd", stepEndPayload),
       (attachment) => this.dispatchEvent("attach", attachment)
     );

package/package.json

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