@smoothdeploy/playwright 1.58.4 → 1.61.0

package/lib/index.js

@@ -29,28 +29,37 @@ var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: tru
 var index_exports = {};
 __export(index_exports, {
   _baseTest: () => _baseTest,
-  defineConfig: () => import_configLoader.defineConfig,
+  _utilityTest: () => _utilityTest,
+  defineConfig: () => import_common2.defineConfig,
   expect: () => import_expect.expect,
   mergeExpects: () => import_expect2.mergeExpects,
-  mergeTests: () => import_testType2.mergeTests,
+  mergeTests: () => import_common2.mergeTests,
   test: () => test
 });
 module.exports = __toCommonJS(index_exports);
 var import_fs = __toESM(require("fs"));
 var import_path = __toESM(require("path"));
 var playwrightLibrary = __toESM(require("playwright-core"));
-var import_utils = require("playwright-core/lib/utils");
-var import_screenshotCompositor = require("playwright-core/lib/server/screenshotCompositor");
+var import_coreBundle = require("playwright-core/lib/coreBundle");
 var import_utilsBundle = require("playwright-core/lib/utilsBundle");
-var import_globals = require("./common/globals");
-var import_testType = require("./common/testType");
+var import_errorContext = require("./errorContext");
+var import_common = require("./common");
+var globals = __toESM(require("./globals"));
+var import_package = require("./package");
 var import_browserBackend = require("./mcp/test/browserBackend");
 var import_expect = require("./matchers/expect");
-var import_configLoader = require("./common/configLoader");
-var import_testType2 = require("./common/testType");
+var import_common2 = require("./common");
 var import_expect2 = require("./matchers/expect");
