playwright 1.55.0 → 1.56.0-alpha-2025-08-21

package/lib/runner/dispatcher.js

@@ -158,8 +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 recoverFromStepErrors = this._failureTracker.canRecoverFromStepError();
-    const worker = new import_workerHost.WorkerHost(testGroup, parallelIndex, loaderData, recoverFromStepErrors, this._extraEnvByProjectId.get(testGroup.projectId) || {}, outputDir);
+    const worker = new import_workerHost.WorkerHost(testGroup, parallelIndex, loaderData, this._extraEnvByProjectId.get(testGroup.projectId) || {}, outputDir);
     const handleOutput = (params) => {
       const chunk = chunkFromParams(params);
       if (worker.didFail()) {
@@ -312,24 +311,6 @@ 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) {
@@ -455,13 +436,11 @@ 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,12 +27,6 @@ class FailureTracker {
     this._failureCount = 0;
     this._hasWorkerErrors = false;
   }
-  canRecoverFromStepError() {
-    return !!this._recoverFromStepErrorHandler;
-  }
-  setRecoverFromStepErrorHandler(recoverFromStepErrorHandler) {
-    this._recoverFromStepErrorHandler = recoverFromStepErrorHandler;
-  }
   onRootSuite(rootSuite) {
     this._rootSuite = rootSuite;
   }
@@ -40,14 +34,6 @@ 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

@@ -51,8 +51,7 @@ var import_reporters = require("./reporters");
 var import_tasks = require("./tasks");
 var import_lastRun = require("./lastRun");
 const TestRunnerEvent = {
-  TestFilesChanged: "testFilesChanged",
-  RecoverFromStepError: "recoverFromStepError"
+  TestFilesChanged: "testFilesChanged"
 };
 class TestRunner extends import_events.default {
   constructor(configLocation, configCLIOverrides) {
@@ -63,8 +62,6 @@ class TestRunner extends import_events.default {
     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) => {
@@ -76,7 +73,6 @@ class TestRunner extends import_events.default {
   async initialize(params) {
     this._watchTestDirs = !!params.watchTestDirs;
     this._populateDependenciesOnList = !!params.populateDependenciesOnList;
-    this._recoverFromStepErrors = !!params.recoverFromStepErrors;
   }
   resizeTerminal(params) {
     process.stdout.columns = params.cols;
@@ -232,6 +228,7 @@ class TestRunner extends import_events.default {
       ...this._configCLIOverrides,
       repeatEach: 1,
       retries: 0,
+      timeout: params.timeout,
       preserveOutputDir: true,
       reporter: params.reporters ? params.reporters.map((r) => [r]) : void 0,
       use: {
@@ -274,7 +271,6 @@ class TestRunner extends import_events.default {
       ...(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;
@@ -282,24 +278,6 @@ class TestRunner extends import_events.default {
     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(fileNames) {
     this._watchedTestDependencies = /* @__PURE__ */ new Set();
     for (const fileName of fileNames) {
@@ -325,7 +303,6 @@ class TestRunner extends import_events.default {
   async stopTests() {
     this._testRun?.stop?.resolve();
     await this._testRun?.run;
-    this._resumeAfterStepErrors.clear();
   }
   async closeGracefully() {
     (0, import_utils.gracefullyProcessExitDoNotHang)(0);

package/lib/runner/testServer.js

@@ -61,8 +61,7 @@ class TestServer {
   }
 }
 const TestRunnerEvent = {
-  TestFilesChanged: "testFilesChanged",
-  RecoverFromStepError: "recoverFromStepError"
+  TestFilesChanged: "testFilesChanged"
 };
 class TestServerDispatcher {
   constructor(configLocation, configCLIOverrides) {
@@ -80,7 +79,6 @@ class TestServerDispatcher {
     };
     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);
@@ -98,8 +96,7 @@ class TestServerDispatcher {
     await this._setInterceptStdio(!!params.interceptStdio);
     await this._testRunner.initialize({
       watchTestDirs: !!params.watchTestDirs,
-      populateDependenciesOnList: !!params.populateDependenciesOnList,
-      recoverFromStepErrors: !!params.recoverFromStepErrors
+      populateDependenciesOnList: !!params.populateDependenciesOnList
     });
   }
   async ping() {
@@ -161,9 +158,6 @@ class TestServerDispatcher {
     const { status } = await this._testRunner.runTests(wireReporter, params);
     return { status };
   }
-  async resumeAfterStepError(params) {
-    await this._testRunner.resumeAfterStepError(params);
-  }
   async watch(params) {
     await this._testRunner.watch(params.fileNames);
   }

package/lib/runner/watchMode.js

@@ -31,7 +31,6 @@ __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");
@@ -43,8 +42,6 @@ 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();
@@ -116,36 +113,10 @@ async function runWatchModeLoop(configLocation, initialOptions) {
     });
   });
   testServerConnection.onReport((report2) => teleSuiteUpdater.processTestReportEvent(report2));
-  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
+    populateDependenciesOnList: true
   });
   await testServerConnection.runGlobalSetup({});
   const { report } = await testServerConnection.listTests({});
@@ -418,29 +389,6 @@ 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, recoverFromStepErrors, extraEnv, outputDir) {
+  constructor(testGroup, parallelIndex, config, extraEnv, outputDir) {
     const workerIndex = lastWorkerIndex++;
     super(require.resolve("../worker/workerMain.js"), `worker-${workerIndex}`, {
       ...extraEnv,
@@ -56,8 +56,7 @@ class WorkerHost extends import_processHost.ProcessHost {
       repeatEachIndex: testGroup.repeatEachIndex,
       projectId: testGroup.projectId,
       config,
-      artifactsDir: import_path.default.join(outputDir, (0, import_folders.artifactsFolderName)(workerIndex)),
-      recoverFromStepErrors
+      artifactsDir: import_path.default.join(outputDir, (0, import_folders.artifactsFolderName)(workerIndex))
     };
   }
   async start() {
@@ -78,9 +77,6 @@ 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, onStepRecoverFromError, onStepEnd, onAttach) {
+  constructor(configInternal, projectInternal, workerParams, test, retry, onStepBegin, onStepEnd, onAttach) {
     this._snapshotNames = { lastAnonymousSnapshotIndex: 0, lastNamedSnapshotIndex: {} };
     this._ariaSnapshotNames = { lastAnonymousSnapshotIndex: 0, lastNamedSnapshotIndex: {} };
     this._wasInterrupted = false;
@@ -61,7 +61,6 @@ 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)();
@@ -85,7 +84,6 @@ 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();
@@ -203,22 +201,6 @@ 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;
@@ -287,11 +269,6 @@ ${(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,7 +95,6 @@ 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(() => {
@@ -217,9 +216,6 @@ 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,
@@ -228,7 +224,6 @@ 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",
+  "version": "1.56.0-alpha-2025-08-21",
   "description": "A high-level API to automate web browsers",
   "repository": {
     "type": "git",
@@ -21,7 +21,7 @@
     "./package.json": "./package.json",
     "./lib/common/configLoader": "./lib/common/configLoader.js",
     "./lib/fsWatcher": "./lib/fsWatcher.js",
-    "./lib/mcp": "./lib/mcp/exports.js",
+    "./lib/mcp/sdk/exports": "./lib/mcp/sdk/exports.js",
     "./lib/program": "./lib/program.js",
     "./lib/reporters/base": "./lib/reporters/base.js",
     "./lib/reporters/list": "./lib/reporters/list.js",
@@ -60,7 +60,7 @@
   },
   "license": "Apache-2.0",
   "dependencies": {
-    "playwright-core": "1.55.0"
+    "playwright-core": "1.56.0-alpha-2025-08-21"
   },
   "optionalDependencies": {
     "fsevents": "2.3.2"