-const _baseTest = import_testType.rootTestType.test;
-(0, import_utils.setBoxedStackPrefixes)([import_path.default.dirname(require.resolve("../package.json"))]);
+const { asLocatorDescription } = require("playwright-core/lib/coreBundle").iso;
+const { getActionGroup, renderTitleForCall } = require("playwright-core/lib/coreBundle").iso;
+const { escapeHTML } = require("playwright-core/lib/coreBundle").iso;
+const { jsonStringifyForceASCII } = require("playwright-core/lib/coreBundle").utils;
+const { createGuid } = require("playwright-core/lib/coreBundle").utils;
+const { debugMode } = require("playwright-core/lib/coreBundle").utils;
+const { setBoxedStackPrefixes } = require("playwright-core/lib/coreBundle").utils;
+const { currentZone } = require("playwright-core/lib/coreBundle").utils;
+const _baseTest = import_common.testType.rootTestType.test;
+setBoxedStackPrefixes([import_package.packageRoot]);
 if (process["__pw_initiator__"]) {
   const originalStackTraceLimit = Error.stackTraceLimit;
   Error.stackTraceLimit = 200;
@@ -62,28 +71,159 @@ if (process["__pw_initiator__"]) {
 } else {
   process["__pw_initiator__"] = new Error().stack;
 }
-const playwrightFixtures = {
-  defaultBrowserType: ["chromium", { scope: "worker", option: true, box: true }],
-  browserName: [({ defaultBrowserType }, use) => use(defaultBrowserType), { scope: "worker", option: true, box: true }],
+const utilityFixtures = {
   playwright: [async ({}, use) => {
     await use(require("playwright-core"));
   }, { scope: "worker", box: true }],
+  screenshot: ["off", { scope: "worker", option: true, box: true }],
+  trace: ["off", { scope: "worker", option: true, box: true }],
+  launchOptions: [{}, { scope: "worker", option: true, box: true }],
   headless: [({ launchOptions }, use) => use(launchOptions.headless ?? true), { scope: "worker", option: true, box: true }],
+  resultScreenshots: [false, { scope: "worker", option: true, box: true }],
+  pauseOnFailure: [false, { scope: "worker", option: true, box: true }],
+  testIdAttribute: ["data-testid", { option: true, box: true }],
+  _combinedContextOptions: [{}, { box: true }],
+  _setupArtifacts: [async ({ playwright, headless, screenshot, resultScreenshots, pauseOnFailure, _combinedContextOptions }, use, testInfo) => {
+    testInfo.setTimeout(testInfo.project.timeout);
+    const artifactsRecorder = new ArtifactsRecorder(playwright, tracing().artifactsDir(), screenshot, resultScreenshots, pauseOnFailure && !headless);
+    await artifactsRecorder.willStartTest(testInfo);
+    const tracingGroupSteps = [];
+    const pausedContexts = /* @__PURE__ */ new Set();
+    const csiListener = {
+      onApiCallBegin: (data, channel) => {
+        const testInfo2 = globals.currentTestInfo();
+        if (!testInfo2 || data.apiName.includes("setTestIdAttribute") || data.apiName === "tracing.groupEnd")
+          return;
+        const zone = currentZone().data("stepZone");
+        const isExpectCall = data.apiName === "locator._expect" || data.apiName === "frame._expect" || data.apiName === "page._expectScreenshot";
+        if (zone && zone.category === "expect" && isExpectCall) {
+          if (zone.apiName)
+            data.apiName = zone.apiName;
+          if (zone.shortTitle || zone.title)
+            data.title = zone.shortTitle ?? zone.title;
+          data.stepId = zone.stepId;
+          if (resultScreenshots && channel.params?.selector)
+            data._channel = channel;
+          return;
+        }
+        const step = testInfo2._addStep({
+          location: data.frames[0],
+          category: "pw:api",
+          title: renderTitle(channel.type, channel.method, channel.params, data.title),
+          apiName: data.apiName,
+          params: channel.params,
+          group: getActionGroup({ type: channel.type, method: channel.method })
+        }, tracingGroupSteps[tracingGroupSteps.length - 1]);
+        data.userData = step;
+        data.stepId = step.stepId;
+        if (data.apiName === "tracing.group")
+          tracingGroupSteps.push(step);
+        if (resultScreenshots && channel.params?.selector)
+          data._channel = channel;
+      },
+      onApiCallEnd: async (data) => {
+        if (data.apiName === "tracing.group")
+          return;
+        if (data.apiName === "tracing.groupEnd") {
+          const step2 = tracingGroupSteps.pop();
+          step2?.complete({ error: data.error });
+          return;
+        }
+        const channel = data._channel;
+        if (channel && !data.error) {
+          const testInfo2 = globals.currentTestInfo();
+          if (testInfo2) {
+            try {
+              await captureResultScreenshot(channel, data, testInfo2);
+            } catch {
+            }
+          }
+        }
+        const step = data.userData;
+        step?.complete({ error: data.error });
+      },
+      onWillPause: ({ keepTestTimeout }) => {
+        if (!keepTestTimeout)
+          globals.currentTestInfo()?._setIgnoreTimeouts(true);
+      },
+      runBeforeCreateBrowserContext: async (options) => {
+        for (const [key, value] of Object.entries(_combinedContextOptions)) {
+          if (!(key in options))
+            options[key] = value;
+        }
+      },
+      runBeforeCreateRequestContext: async (options) => {
+        for (const [key, value] of Object.entries(_combinedContextOptions)) {
+          if (!(key in options))
+            options[key] = value;
+        }
+      },
+      runAfterCreateBrowserContext: async (context) => {
+        context.debugger.on("pausedstatechanged", () => {
+          const paused = !!context.debugger.pausedDetails();
+          if (pausedContexts.has(context) && !paused) {
+            pausedContexts.delete(context);
+            testInfo._setIgnoreTimeouts(false);
+          } else if (!pausedContexts.has(context) && paused) {
+            pausedContexts.add(context);
+            testInfo._setIgnoreTimeouts(true);
+          }
+        });
+        await artifactsRecorder.didCreateBrowserContext(context);
+        const currentTestInfo = globals.currentTestInfo();
+        if (currentTestInfo) {
+          attachConnectedHeaderIfNeeded(currentTestInfo, context.browser());
+          currentTestInfo._onCustomMessageCallback = (0, import_browserBackend.createCustomMessageHandler)(currentTestInfo, context);
+          await (0, import_browserBackend.runDaemonForContext)(currentTestInfo, context);
+        }
+      },
+      runAfterCreateRequestContext: async (context) => {
+        await artifactsRecorder.didCreateRequestContext(context);
+      },
+      runBeforeCloseBrowserContext: async (context) => {
+        await artifactsRecorder.willCloseBrowserContext(context);
+      },
+      runBeforeCloseRequestContext: async (context) => {
+        await artifactsRecorder.willCloseRequestContext(context);
+      }
+    };
+    const clientInstrumentation = playwright._instrumentation;
+    clientInstrumentation.addListener(csiListener);
+    await use();
+    clientInstrumentation.removeListener(csiListener);
+    await artifactsRecorder.didFinishTest();
+  }, { auto: "all-hooks-included", title: "trace recording", box: true, timeout: 0 }],
+  request: async ({ playwright }, use) => {
+    const request = await playwright.request.newContext();
+    await use(request);
+    const hook = test.info()._currentHookType();
+    if (hook === "beforeAll") {
+      await request.dispose({ reason: [
+        `Fixture { request } from beforeAll cannot be reused in a test.`,
+        `  - Recommended fix: use a separate { request } in the test.`,
+        `  - Alternatively, manually create APIRequestContext in beforeAll and dispose it in afterAll.`,
+        `See https://playwright.dev/docs/api-testing#sending-api-requests-from-ui-tests for more details.`
+      ].join("\n") });
+    } else {
+      await request.dispose();
+    }
+  }
+};
+const _utilityTest = _baseTest.extend(utilityFixtures);
+const playwrightFixtures = {
+  defaultBrowserType: ["chromium", { scope: "worker", option: true, box: true }],
+  browserName: [({ defaultBrowserType }, use) => use(defaultBrowserType), { scope: "worker", option: true, box: true }],
   channel: [({ launchOptions }, use) => use(launchOptions.channel), { scope: "worker", option: true, box: true }],
-  launchOptions: [{}, { scope: "worker", option: true, box: true }],
   connectOptions: [async ({ _optionConnectOptions }, use) => {
     await use(connectOptionsFromEnv() || _optionConnectOptions);
   }, { scope: "worker", option: true, box: true }],
-  screenshot: ["off", { scope: "worker", option: true, box: true }],
-  resultScreenshots: [false, { scope: "worker", option: true, box: true }],
-  pauseOnFailure: [false, { scope: "worker", option: true, box: true }],
   video: ["off", { scope: "worker", option: true, box: true }],
-  trace: ["off", { scope: "worker", option: true, box: true }],
   _browserOptions: [async ({ playwright, headless, channel, launchOptions }, use) => {
     const options = {
       handleSIGINT: false,
       ...launchOptions,
-      tracesDir: tracing().tracesDir()
+      tracesDir: tracing().tracesDir(),
+      artifactsDir: tracing().artifactsDir()
     };
     if (headless !== void 0)
       options.headless = headless;
@@ -93,16 +233,16 @@ const playwrightFixtures = {
     await use(options);
     playwright._defaultLaunchOptions = void 0;
   }, { scope: "worker", auto: true, box: true }],
-  browser: [async ({ playwright, browserName, _browserOptions, connectOptions }, use) => {
+  browser: [async ({ playwright, browserName, _browserOptions, connectOptions }, use, workerInfo) => {
     if (!["chromium", "firefox", "webkit"].includes(browserName))
       throw new Error(`Unexpected browserName "${browserName}", must be one of "chromium", "firefox" or "webkit"`);
     if (connectOptions) {
-      const browser2 = await playwright[browserName].connect({
+      const browser2 = await playwright[browserName].connect(connectOptions.wsEndpoint, {
         ...connectOptions,
-        exposeNetwork: connectOptions.exposeNetwork ?? connectOptions._exposeNetwork,
+        exposeNetwork: connectOptions.exposeNetwork,
         headers: {
           // HTTP headers are ASCII only (not UTF-8).
-          "x-playwright-launch-options": (0, import_utils.jsonStringifyForceASCII)(_browserOptions),
+          "x-playwright-launch-options": jsonStringifyForceASCII(_browserOptions),
           ...connectOptions.headers
         }
       });
@@ -111,6 +251,8 @@ const playwrightFixtures = {
       return;
     }
     const browser = await playwright[browserName].launch();
+    if (process.env.PLAYWRIGHT_DASHBOARD)
+      await browser.bind(`worker-${workerInfo.parallelIndex}`);
     await use(browser);
     await browser.close({ reason: "Test ended." });
   }, { scope: "worker", timeout: 0 }],
@@ -135,14 +277,12 @@ const playwrightFixtures = {
   userAgent: [({ contextOptions }, use) => use(contextOptions.userAgent), { option: true, box: true }],
   viewport: [({ contextOptions }, use) => use(contextOptions.viewport === void 0 ? null : contextOptions.viewport), { option: true, box: true }],
   actionTimeout: [0, { option: true, box: true }],
-  testIdAttribute: ["data-testid", { option: true, box: true }],
   navigationTimeout: [0, { option: true, box: true }],
   baseURL: [async ({}, use) => {
     await use(process.env.PLAYWRIGHT_TEST_BASE_URL);
   }, { option: true, box: true }],
   serviceWorkers: [({ contextOptions }, use) => use(contextOptions.serviceWorkers ?? "allow"), { option: true, box: true }],
   contextOptions: [{}, { option: true, box: true }],
-  agentOptions: [void 0, { option: true, box: true }],
   _combinedContextOptions: [async ({
     acceptDownloads,
     bypassCSP,
@@ -217,116 +357,21 @@ const playwrightFixtures = {
       ...contextOptions,
       ...options
     });
-  }, { box: true }],
-  _setupContextOptions: [async ({ playwright, actionTimeout, navigationTimeout, testIdAttribute }, use, testInfo) => {
+  }, { scope: "test", box: true }],
+  _setupContextOptions: [async ({ playwright, actionTimeout, navigationTimeout, testIdAttribute }, use, _testInfo) => {
+    const testInfo = _testInfo;
     if (testIdAttribute)
       playwrightLibrary.selectors.setTestIdAttribute(testIdAttribute);
     testInfo.snapshotSuffix = process.platform;
-    if ((0, import_utils.debugMode)() === "inspector")
-      testInfo._setDebugMode();
+    testInfo._onCustomMessageCallback = () => Promise.reject(new Error("Only tests that use default Playwright context or page fixture support test_debug"));
+    if (debugMode() === "inspector")
+      testInfo._setIgnoreTimeouts(true);
     playwright._defaultContextTimeout = actionTimeout || 0;
     playwright._defaultContextNavigationTimeout = navigationTimeout || 0;
     await use();
     playwright._defaultContextTimeout = void 0;
     playwright._defaultContextNavigationTimeout = void 0;
   }, { auto: "all-hooks-included", title: "context configuration", box: true }],
-  _setupArtifacts: [async ({ playwright, headless, screenshot, resultScreenshots, pauseOnFailure, _combinedContextOptions }, use, testInfo) => {
-    testInfo.setTimeout(testInfo.project.timeout);
-    const artifactsRecorder = new ArtifactsRecorder(playwright, tracing().artifactsDir(), screenshot, resultScreenshots, pauseOnFailure && !headless);
-    await artifactsRecorder.willStartTest(testInfo);
-    const tracingGroupSteps = [];
-    const csiListener = {
-      onApiCallBegin: (data, channel) => {
-        const testInfo2 = (0, import_globals.currentTestInfo)();
-        if (!testInfo2 || data.apiName.includes("setTestIdAttribute") || data.apiName === "tracing.groupEnd")
-          return;
-        const zone = (0, import_utils.currentZone)().data("stepZone");
-        const isExpectCall = data.apiName === "locator._expect" || data.apiName === "frame._expect" || data.apiName === "page._expectScreenshot";
-        if (zone && zone.category === "expect" && isExpectCall) {
-          if (zone.apiName)
-            data.apiName = zone.apiName;
-          if (zone.shortTitle || zone.title)
-            data.title = zone.shortTitle ?? zone.title;
-          data.stepId = zone.stepId;
-          if (resultScreenshots && channel.params?.selector)
-            data._channel = channel;
-          return;
-        }
-        const stepTitle = renderTitle(channel.type, channel.method, channel.params, data.title);
-        const step = testInfo2._addStep({
-          location: data.frames[0],
-          category: "pw:api",
-          title: stepTitle,
-          apiName: data.apiName,
-          params: channel.params,
-          group: (0, import_utils.getActionGroup)({ type: channel.type, method: channel.method })
-        }, tracingGroupSteps[tracingGroupSteps.length - 1]);
-        data.userData = step;
-        data.stepId = step.stepId;
-        if (data.apiName === "tracing.group")
-          tracingGroupSteps.push(step);
-        if (resultScreenshots && channel.params?.selector)
-          data._channel = channel;
-      },
-      onApiCallEnd: async (data) => {
-        if (data.apiName === "tracing.group")
-          return;
-        if (data.apiName === "tracing.groupEnd") {
-          const step2 = tracingGroupSteps.pop();
-          step2?.complete({ error: data.error });
-          return;
-        }
-        const channel = data._channel;
-        if (channel && !data.error) {
-          const testInfo2 = (0, import_globals.currentTestInfo)();
-          if (testInfo2) {
-            try {
-              await captureResultScreenshot(channel, data, testInfo2);
-            } catch {
-            }
-          }
-        }
-        const step = data.userData;
-        step?.complete({ error: data.error });
-      },
-      onWillPause: ({ keepTestTimeout }) => {
-        if (!keepTestTimeout)
-          (0, import_globals.currentTestInfo)()?._setDebugMode();
-      },
-      runBeforeCreateBrowserContext: async (options) => {
-        for (const [key, value] of Object.entries(_combinedContextOptions)) {
-          if (!(key in options))
-            options[key] = value;
-        }
-      },
-      runBeforeCreateRequestContext: async (options) => {
-        for (const [key, value] of Object.entries(_combinedContextOptions)) {
-          if (!(key in options))
-            options[key] = value;
-        }
-      },
-      runAfterCreateBrowserContext: async (context) => {
-        await artifactsRecorder.didCreateBrowserContext(context);
-        const testInfo2 = (0, import_globals.currentTestInfo)();
-        if (testInfo2)
-          attachConnectedHeaderIfNeeded(testInfo2, context.browser());
-      },
-      runAfterCreateRequestContext: async (context) => {
-        await artifactsRecorder.didCreateRequestContext(context);
-      },
-      runBeforeCloseBrowserContext: async (context) => {
-        await artifactsRecorder.willCloseBrowserContext(context);
-      },
-      runBeforeCloseRequestContext: async (context) => {
-        await artifactsRecorder.willCloseRequestContext(context);
-      }
-    };
-    const clientInstrumentation = playwright._instrumentation;
-    clientInstrumentation.addListener(csiListener);
-    await use();
-    clientInstrumentation.removeListener(csiListener);
-    await artifactsRecorder.didFinishTest();
-  }, { auto: "all-hooks-included", title: "trace recording", box: true, timeout: 0 }],
   _contextFactory: [async ({
     browser,
     video,
@@ -348,23 +393,15 @@ const playwrightFixtures = {
           `If you would like to configure your page before each test, do that in beforeEach hook instead.`
         ].join("\n"));
       }
+      const show = typeof video === "string" ? void 0 : video.show;
       const videoOptions = captureVideo ? {
         recordVideo: {
           dir: tracing().artifactsDir(),
-          size: typeof video === "string" ? void 0 : video.size
+          size: typeof video === "string" ? void 0 : video.size,
+          showActions: show?.actions
         }
       } : {};
       const context = await browser.newContext({ ...videoOptions, ...options });
-      if (process.env.PW_CLOCK === "frozen") {
-        await context._wrapApiCall(async () => {
-          await context.clock.install({ time: 0 });
-          await context.clock.pauseAt(1e3);
-        }, { internal: true });
-      } else if (process.env.PW_CLOCK === "realtime") {
-        await context._wrapApiCall(async () => {
-          await context.clock.install({ time: 0 });
-        }, { internal: true });
-      }
       let closed = false;
       const close = async () => {
         if (closed)
@@ -372,8 +409,7 @@ const playwrightFixtures = {
         closed = true;
         const closeReason = testInfo.status === "timedOut" ? "Test timeout of " + testInfo.timeout + "ms exceeded." : "Test ended.";
         await context.close({ reason: closeReason });
-        const testFailed = testInfo.status !== testInfo.expectedStatus;
-        const preserveVideo = captureVideo && (videoMode === "on" || testFailed && videoMode === "retain-on-failure" || videoMode === "on-first-retry" && testInfo.retry === 1);
+        const preserveVideo = captureVideo && shouldPreserveVideo(videoMode, testInfo);
         if (preserveVideo) {
           const { pagesWithVideo: pagesForVideo } = contexts.get(context);
           const videos = pagesForVideo.map((p) => p.video()).filter((video2) => !!video2);
@@ -405,18 +441,20 @@ const playwrightFixtures = {
     const reuse = mode === "when-possible" && normalizeVideoMode(video) === "off";
     await use(reuse);
   }, { scope: "worker", title: "context", box: true }],
-  context: async ({ browser, _reuseContext, _contextFactory }, use, testInfo) => {
+  context: async ({ browser, video, _reuseContext, _contextFactory }, use, testInfoPublic) => {
     const browserImpl = browser;
+    const testInfo = testInfoPublic;
+    const show = typeof video === "string" ? void 0 : video.show;
     attachConnectedHeaderIfNeeded(testInfo, browserImpl);
     if (!_reuseContext) {
       const { context: context2, close } = await _contextFactory();
-      testInfo._onCustomMessageCallback = (0, import_browserBackend.createCustomMessageHandler)(testInfo, context2);
+      await installScreencastTitleUpdater(testInfo, context2, show?.test);
       await use(context2);
       await close();
       return;
     }
     const context = await browserImpl._wrapApiCall(() => browserImpl._newContextForReuse(), { internal: true });
-    testInfo._onCustomMessageCallback = (0, import_browserBackend.createCustomMessageHandler)(testInfo, context);
+    await installScreencastTitleUpdater(testInfo, context, show?.test);
     await use(context);
     const closeReason = testInfo.status === "timedOut" ? "Test timeout of " + testInfo.timeout + "ms exceeded." : "Test ended.";
     await browserImpl._wrapApiCall(() => browserImpl._disconnectFromReusedContext(closeReason), { internal: true });
@@ -430,54 +468,6 @@ const playwrightFixtures = {
     if (!page)
       page = await context.newPage();
     await use(page);
-  },
-  agent: async ({ page, agentOptions }, use, testInfo) => {
-    const testInfoImpl = testInfo;
-    const cachePathTemplate = agentOptions?.cachePathTemplate ?? "{testDir}/{testFilePath}-cache.json";
-    const resolvedCacheFile = testInfoImpl._applyPathTemplate(cachePathTemplate, "", ".json");
-    const cacheFile = testInfoImpl.config.runAgents === "all" ? void 0 : await testInfoImpl._cloneStorage(resolvedCacheFile);
-    const cacheOutFile = import_path.default.join(testInfoImpl.artifactsDir(), "agent-cache-" + (0, import_utils.createGuid)() + ".json");
-    const provider = agentOptions?.provider && testInfo.config.runAgents !== "none" ? agentOptions.provider : void 0;
-    if (provider)
-      testInfo.setTimeout(0);
-    const cache = {
-      cacheFile,
-      cacheOutFile
-    };
-    const agent = await page.agent({
-      provider,
-      cache,
-      limits: agentOptions?.limits,
-      secrets: agentOptions?.secrets,
-      systemPrompt: agentOptions?.systemPrompt,
-      expect: {
-        timeout: testInfoImpl._projectInternal.expect?.timeout
-      }
-    });
-    await use(agent);
-    const usage = await agent.usage();
-    if (usage.turns > 0)
-      await testInfoImpl.attach("agent-usage", { contentType: "application/json", body: Buffer.from(JSON.stringify(usage, null, 2)) });
-    if (!resolvedCacheFile || !cacheOutFile)
-      return;
-    if (testInfo.status !== "passed")
-      return;
-    await testInfoImpl._upstreamStorage(resolvedCacheFile, cacheOutFile);
-  },
-  request: async ({ playwright }, use) => {
-    const request = await playwright.request.newContext();
-    await use(request);
-    const hook = test.info()._currentHookType();
-    if (hook === "beforeAll") {
-      await request.dispose({ reason: [
-        `Fixture { request } from beforeAll cannot be reused in a test.`,
-        `  - Recommended fix: use a separate { request } in the test.`,
-        `  - Alternatively, manually create APIRequestContext in beforeAll and dispose it in afterAll.`,
-        `See https://playwright.dev/docs/api-testing#sending-api-requests-from-ui-tests for more details.`
-      ].join("\n") });
-    } else {
-      await request.dispose();
-    }
   }
 };
 function normalizeVideoMode(video) {
@@ -489,7 +479,23 @@ function normalizeVideoMode(video) {
   return videoMode;
 }
 function shouldCaptureVideo(videoMode, testInfo) {
-  return videoMode === "on" || videoMode === "retain-on-failure" || videoMode === "on-first-retry" && testInfo.retry === 1;
+  return videoMode === "on" || videoMode === "retain-on-failure" || videoMode === "retain-on-failure-and-retries" || videoMode === "on-first-retry" && testInfo.retry === 1 || videoMode === "on-all-retries" && testInfo.retry > 0 || videoMode === "retain-on-first-failure" && testInfo.retry === 0;
+}
+function shouldPreserveVideo(videoMode, testInfo) {
+  const testFailed = testInfo.status !== testInfo.expectedStatus;
+  switch (videoMode) {
+    case "on":
+    case "on-first-retry":
+    case "on-all-retries":
+      return true;
+    case "retain-on-failure":
+    case "retain-on-first-failure":
+      return testFailed;
+    case "retain-on-failure-and-retries":
+      return testFailed || testInfo.retry > 0;
+    default:
+      return false;
+  }
 }
 function normalizeScreenshotMode(screenshot) {
   if (!screenshot)
@@ -512,12 +518,12 @@ function attachConnectedHeaderIfNeeded(testInfo, browser) {
   }
 }
 function resolveFileToConfig(file) {
-  const config = test.info().config.configFile;
-  if (!config || !file)
+  const config2 = test.info().config.configFile;
+  if (!config2 || !file)
     return file;
   if (import_path.default.isAbsolute(file))
     return file;
-  return import_path.default.resolve(import_path.default.dirname(config), file);
+  return import_path.default.resolve(import_path.default.dirname(config2), file);
 }
 function resolveClientCerticates(clientCertificates) {
   for (const cert of clientCertificates) {
@@ -596,7 +602,7 @@ class SnapshotRecorder {
       return;
     page[this.testInfo._uniqueSymbol] = true;
     try {
-      const path2 = temporary ? this._createTemporaryArtifact((0, import_utils.createGuid)() + this._extension) : this._createAttachmentPath();
+      const path2 = temporary ? this._createTemporaryArtifact(createGuid() + this._extension) : this._createAttachmentPath();
       await this._doSnapshot(page, path2);
       if (temporary)
         this._temporary.push(path2);
@@ -625,7 +631,7 @@ class ArtifactsRecorder {
   }
   async willStartTest(testInfo) {
     this._testInfo = testInfo;
-    testInfo._onDidFinishTestFunctionCallback = () => this.didFinishTestFunction();
+    testInfo._onDidFinishTestFunctionCallbacks.add(() => this.didFinishTestFunction());
     this._screenshotRecorder.fixOrdinal();
     await Promise.all(this._playwright._allContexts().map((context) => this.didCreateBrowserContext(context)));
     const existingApiRequests = Array.from(this._playwright.request._contexts);
@@ -644,6 +650,8 @@ class ArtifactsRecorder {
       return;
     if (this._testInfo.errors.length === 0)
       return;
+    if (this._testInfo.errors.some((e) => e.errorContext))
+      return;
     if (this._pageSnapshot)
       return;
     const page = context.pages()[0];
@@ -651,16 +659,16 @@ class ArtifactsRecorder {
       return;
     try {
       await page._wrapApiCall(async () => {
-        this._pageSnapshot = (await page._snapshotForAI({ timeout: 5e3 })).full;
+        this._pageSnapshot = await page.ariaSnapshot({ mode: "ai", timeout: 5e3 });
       }, { internal: true });
     } catch {
     }
   }
   async didCreateRequestContext(context) {
-    await this._startTraceChunkOnContextCreation(context, context._tracing);
+    await this._startTraceChunkOnContextCreation(context, context.tracing);
   }
   async willCloseRequestContext(context) {
-    await this._stopTracing(context, context._tracing);
+    await this._stopTracing(context, context.tracing);
   }
   async didFinishTestFunction() {
     await this._screenshotRecorder.maybeCapture();
@@ -717,27 +725,29 @@ class ArtifactsRecorder {
     await Promise.all(leftoverContexts.map(async (context2) => {
       await this._stopTracing(context2, context2.tracing);
     }).concat(leftoverApiRequests.map(async (context2) => {
-      await this._stopTracing(context2, context2._tracing);
+      await this._stopTracing(context2, context2.tracing);
     })));
     await this._screenshotRecorder.persistTemporary();
     const context = leftoverContexts[0];
     if (context)
       await this._takePageSnapshot(context);
-    if (this._pageSnapshot && this._testInfo.errors.length > 0 && !this._testInfo.attachments.some((a) => a.name === "error-context")) {
-      const lines = [
-        "# Page snapshot",
-        "",
-        "```yaml",
-        this._pageSnapshot,
-        "```"
-      ];
-      const filePath = this._testInfo.outputPath("error-context.md");
-      await import_fs.default.promises.writeFile(filePath, lines.join("\n"), "utf8");
-      this._testInfo._attach({
-        name: "error-context",
-        contentType: "text/markdown",
-        path: filePath
-      }, void 0);
+    if (this._testInfo.errors.length > 0) {
+      const hasMatcherAriaSnapshot = this._testInfo.errors.some((e) => e.errorContext);
+      const errorContextContent = (0, import_errorContext.buildErrorContext)({
+        titlePath: this._testInfo.titlePath,
+        location: { file: this._testInfo.file, line: this._testInfo.line, column: this._testInfo.column },
+        errors: this._testInfo.errors,
+        pageSnapshot: hasMatcherAriaSnapshot ? void 0 : this._pageSnapshot
+      });
+      if (errorContextContent) {
+        const filePath = this._testInfo.outputPath("error-context.md");
+        await import_fs.default.promises.writeFile(filePath, errorContextContent, "utf8");
+        this._testInfo._attach({
+          name: "error-context",
+          contentType: "text/markdown",
+          path: filePath
+        }, void 0);
+      }
     }
   }
   async _startTraceChunkOnContextCreation(channelOwner, tracing2) {
@@ -805,7 +815,7 @@ async function captureResultScreenshot(channel, data, testInfo) {
         style: "x-pw-glass { display: none !important; }"
       });
     }, { internal: true });
-    const { full, cropped } = (0, import_screenshotCompositor.compositeHighlight)(pngBuffer, box, cssViewport);
+    const { full, cropped } = import_coreBundle.server.compositeHighlight(pngBuffer, box, cssViewport);
     const safeTestId = testInfo.testId.replace(/[^a-zA-Z0-9_-]/g, "-");
     const safeStepId = (data.stepId ?? "unknown").replace(/[^a-zA-Z0-9_-]/g, "-");
     const screenshotDir = import_path.default.join(process.cwd(), ".smoothdeploy-output", "screenshots", safeTestId);
@@ -821,20 +831,67 @@ async function captureResultScreenshot(channel, data, testInfo) {
     _capturingResultScreenshot = false;
   }
 }
+async function installScreencastTitleUpdater(testInfo, context, testAnnotate) {
+  if (!testAnnotate)
+    return;
+  const testTitle = testAnnotate.level === "file" ? [testInfo.titlePath[0]] : testInfo.titlePath;
+  const stepStack = [];
+  const overlays = /* @__PURE__ */ new Map();
+  const position = testAnnotate.position ?? "top-left";
+  const fontSize = testAnnotate.fontSize ?? 14;
+  const level = testAnnotate.level ?? "step";
+  const updateOverlay = async () => {
+    const parts = level === "step" ? [...testTitle, ...stepStack] : testTitle;
+    const html = createTestOverlay(parts, position, fontSize);
+    for (const page of context.pages()) {
+      await overlays.get(page)?.dispose();
+      overlays.delete(page);
+      const disposable = await page.screencast.showOverlay(html);
+      overlays.set(page, disposable);
+    }
+  };
+  testInfo._onUserStepBegin = async (title) => {
+    stepStack.push(title);
+    await updateOverlay();
+  };
+  testInfo._onUserStepEnd = async () => {
+    stepStack.pop();
+    await updateOverlay();
+  };
+  context.on("page", async () => {
+    void updateOverlay();
+  });
+  await updateOverlay();
+}
+function createTestOverlay(parts, position, fontSize) {
+  const positionStyles = {
+    "top-left": "top: 6px; left: 6px;",
+    "top": "top: 6px; left: 50%; transform: translateX(-50%);",
+    "top-right": "top: 6px; right: 6px;",
+    "bottom-left": "bottom: 6px; left: 6px;",
+    "bottom": "bottom: 6px; left: 50%; transform: translateX(-50%);",
+    "bottom-right": "bottom: 6px; right: 6px;"
+  };
+  const posStyle = positionStyles[position] ?? positionStyles["top-left"];
+  return `<div style="white-space: nowrap; font-size: ${fontSize}px; padding: 3px 6px; background: rgba(0,0,0,0.5); color: white; border-radius: 4px; position: absolute; ${posStyle}">
+    ${parts.map((p) => `<div>${escapeHTML(p)}</div>`).join("")}
+  </div>`;
+}
 function renderTitle(type, method, params, title) {
-  const prefix = (0, import_utils.renderTitleForCall)({ title, type, method, params });
+  const prefix = renderTitleForCall({ title, type, method, params });
   let selector;
   if (params?.["selector"] && typeof params.selector === "string")
-    selector = (0, import_utils.asLocatorDescription)("javascript", params.selector);
+    selector = asLocatorDescription("javascript", params.selector);
   return prefix + (selector ? ` ${selector}` : "");
 }
 function tracing() {
   return test.info()._tracing;
 }
-const test = _baseTest.extend(playwrightFixtures);
+const test = _utilityTest.extend(playwrightFixtures);
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
   _baseTest,
+  _utilityTest,
   defineConfig,
   expect,
   mergeExpects,