@wdio/nightwatch-devtools 1.5.1 → 1.6.0

package/dist/index.js

@@ -12,7 +12,7 @@ import {
   serializeError,
   stripAnsi,
   toError
-} from "./chunk-DKSBYMPM.js";
+} from "./chunk-DNCL4MP7.js";
 
 // src/index.ts
 import { fileURLToPath } from "url";
@@ -58,6 +58,12 @@ var REUSE_ENV = {
   RERUN_ENTRY_TYPE: "DEVTOOLS_RERUN_ENTRY_TYPE"
 };
 
+// ../shared/src/snapshot-format.ts
+var SNAPSHOT_INDENT_UNIT = "  ";
+var SNAPSHOT_PAGE_HEADER = "[Page";
+var SNAPSHOT_LOCATOR_DELIM = "\u2192";
+var SNAPSHOT_PURPOSE_TOKEN = "\u2208";
+
 // ../shared/src/timing.ts
 var TIMING_BASE = {
   /** ms to let the dashboard render between rapid state updates. */
@@ -83,6 +89,30 @@ var DEFAULTS_BASE = {
 };
 
 // ../shared/src/trace-actions.ts
+var ASSERT_ACTION_CLASS = "Assert";
+var TRACKED_ASSERT_METHODS = [
+  "equal",
+  "strictEqual",
+  "deepEqual",
+  "deepStrictEqual",
+  "notEqual",
+  "notStrictEqual",
+  "notDeepEqual",
+  "notDeepStrictEqual",
+  "ok",
+  "fail",
+  "throws",
+  "doesNotThrow",
+  "rejects",
+  "doesNotReject",
+  "match",
+  "doesNotMatch"
+];
+var ASSERT_COMMAND_RE = /^(?:assert|verify|expect)\.(\w+)$/;
+function mapAssertCommand(command) {
+  const match = ASSERT_COMMAND_RE.exec(command);
+  return match ? { class: ASSERT_ACTION_CLASS, method: match[1] } : null;
+}
 var ACTION_MAP = {
   // WDIO browser-level
   url: { class: "Page", method: "navigate" },
@@ -111,8 +141,51 @@ var ACTION_MAP = {
   execute: { class: "Page", method: "evaluate" },
   executeAsync: { class: "Page", method: "evaluate" },
   switchToFrame: { class: "Frame", method: "goto" },
-  touchAction: { class: "Element", method: "tap" }
+  touchAction: { class: "Element", method: "tap" },
+  // WDIO element reads — surfaced so query steps appear in the timeline the way
+  // locator queries do in standard trace viewers. Adapters already capture
+  // these; only the export allow-list kept them out.
+  getText: { class: "Element", method: "getText" },
+  getValue: { class: "Element", method: "getValue" },
+  getAttribute: { class: "Element", method: "getAttribute" },
+  getProperty: { class: "Element", method: "getProperty" },
+  getCSSProperty: { class: "Element", method: "getCSSProperty" },
+  getTagName: { class: "Element", method: "getTagName" },
+  getLocation: { class: "Element", method: "getLocation" },
+  getSize: { class: "Element", method: "getSize" },
+  isDisplayed: { class: "Element", method: "isDisplayed" },
+  isExisting: { class: "Element", method: "isExisting" },
+  isEnabled: { class: "Element", method: "isEnabled" },
+  isSelected: { class: "Element", method: "isSelected" },
+  isClickable: { class: "Element", method: "isClickable" },
+  isFocused: { class: "Element", method: "isFocused" },
+  // Explicit user-facing waits (not the internal polling loops behind them).
+  waitForDisplayed: { class: "Element", method: "waitForDisplayed" },
+  waitForExist: { class: "Element", method: "waitForExist" },
+  waitForEnabled: { class: "Element", method: "waitForEnabled" },
+  waitForClickable: { class: "Element", method: "waitForClickable" },
+  waitUntil: { class: "Browser", method: "waitForFunction" },
+  // WDIO page/browser reads
+  getTitle: { class: "Page", method: "getTitle" },
+  getUrl: { class: "Page", method: "getUrl" },
+  getPageSource: { class: "Page", method: "getPageSource" },
+  // Selenium read aliases — normalized onto the WDIO names above so both runners
+  // read identically. getText/getAttribute/getTagName/isDisplayed/isEnabled/
+  // isSelected share the command name across runners and need no alias.
+  getCssValue: { class: "Element", method: "getCSSProperty" },
+  getRect: { class: "Element", method: "getRect" },
+  getCurrentUrl: { class: "Page", method: "getUrl" }
 };
+var POINTABLE_METHODS = /* @__PURE__ */ new Set([
+  "click",
+  "dblclick",
+  "hover",
+  "tap",
+  "dragTo",
+  "scrollIntoViewIfNeeded",
+  "selectOption",
+  "fill"
+]);
 
 // ../shared/src/types.ts
 var TEST_STATE = {
@@ -128,14 +201,37 @@ var SCREENCAST_DEFAULTS = {
   quality: 70,
   maxWidth: 1280,
   maxHeight: 720,
-  pollIntervalMs: 200
+  pollIntervalMs: 200,
+  maxBufferFrames: 2e3
 };
 
 // ../core/src/action-mapping.ts
 function mapCommandToAction(command) {
-  return ACTION_MAP[command] ?? null;
+  return ACTION_MAP[command] ?? mapAssertCommand(command);
+}
+var ASSERT_TITLE_VALUE_MAX = 40;
+function formatAssertValue(value) {
+  let text;
+  if (typeof value === "object" && value !== null) {
+    try {
+      text = JSON.stringify(value);
+    } catch {
+      text = String(value);
+    }
+  } else {
+    text = typeof value === "string" ? JSON.stringify(value) : String(value);
+  }
+  return text.length > ASSERT_TITLE_VALUE_MAX ? `${text.slice(0, ASSERT_TITLE_VALUE_MAX - 1)}\u2026` : text;
 }
-function formatActionTitle(action, args, params) {
+function formatAssertTitle(action, args, params, command) {
+  const values = args.length > 0 ? args.slice(0, 2) : [params?.actual, params?.expected];
+  const label = values.filter((value) => value !== void 0).map(formatAssertValue).join(", ");
+  return `${command ?? `assert.${action.method}`}(${label})`;
+}
+function formatActionTitle(action, args, params, command) {
+  if (action.class === ASSERT_ACTION_CLASS) {
+    return formatAssertTitle(action, args, params, command);
+  }
   const firstArg = args[0] ?? params?.selector;
   if (firstArg === void 0) {
     return `${action.class}.${action.method}()`;
@@ -521,14 +617,14 @@ function translateRecursively(domNode, parentPath = "", index = null) {
       }
     }
   }
-  const path10 = index === null ? "" : `${parentPath ? parentPath + "." : ""}${index}`;
+  const path14 = index === null ? "" : `${parentPath ? parentPath + "." : ""}${index}`;
   return {
     children: childNodesOf(domNode).map(
-      (childNode, childIndex) => translateRecursively(childNode, path10, childIndex)
+      (childNode, childIndex) => translateRecursively(childNode, path14, childIndex)
     ),
     tagName: domNode.nodeName,
     attributes,
-    path: path10
+    path: path14
   };
 }
 function isSameElement(node1, node2) {
@@ -665,11 +761,11 @@ function checkXPathUniqueness(doc, xpathExpr, targetNode) {
     return { isUnique: false };
   }
 }
-function findDOMNodeByPath(doc, path10) {
-  if (!path10) {
+function findDOMNodeByPath(doc, path14) {
+  if (!path14) {
     return doc.documentElement;
   }
-  const indices = path10.split(".").map(Number);
+  const indices = path14.split(".").map(Number);
   let current = doc.documentElement;
   for (const index of indices) {
     if (!current) {
@@ -1310,7 +1406,7 @@ function inferPurpose(nodes, index) {
 }
 function serializeWebSnapshot(nodes, context, options = {}) {
   const { inViewportOnly = true } = options;
-  let header = "[Page";
+  let header = SNAPSHOT_PAGE_HEADER;
   if (context?.title) {
     header += `: ${context.title}`;
   }
@@ -1324,7 +1420,7 @@ function serializeWebSnapshot(nodes, context, options = {}) {
     if (inViewportOnly && node.isInViewport === false) {
       continue;
     }
-    const indent = "  ".repeat(node.depth + 1);
+    const indent = SNAPSHOT_INDENT_UNIT.repeat(node.depth + 1);
     const isInteractive = INTERACTIVE_ROLES.has(node.role);
     if (isStatictextEchoedByParent(nodes, i)) {
       continue;
@@ -1337,12 +1433,16 @@ function serializeWebSnapshot(nodes, context, options = {}) {
       const purpose = inferPurpose(nodes, i);
       if (node.name) {
         lines.push(
-          purpose ? `${indent}${roleLabel} "${node.name}" \u2208 "${purpose}"  \u2192  ${node.selector}` : `${indent}${roleLabel} "${node.name}"  \u2192  ${node.selector}`
+          purpose ? `${indent}${roleLabel} "${node.name}" ${SNAPSHOT_PURPOSE_TOKEN} "${purpose}"  ${SNAPSHOT_LOCATOR_DELIM}  ${node.selector}` : `${indent}${roleLabel} "${node.name}"  ${SNAPSHOT_LOCATOR_DELIM}  ${node.selector}`
         );
       } else if (purpose) {
-        lines.push(`${indent}${roleLabel} \u2208 "${purpose}"  \u2192  ${node.selector}`);
+        lines.push(
+          `${indent}${roleLabel} ${SNAPSHOT_PURPOSE_TOKEN} "${purpose}"  ${SNAPSHOT_LOCATOR_DELIM}  ${node.selector}`
+        );
       } else {
-        lines.push(`${indent}${roleLabel}  \u2192  ${node.selector}`);
+        lines.push(
+          `${indent}${roleLabel}  ${SNAPSHOT_LOCATOR_DELIM}  ${node.selector}`
+        );
       }
     } else {
       lines.push(
@@ -1660,7 +1760,7 @@ function renderMobileNodes(nodes) {
   const selectorIndex = /* @__PURE__ */ new Map();
   for (let i = 0; i < nodes.length; i++) {
     const node = nodes[i];
-    const indent = "  ".repeat(node.depth + 1);
+    const indent = SNAPSHOT_INDENT_UNIT.repeat(node.depth + 1);
     if (NOISY_ROLES.has(node.role) && !node.name && node.depth > 1 && !node.isInteractive) {
       continue;
     }
@@ -1693,12 +1793,16 @@ function renderMobileNodes(nodes) {
       const purpose = mobileInferPurpose(nodes, i);
       if (node.name) {
         lines.push(
-          purpose ? `${indent}${node.role} "${node.name}" \u2208 "${purpose}"  \u2192  ${selector}` : `${indent}${node.role} "${node.name}"  \u2192  ${selector}`
+          purpose ? `${indent}${node.role} "${node.name}" ${SNAPSHOT_PURPOSE_TOKEN} "${purpose}"  ${SNAPSHOT_LOCATOR_DELIM}  ${selector}` : `${indent}${node.role} "${node.name}"  ${SNAPSHOT_LOCATOR_DELIM}  ${selector}`
         );
       } else if (purpose) {
-        lines.push(`${indent}${node.role} \u2208 "${purpose}"  \u2192  ${selector}`);
+        lines.push(
+          `${indent}${node.role} ${SNAPSHOT_PURPOSE_TOKEN} "${purpose}"  ${SNAPSHOT_LOCATOR_DELIM}  ${selector}`
+        );
       } else {
-        lines.push(`${indent}${node.role}  \u2192  ${selector}`);
+        lines.push(
+          `${indent}${node.role}  ${SNAPSHOT_LOCATOR_DELIM}  ${selector}`
+        );
       }
     } else {
       lines.push(
@@ -2003,7 +2107,8 @@ async function captureActionSnapshot(input) {
       ),
       runWith(
         input.runScript,
-        elementsScript(false, true),
+        // includeBounds: the per-action element rects drive A8 input points.
+        elementsScript(true, true),
         []
       )
     ]);
@@ -2050,6 +2155,443 @@ async function captureActionSnapshot(input) {
   }
 }
 
+// ../core/src/artifact-naming.ts
+function trimChar(value, char) {
+  let start2 = 0;
+  let end = value.length;
+  while (start2 < end && value[start2] === char) {
+    start2++;
+  }
+  while (end > start2 && value[end - 1] === char) {
+    end--;
+  }
+  return value.slice(start2, end);
+}
+function fileSlug(value) {
+  return trimChar(value.replace(/[^a-zA-Z0-9_-]+/g, "-"), "-");
+}
+
+// ../core/src/artifacts-manifest.ts
+import fs from "fs/promises";
+import path from "path";
+function artifactsManifestFilename(sessionId) {
+  return `devtools-artifacts-${sessionId}.json`;
+}
+function buildArtifactsManifest(input) {
+  const tests = [];
+  for (const [uid, meta] of input.testMetadata) {
+    tests.push({
+      uid,
+      title: meta.title,
+      specFile: meta.specFile,
+      state: meta.state,
+      attempt: meta.attempt
+    });
+  }
+  return {
+    sessionId: input.sessionId,
+    format: input.format,
+    artifacts: [...input.artifacts],
+    tests
+  };
+}
+async function writeArtifactsManifest(outputDir, manifest) {
+  await fs.mkdir(outputDir, { recursive: true });
+  const filePath = path.join(
+    outputDir,
+    artifactsManifestFilename(manifest.sessionId)
+  );
+  await fs.writeFile(filePath, JSON.stringify(manifest, null, 2), "utf8");
+  return filePath;
+}
+
+// ../core/src/allure-artifacts.ts
+import fs5 from "fs/promises";
+import { basename } from "path";
+
+// ../core/src/screenshot-artifact.ts
+import fs2 from "fs/promises";
+import path2 from "path";
+function shouldCaptureScreenshot(policy, failed) {
+  if (policy === "on") {
+    return true;
+  }
+  if (policy === "only-on-failure") {
+    return failed;
+  }
+  return false;
+}
+async function writeScreenshotArtifact(input) {
+  await fs2.mkdir(input.outputDir, { recursive: true });
+  const filename = `screenshot-${fileSlug(input.testUid)}-${input.sessionId.slice(0, 8)}.png`;
+  const filePath = path2.join(input.outputDir, filename);
+  await fs2.writeFile(filePath, Buffer.from(input.base64, "base64"));
+  return {
+    kind: "screenshot",
+    path: filePath,
+    scope: "test",
+    key: input.testUid,
+    testUids: [input.testUid],
+    retained: true
+  };
+}
+
+// ../core/src/video-slice.ts
+import fs4 from "fs/promises";
+import path4 from "path";
+
+// ../core/src/video-encoder.ts
+import fs3 from "fs/promises";
+import path3 from "path";
+import os from "os";
+import { createRequire } from "module";
+var require2 = createRequire(import.meta.url);
+function loadFfmpeg() {
+  try {
+    return require2("fluent-ffmpeg");
+  } catch {
+    throw new Error(
+      "VideoEncoder: fluent-ffmpeg is required for screencast encoding. Install it with: npm install fluent-ffmpeg"
+    );
+  }
+}
+async function writeFramesAndManifest(frames, tmpDir, ext) {
+  const manifestLines = ["ffconcat version 1.0"];
+  for (let i = 0; i < frames.length; i++) {
+    const frameName = `frame-${String(i).padStart(6, "0")}.${ext}`;
+    const framePath = path3.join(tmpDir, frameName);
+    await fs3.writeFile(framePath, Buffer.from(frames[i].data, "base64"));
+    const nextTs = frames[i + 1]?.timestamp ?? frames[i].timestamp + 100;
+    const durationSecs = Math.max((nextTs - frames[i].timestamp) / 1e3, 0.01);
+    manifestLines.push(`file '${framePath}'`);
+    manifestLines.push(`duration ${durationSecs.toFixed(6)}`);
+  }
+  const lastFramePath = path3.join(
+    tmpDir,
+    `frame-${String(frames.length - 1).padStart(6, "0")}.${ext}`
+  );
+  manifestLines.push(`file '${lastFramePath}'`);
+  const manifestPath = path3.join(tmpDir, "manifest.txt");
+  await fs3.writeFile(manifestPath, manifestLines.join("\n"));
+  return manifestPath;
+}
+function classifyFfmpegError(err) {
+  const msg = err.message || "";
+  if (msg.includes("Cannot find ffmpeg") || msg.includes("ENOENT") || msg.includes("spawn") || msg.includes("not found")) {
+    return new Error(
+      "VideoEncoder: ffmpeg binary not found on PATH. Install ffmpeg: https://ffmpeg.org/download.html"
+    );
+  }
+  return new Error(`VideoEncoder: ffmpeg error \u2014 ${msg}`);
+}
+function runFfmpeg(ffmpeg, manifestPath, outputPath) {
+  return new Promise((resolve2, reject) => {
+    ffmpeg().input(manifestPath).inputOptions(["-f", "concat", "-safe", "0"]).videoCodec("libvpx").outputOptions([
+      "-b:v",
+      "1M",
+      "-pix_fmt",
+      "yuv420p",
+      "-vsync",
+      "cfr",
+      "-r",
+      "10",
+      // Force a keyframe every frame. VP8 can only seek to keyframes, and
+      // libvpx's default GOP places a single keyframe on near-static
+      // screencast content — so scrubber/marker seeks snap back to the
+      // start. At 10fps over short recordings, all-intra keeps seeking
+      // frame-accurate at an acceptable size.
+      "-g",
+      "1",
+      "-keyint_min",
+      "1",
+      "-auto-alt-ref",
+      "0",
+      "-disposition:v",
+      "default"
+    ]).output(outputPath).on("end", () => resolve2()).on("error", (err) => reject(classifyFfmpegError(err))).run();
+  });
+}
+async function encodeToVideo(frames, outputPath, options = {}) {
+  if (frames.length === 0) {
+    throw new Error("VideoEncoder: no frames to encode");
+  }
+  const ffmpeg = loadFfmpeg();
+  const ext = options.captureFormat === "png" ? "png" : "jpg";
+  const tmpDir = await fs3.mkdtemp(
+    path3.join(os.tmpdir(), "devtools-screencast-")
+  );
+  try {
+    const manifestPath = await writeFramesAndManifest(frames, tmpDir, ext);
+    await runFfmpeg(ffmpeg, manifestPath, outputPath);
+  } finally {
+    await fs3.rm(tmpDir, { recursive: true, force: true }).catch(() => {
+    });
+  }
+}
+
+// ../core/src/video-slice.ts
+function sliceFramesFrom(frames, startWallTime) {
+  return frames.filter((f) => f.timestamp >= startWallTime);
+}
+async function encodePerTestVideo(input) {
+  const minFrames = input.minFrames ?? 2;
+  if (input.frames.length < minFrames) {
+    return void 0;
+  }
+  await fs4.mkdir(input.outputDir, { recursive: true });
+  const retrySuffix = input.attempt ? `-retry${input.attempt}` : "";
+  const filename = `video-${fileSlug(input.testUid)}-${input.sessionId.slice(0, 8)}${retrySuffix}.webm`;
+  const filePath = path4.join(input.outputDir, filename);
+  try {
+    await encodeToVideo([...input.frames], filePath, {
+      captureFormat: input.captureFormat
+    });
+  } catch (err) {
+    input.onLog?.("warn", `Per-test video encode failed: ${errorMessage(err)}`);
+    return void 0;
+  }
+  return {
+    kind: "video",
+    path: filePath,
+    scope: "test",
+    key: input.testUid,
+    testUids: [input.testUid],
+    retained: true
+  };
+}
+
+// ../core/src/trace-retention.ts
+var KNOWN_POLICIES = /* @__PURE__ */ new Set([
+  "on",
+  "retain-on-failure",
+  "retain-on-first-failure",
+  "on-first-retry",
+  "on-all-retries",
+  "retain-on-failure-and-retries"
+]);
+function shouldRetainTrace(policy, input) {
+  if (policy === void 0 || policy === "on" || !KNOWN_POLICIES.has(policy)) {
+    return { retain: true };
+  }
+  const outcomes = Array.from(input.outcomes);
+  if (outcomes.length === 0) {
+    return { retain: true, failOpen: true };
+  }
+  const anyFailed = outcomes.some((o) => o.state === "failed");
+  if (!input.attemptInfoAvailable && policy !== "retain-on-failure") {
+    return { retain: anyFailed, degradedToFailure: true };
+  }
+  const groups = groupByTest(outcomes);
+  switch (policy) {
+    case "retain-on-failure":
+      return { retain: groups.some((g) => finalAttempt(g).state === "failed") };
+    case "retain-on-first-failure":
+      return {
+        retain: groups.some((g) => firstAttempt(g)?.state === "failed")
+      };
+    case "on-first-retry":
+      return { retain: groups.some((g) => g.some((o) => o.attempt === 1)) };
+    case "on-all-retries":
+      return { retain: groups.some((g) => g.some((o) => attemptOf(o) >= 1)) };
+    case "retain-on-failure-and-retries":
+      return {
+        retain: groups.some(
+          (g) => finalAttempt(g).state === "failed" || g.some((o) => attemptOf(o) >= 1)
+        )
+      };
+  }
+}
+var attemptOf = (o) => o.attempt ?? 0;
+function groupByTest(outcomes) {
+  const byUid = /* @__PURE__ */ new Map();
+  const groups = [];
+  for (const outcome of outcomes) {
+    if (outcome.uid === void 0) {
+      groups.push([outcome]);
+      continue;
+    }
+    const existing = byUid.get(outcome.uid);
+    if (existing) {
+      existing.push(outcome);
+    } else {
+      const group = [outcome];
+      byUid.set(outcome.uid, group);
+      groups.push(group);
+    }
+  }
+  return groups;
+}
+function finalAttempt(group) {
+  return group.reduce((best, o) => attemptOf(o) >= attemptOf(best) ? o : best);
+}
+function firstAttempt(group) {
+  return group.find((o) => attemptOf(o) === 0);
+}
+function tracePolicyModeWarning(policy, mode) {
+  if (policy === void 0 || mode === "trace") {
+    return void 0;
+  }
+  return 'tracePolicy only applies in trace mode; ignoring it because mode is not "trace".';
+}
+
+// ../core/src/allure-artifacts.ts
+var CONTENT_TYPE_BY_KIND = {
+  trace: "application/zip",
+  video: "video/webm",
+  screenshot: "image/png"
+};
+async function attachTraceArtifact(artifact, sink, onLog) {
+  if (!sink || !artifact.retained || !artifact.path) {
+    return;
+  }
+  try {
+    const stat = await fs5.stat(artifact.path);
+    if (!stat.isFile()) {
+      return;
+    }
+    const content = await fs5.readFile(artifact.path);
+    await sink(
+      basename(artifact.path),
+      content,
+      CONTENT_TYPE_BY_KIND[artifact.kind]
+    );
+  } catch (err) {
+    onLog?.(
+      "warn",
+      `Allure attach skipped for ${artifact.path}: ${String(err)}`
+    );
+  }
+}
+function lastRenderedScreenshot(snapshots, startWallTime) {
+  for (let i = snapshots.length - 1; i >= 0; i--) {
+    const snap = snapshots[i];
+    if (snap.timestamp < startWallTime) {
+      return void 0;
+    }
+    if (snap.command !== "__final__" && snap.screenshot) {
+      return snap.screenshot;
+    }
+  }
+  return void 0;
+}
+async function captureAndAttachScreenshot(input) {
+  const { mode, granularity, policy, failed, screenshotBase64, sessionId } = input;
+  if (mode !== "trace" || granularity !== "test" || !screenshotBase64 || !sessionId || !input.testUid || !shouldCaptureScreenshot(policy, failed)) {
+    return;
+  }
+  const artifact = await writeScreenshotArtifact({
+    outputDir: input.outputDir,
+    testUid: input.testUid,
+    sessionId,
+    base64: screenshotBase64
+  });
+  input.onArtifact(artifact);
+  await attachTraceArtifact(artifact, input.attach, input.onLog);
+}
+async function captureAndAttachVideo(input) {
+  const { mode, granularity, policy, frames, testUid, sessionId } = input;
+  if (mode !== "trace" || granularity !== "test" || !policy || policy === "off" || !frames || !testUid || !sessionId || input.outcomes.length === 0) {
+    return;
+  }
+  if (!shouldRetainTrace(policy, {
+    outcomes: input.outcomes,
+    attemptInfoAvailable: true
+  }).retain) {
+    return;
+  }
+  const artifact = await encodePerTestVideo({
+    frames: sliceFramesFrom(frames, input.startWallTime),
+    outputDir: input.outputDir,
+    testUid,
+    sessionId,
+    attempt: input.attempt,
+    captureFormat: input.captureFormat,
+    onLog: input.onLog
+  });
+  if (!artifact) {
+    return;
+  }
+  input.onArtifact(artifact);
+  await attachTraceArtifact(artifact, input.attach, input.onLog);
+}
+
+// ../core/src/attempt-tracker.ts
+var TestAttemptTracker = class {
+  #ledger = /* @__PURE__ */ new Map();
+  #sawRetry = false;
+  /** Record a starting test; returns its attempt number (0 first, +1 per rerun).
+   *  `specFile` (optional) enables spec-scoped retention lookups. */
+  recordStart(uid, specFile) {
+    const entry = this.#ledger.get(uid);
+    if (entry && entry.attempts.length > 0) {
+      this.#sawRetry = true;
+      entry.attempts[entry.attempts.length - 1].state = "failed";
+    }
+    const attempt = entry ? entry.attempts.length : 0;
+    const slot = { uid, attempt };
+    if (entry) {
+      entry.attempts.push(slot);
+      if (specFile !== void 0) {
+        entry.specFile = specFile;
+      }
+    } else {
+      this.#ledger.set(uid, { specFile, attempts: [slot] });
+    }
+    return attempt;
+  }
+  /** Stamp the resolved state onto uid's most recent attempt slot once the
+   *  outcome is known. `attempt` overrides the slot's number when the adapter
+   *  resolved a more authoritative value (e.g. WDIO's result.retries). */
+  recordOutcome(uid, state, attempt) {
+    const attempts = this.#ledger.get(uid)?.attempts;
+    const slot = attempts?.[attempts.length - 1];
+    if (!slot) {
+      return;
+    }
+    slot.state = state;
+    if (attempt !== void 0) {
+      slot.attempt = attempt;
+    }
+  }
+  /** Latest attempt recorded for `uid`, or undefined if it never started. */
+  attemptFor(uid) {
+    const entry = this.#ledger.get(uid);
+    return entry ? entry.attempts.length - 1 : void 0;
+  }
+  /** True once any test has started more than once (a retry occurred). */
+  get sawRetry() {
+    return this.#sawRetry;
+  }
+  all() {
+    const out = [];
+    for (const entry of this.#ledger.values()) {
+      out.push(...entry.attempts);
+    }
+    return out;
+  }
+  forSpec(specFile) {
+    const out = [];
+    for (const entry of this.#ledger.values()) {
+      if (entry.specFile === specFile) {
+        out.push(...entry.attempts);
+      }
+    }
+    return out;
+  }
+  forTest(uid, attempt) {
+    const attempts = this.#ledger.get(uid)?.attempts ?? [];
+    return attempt === void 0 ? attempts : attempts.filter((a) => a.attempt === attempt);
+  }
+  /** Clear all state — used at session boundaries and reuse-mode reconnects. */
+  reset() {
+    this.#ledger.clear();
+    this.#sawRetry = false;
+  }
+};
+
+// ../core/src/assert-patcher.ts
+import { createRequire as createRequire2 } from "module";
+
 // ../core/src/stack.ts
 import { parse as parseStackTrace } from "stacktrace-parser";
 function isUserCodeFrame(frame) {
@@ -2064,8 +2606,14 @@ function normalizeFilePath(filePath) {
     return stripped;
   }
 }
-function getCallSourceFromStack() {
-  const stack = new Error().stack;
+function isAssertFromUserCode(stack) {
+  if (!stack) {
+    return true;
+  }
+  const caller = parseStackTrace(stack)[1];
+  return !!caller && isUserCodeFrame(caller);
+}
+function getCallSourceFromStack(stack = new Error().stack) {
   if (!stack) {
     return { filePath: void 0, callSource: "unknown:0" };
   }
@@ -2077,31 +2625,839 @@ function getCallSourceFromStack() {
   return { filePath, callSource: `${filePath}:${frame.lineNumber ?? 0}` };
 }
 
-// ../core/src/trace-exporter.ts
-import fs from "fs/promises";
-import path from "path";
-
-// ../core/src/trace-har.ts
-function toHeaderArray(h) {
-  if (!h) {
-    return [];
+// ../core/src/assert-patcher.ts
+var require3 = createRequire2(import.meta.url);
+var ASSERT_PATCHED_SYMBOL = /* @__PURE__ */ Symbol.for(
+  "@wdio/devtools-core/assert-patched"
+);
+function safeSerializeAssertArg(value) {
+  if (value === null || value === void 0) {
+    return value;
   }
-  return Object.entries(h).map(([name, value]) => ({ name, value }));
+  if (value instanceof RegExp) {
+    return value.toString();
+  }
+  if (typeof value === "function") {
+    return "[Function]";
+  }
+  if (typeof value === "object") {
+    try {
+      return JSON.parse(JSON.stringify(value));
+    } catch {
+      return String(value);
+    }
+  }
+  return value;
 }
-function toQueryString(url) {
+function displayAssertValue(value) {
+  if (typeof value === "string") {
+    return `'${value}'`;
+  }
   try {
-    const u = new URL(url);
-    const out = [];
-    u.searchParams.forEach((value, name) => out.push({ name, value }));
-    return out;
+    return JSON.stringify(value) ?? String(value);
   } catch {
-    return [];
+    return String(value);
   }
 }
-function networkRequestToHar(entry) {
-  const startedDateTime = new Date(entry.timestamp).toISOString();
-  const duration = entry.time ?? (entry.endTime ?? entry.startTime) - entry.startTime;
-  const status = entry.response?.status ?? entry.status ?? 0;
+function describeAssertFailure(err) {
+  const error = toError(err);
+  const e = typeof err === "object" && err ? err : {};
+  if (!("actual" in e) && !("expected" in e)) {
+    return { result: void 0, error };
+  }
+  const rawMessage = stripAnsi(error.message);
+  const cleanMessage = e.generatedMessage ? `${rawMessage.split("\n")[0] ?? "Assertion failed"}
+
+Expected: ${displayAssertValue(e.expected)}
+Received: ${displayAssertValue(e.actual)}` : rawMessage;
+  error.message = cleanMessage;
+  if (error.stack) {
+    error.stack = stripAnsi(error.stack).replace(rawMessage, cleanMessage);
+  }
+  return {
+    result: {
+      passed: false,
+      actual: safeSerializeAssertArg(e.actual),
+      expected: safeSerializeAssertArg(e.expected)
+    },
+    error
+  };
+}
+function makeAssertEmitters(methodName, args, onCommand, callerStack) {
+  const callInfo = getCallSourceFromStack(callerStack);
+  if (callInfo.filePath === void 0 || !isAssertFromUserCode(callerStack)) {
+    return { passed: () => {
+    }, failed: () => {
+    } };
+  }
+  const startedAt = Date.now();
+  const sanitizedArgs = args.map(safeSerializeAssertArg);
+  const emit = (result, error) => onCommand({
+    command: `assert.${methodName}`,
+    args: sanitizedArgs,
+    result,
+    error,
+    callSource: callInfo.callSource,
+    timestamp: startedAt
+  });
+  return {
+    passed: () => emit("passed", void 0),
+    failed: (err) => {
+      const { result, error } = describeAssertFailure(err);
+      emit(result, error);
+    }
+  };
+}
+function makePatchedAssertMethod(methodName, assertObj, original, onCommand) {
+  return function patchedAssert(...args) {
+    const callerStack = new Error().stack;
+    const { passed, failed } = makeAssertEmitters(
+      methodName,
+      args,
+      onCommand,
+      callerStack
+    );
+    let result;
+    assertObj[methodName] = original;
+    try {
+      result = original.apply(this, args);
+    } catch (err) {
+      failed(err);
+      throw err;
+    } finally {
+      assertObj[methodName] = patchedAssert;
+    }
+    const maybe = result;
+    if (maybe && typeof maybe.then === "function") {
+      return result.then(
+        (v) => {
+          passed();
+          return v;
+        },
+        (err) => {
+          failed(err);
+          throw err;
+        }
+      );
+    }
+    passed();
+    return result;
+  };
+}
+function capturedAssertToCommandLog(cmd, testUid) {
+  const entry = {
+    command: cmd.command,
+    args: cmd.args,
+    result: cmd.result,
+    timestamp: cmd.timestamp,
+    startTime: cmd.timestamp
+  };
+  if (cmd.error) {
+    entry.error = {
+      name: cmd.error.name,
+      message: cmd.error.message,
+      stack: cmd.error.stack
+    };
+  }
+  if (cmd.callSource) {
+    entry.callSource = cmd.callSource;
+  }
+  if (testUid) {
+    entry.testUid = testUid;
+  }
+  return entry;
+}
+function matcherAssertionToCommandLog(input, testUid) {
+  const command = `${input.prefix ?? "expect"}.${input.method}`;
+  const message = typeof input.message === "function" ? input.message() : input.message;
+  const entry = capturedAssertToCommandLog(
+    {
+      command,
+      args: (input.args ?? []).map(safeSerializeAssertArg),
+      result: input.passed ? "passed" : void 0,
+      error: input.passed ? void 0 : new Error(stripAnsi(message ?? `${command} failed`)),
+      callSource: input.callSource,
+      timestamp: Date.now()
+    },
+    testUid
+  );
+  if (input.title) {
+    entry.title = input.title;
+  }
+  return entry;
+}
+function patchAssertNamespace(nsObj, onCommand) {
+  let count = 0;
+  for (const methodName of TRACKED_ASSERT_METHODS) {
+    const original = nsObj[methodName];
+    if (typeof original !== "function") {
+      continue;
+    }
+    nsObj[methodName] = makePatchedAssertMethod(
+      methodName,
+      nsObj,
+      original,
+      onCommand
+    );
+    count++;
+  }
+  return count;
+}
+function patchNodeAssert(onCommand, onLog) {
+  const log14 = (level, message) => onLog?.(level, message);
+  let assertModule;
+  try {
+    assertModule = require3("node:assert");
+  } catch {
+    log14("warn", "node:assert not available \u2014 skipping assertion capture");
+    return false;
+  }
+  const assertObj = assertModule;
+  if (assertObj[ASSERT_PATCHED_SYMBOL]) {
+    return true;
+  }
+  assertObj[ASSERT_PATCHED_SYMBOL] = true;
+  let patched = patchAssertNamespace(assertObj, onCommand);
+  const strict = assertObj.strict;
+  if (strict && (typeof strict === "object" || typeof strict === "function")) {
+    patched += patchAssertNamespace(
+      strict,
+      onCommand
+    );
+  }
+  log14("info", `Patched ${patched} node:assert method(s)`);
+  return true;
+}
+
+// ../core/src/sha1.ts
+import { createHash } from "crypto";
+function sha1Hex(data) {
+  return createHash("sha1").update(data).digest("hex");
+}
+
+// ../core/src/trace-sources.ts
+var MAX_SOURCE_BYTES = 2 * 1024 * 1024;
+function sourceResourceName(filePath) {
+  return `src@${sha1Hex(filePath)}.txt`;
+}
+function splitNumericSuffix(value) {
+  const sep = value.lastIndexOf(":");
+  if (sep <= 0) {
+    return { rest: value };
+  }
+  const digits = value.slice(sep + 1);
+  if (!/^\d+$/.test(digits)) {
+    return { rest: value };
+  }
+  return { rest: value.slice(0, sep), num: Number(digits) };
+}
+function callSourceToStack(callSource) {
+  if (!callSource || callSource === "unknown:0") {
+    return void 0;
+  }
+  const last = splitNumericSuffix(callSource);
+  if (last.num === void 0) {
+    return [{ file: callSource, line: 0, column: 0 }];
+  }
+  const prev = splitNumericSuffix(last.rest);
+  if (prev.num === void 0) {
+    return [{ file: last.rest, line: last.num, column: 0 }];
+  }
+  return [{ file: prev.rest, line: prev.num, column: last.num }];
+}
+function buildSourceResources(sources) {
+  const out = [];
+  for (const [filePath, text] of Object.entries(sources)) {
+    const data = Buffer.from(text, "utf8");
+    if (data.byteLength > MAX_SOURCE_BYTES) {
+      continue;
+    }
+    out.push({ resourceName: sourceResourceName(filePath), data });
+  }
+  return out;
+}
+
+// ../core/src/trace-hierarchy.ts
+function buildGroupPath(cmd, testMetadata) {
+  const path14 = [];
+  if (cmd.testUid) {
+    const entry = testMetadata?.get(cmd.testUid);
+    for (const ancestor of entry?.ancestry ?? []) {
+      path14.push({ uid: ancestor.uid, title: ancestor.title });
+    }
+    path14.push({ uid: cmd.testUid, title: entry?.title ?? cmd.testUid });
+  }
+  if (cmd.stepUid) {
+    const stepEntry = testMetadata?.get(cmd.stepUid);
+    path14.push({ uid: cmd.stepUid, title: stepEntry?.title ?? cmd.stepUid });
+  }
+  return path14;
+}
+
+// ../core/src/trace-action-events.ts
+var MAX_RESULT_BYTES = 64 * 1024;
+function serializableResult(result) {
+  if (result === void 0) {
+    return void 0;
+  }
+  try {
+    const json = JSON.stringify(result);
+    if (json === void 0 || json.length > MAX_RESULT_BYTES) {
+      return void 0;
+    }
+    return JSON.parse(json);
+  } catch {
+    return void 0;
+  }
+}
+function collapsedAssertResult(result) {
+  if (typeof result === "object" && result !== null && "passed" in result) {
+    return result;
+  }
+  return void 0;
+}
+function buildAssertParams(cmd) {
+  const params = Object.fromEntries(
+    cmd.args.map((arg, index) => [String(index), arg])
+  );
+  const [actual, expected, message] = cmd.args;
+  const collapsed = collapsedAssertResult(cmd.result);
+  const semantic = {
+    actual: collapsed?.actual ?? actual,
+    expected: collapsed?.expected ?? expected,
+    message: collapsed?.message ?? message
+  };
+  for (const [key, value] of Object.entries(semantic)) {
+    if (value !== void 0) {
+      params[key] = value;
+    }
+  }
+  return params;
+}
+function buildActionParams(action, rawArgs) {
+  const isValueMethod = FILL_METHODS.has(action.method);
+  if (action.class === "Element" && isValueMethod && rawArgs.length >= 2) {
+    return { selector: rawArgs[0], value: rawArgs[1] };
+  }
+  if (action.class === "Element" && isValueMethod && rawArgs.length === 1) {
+    return { value: rawArgs[0] };
+  }
+  if (action.class === "Element" && rawArgs.length === 1 && typeof rawArgs[0] === "string") {
+    return { selector: rawArgs[0] };
+  }
+  if (rawArgs.length === 1 && typeof rawArgs[0] === "string") {
+    return { url: rawArgs[0] };
+  }
+  return Object.fromEntries(rawArgs.map((a, i) => [String(i), a]));
+}
+function closeGroupsFrom(stream, from) {
+  for (let i = stream.openGroups.length - 1; i >= from; i--) {
+    stream.events.push({
+      type: "after",
+      callId: stream.openGroups[i].callId,
+      endTime: stream.prevEndMs
+    });
+  }
+  stream.openGroups.length = Math.max(0, from);
+}
+function syncGroups(stream, cmd, pageId, wallTime, testMetadata) {
+  const desired = buildGroupPath(cmd, testMetadata);
+  let common = 0;
+  while (common < stream.openGroups.length && common < desired.length && stream.openGroups[common].uid === desired[common].uid) {
+    common++;
+  }
+  closeGroupsFrom(stream, common);
+  for (let i = common; i < desired.length; i++) {
+    stream.callCounter++;
+    const callId = `call@${stream.callCounter}`;
+    const parentId = stream.openGroups[i - 1]?.callId;
+    const groupBefore = {
+      type: "before",
+      callId,
+      startTime: Math.max(
+        stream.prevEndMs,
+        (cmd.startTime ?? cmd.timestamp) - wallTime
+      ),
+      class: "Tracing",
+      method: "tracingGroup",
+      pageId,
+      params: { name: desired[i].title },
+      title: desired[i].title,
+      apiName: "tracing.tracingGroup"
+    };
+    if (parentId) {
+      groupBefore.parentId = parentId;
+    }
+    stream.events.push(groupBefore);
+    stream.openGroups.push({ uid: desired[i].uid, callId });
+  }
+}
+function buildParamsAndTitle(action, cmd) {
+  const isAssert = action.class === ASSERT_ACTION_CLASS;
+  const params = isAssert ? buildAssertParams(cmd) : buildActionParams(action, cmd.args);
+  if (cmd.selector && params.locator === void 0) {
+    params.locator = cmd.selector;
+  }
+  return {
+    params,
+    title: formatActionTitle(
+      action,
+      cmd.args,
+      params,
+      isAssert ? cmd.command : void 0
+    )
+  };
+}
+function actionError(cmd, isAssert) {
+  if (cmd.error) {
+    const err = cmd.error;
+    return { message: err.message ?? String(cmd.error) };
+  }
+  if (isAssert) {
+    const collapsed = collapsedAssertResult(cmd.result);
+    if (collapsed && collapsed.passed === false) {
+      return { message: String(collapsed.message ?? "Assertion failed") };
+    }
+  }
+  return void 0;
+}
+function resolveActionPoint(action, cmd, snapshotIndex) {
+  if (action.class !== "Element" || !POINTABLE_METHODS.has(action.method)) {
+    return void 0;
+  }
+  const selector = cmd.args?.[0];
+  if (typeof selector !== "string") {
+    return void 0;
+  }
+  const elements = snapshotIndex?.elementsAt(cmd.timestamp);
+  for (const el of elements ?? []) {
+    const e = el;
+    if (e.selector === selector && e.boundingBox) {
+      const bb = e.boundingBox;
+      return { x: bb.x + bb.width / 2, y: bb.y + bb.height / 2 };
+    }
+  }
+  return void 0;
+}
+function buildAfterEvent(cmd, action, callId, endMs, snapshotIndex) {
+  const afterEvent = { type: "after", callId, endTime: endMs };
+  const error = actionError(cmd, action.class === ASSERT_ACTION_CLASS);
+  if (error) {
+    afterEvent.error = error;
+  }
+  const result = serializableResult(cmd.result);
+  if (result !== void 0) {
+    afterEvent.result = result;
+  }
+  const afterName = snapshotIndex?.claimAfter(cmd.timestamp, callId);
+  if (afterName) {
+    afterEvent.afterSnapshot = afterName;
+  }
+  const point = resolveActionPoint(action, cmd, snapshotIndex);
+  if (point) {
+    afterEvent.point = point;
+  }
+  return afterEvent;
+}
+function pushActionPair(stream, cmd, action, pageId, wallTime, snapshotIndex) {
+  stream.callCounter++;
+  const callId = `call@${stream.callCounter}`;
+  const rawStartMs = (cmd.startTime ?? cmd.timestamp) - wallTime;
+  const rawEndMs = cmd.timestamp - wallTime;
+  const startMs = Math.max(stream.prevEndMs, rawStartMs);
+  const endMs = Math.max(startMs + 1, rawEndMs);
+  const { params, title } = buildParamsAndTitle(action, cmd);
+  const beforeEvent = {
+    type: "before",
+    callId,
+    startTime: startMs,
+    class: action.class,
+    method: action.method,
+    pageId,
+    params,
+    title,
+    apiName: `${action.class.toLowerCase()}.${action.method}`,
+    parentId: stream.openGroups[stream.openGroups.length - 1]?.callId
+  };
+  const stack = callSourceToStack(cmd.callSource);
+  if (stack) {
+    beforeEvent.stack = stack;
+  }
+  const beforeName = snapshotIndex?.beforeName();
+  if (beforeName) {
+    beforeEvent.beforeSnapshot = beforeName;
+  }
+  stream.events.push(beforeEvent);
+  stream.events.push(buildAfterEvent(cmd, action, callId, endMs, snapshotIndex));
+  stream.prevEndMs = endMs;
+}
+function buildActionEvents(commands, pageId, wallTime, testMetadata, snapshotIndex) {
+  const stream = {
+    events: [],
+    prevEndMs: 0,
+    callCounter: 0,
+    openGroups: []
+  };
+  const ordered = [...commands].sort(
+    (a, b) => (a.startTime ?? a.timestamp) - (b.startTime ?? b.timestamp)
+  );
+  for (const cmd of ordered) {
+    const action = mapCommandToAction(cmd.command);
+    if (!action) {
+      continue;
+    }
+    syncGroups(stream, cmd, pageId, wallTime, testMetadata);
+    pushActionPair(stream, cmd, action, pageId, wallTime, snapshotIndex);
+  }
+  closeGroupsFrom(stream, 0);
+  return stream.events;
+}
+
+// ../core/src/trace-console.ts
+var MAX_CONSOLE_EVENTS = 1e4;
+function toTraceLevel(level) {
+  if (level === "warn") {
+    return "warning";
+  }
+  if (level === "trace") {
+    return "debug";
+  }
+  return level;
+}
+function previewArg(arg) {
+  if (typeof arg === "string") {
+    return arg;
+  }
+  try {
+    return JSON.stringify(arg) ?? String(arg);
+  } catch {
+    return String(arg);
+  }
+}
+function buildConsoleEvents(logs, pageId, wallTime) {
+  const capped = logs.slice(0, MAX_CONSOLE_EVENTS);
+  const events = capped.map((log14) => {
+    const time = Math.max(0, log14.timestamp - wallTime);
+    const text = log14.args.map(previewArg).join(" ");
+    if (log14.source === "browser" || log14.source === void 0) {
+      return {
+        type: "console",
+        time,
+        pageId,
+        messageType: toTraceLevel(log14.type),
+        text,
+        args: log14.args.map((arg) => ({ preview: previewArg(arg), value: arg })),
+        // Location isn't captured at the patch site; the required field ships zeroed.
+        location: { url: "", lineNumber: 0, columnNumber: 0 }
+      };
+    }
+    return {
+      type: log14.type === "error" || log14.type === "warn" ? "stderr" : "stdout",
+      timestamp: time,
+      text,
+      source: log14.source
+    };
+  });
+  if (logs.length > MAX_CONSOLE_EVENTS) {
+    const last = capped[capped.length - 1];
+    events.push({
+      type: "stderr",
+      timestamp: last ? Math.max(0, last.timestamp - wallTime) : 0,
+      text: `[devtools] console truncated: dropped ${logs.length - MAX_CONSOLE_EVENTS} entries`
+    });
+  }
+  return events;
+}
+
+// ../core/src/trace-exporter.ts
+import fs6 from "fs/promises";
+import path5 from "path";
+
+// ../core/src/trace-snapshots.ts
+function collapseByTimestamp(snapshots) {
+  const byTs = /* @__PURE__ */ new Map();
+  const order = [];
+  for (const snap of snapshots) {
+    const existing = byTs.get(snap.timestamp);
+    if (!existing) {
+      byTs.set(snap.timestamp, { ...snap });
+      order.push(snap.timestamp);
+      continue;
+    }
+    if ((snap.screenshot?.length ?? 0) > (existing.screenshot?.length ?? 0)) {
+      existing.screenshot = snap.screenshot;
+    }
+    if (!existing.elements?.length && snap.elements?.length) {
+      existing.elements = snap.elements;
+    }
+    if (!existing.snapshotText && snap.snapshotText) {
+      existing.snapshotText = snap.snapshotText;
+    }
+  }
+  return order.map((ts) => byTs.get(ts));
+}
+function buildSnapshotResources(rawSnapshots, pageId) {
+  const snapshots = collapseByTimestamp(rawSnapshots);
+  const out = [];
+  for (const snap of snapshots) {
+    const base = `${pageId}-${snap.timestamp}`;
+    if (snap.screenshot) {
+      out.push({
+        resourceName: `${base}.jpeg`,
+        data: Buffer.from(snap.screenshot, "base64")
+      });
+    }
+    if (snap.elements && snap.elements.length) {
+      out.push({
+        resourceName: `${base}-elements.json`,
+        data: Buffer.from(JSON.stringify(snap.elements), "utf8")
+      });
+    }
+    if (snap.snapshotText) {
+      out.push({
+        resourceName: `${base}-snapshot.txt`,
+        data: Buffer.from(snap.snapshotText, "utf8")
+      });
+    }
+  }
+  return out;
+}
+function frameForSnapshot(snap, pageId, timestamp, viewport) {
+  const base = `${pageId}-${snap.timestamp}`;
+  const frame = {
+    type: "screencast-frame",
+    pageId,
+    sha1: `${base}.jpeg`,
+    width: viewport.width,
+    height: viewport.height,
+    timestamp
+  };
+  if (snap.elements && snap.elements.length) {
+    frame.elements = `${base}-elements.json`;
+  }
+  if (snap.snapshotText) {
+    frame.snapshot = `${base}-snapshot.txt`;
+  }
+  return frame;
+}
+function buildFilmstripEvents(rawSnapshots, pageId, wallTime, viewport) {
+  const snapshots = collapseByTimestamp(rawSnapshots);
+  const firstSnap = snapshots.find((s) => s.screenshot);
+  const events = [];
+  if (firstSnap) {
+    events.push(frameForSnapshot(firstSnap, pageId, 0, viewport));
+  }
+  for (const snap of snapshots) {
+    if (snap === firstSnap || !snap.screenshot) {
+      continue;
+    }
+    events.push(
+      frameForSnapshot(
+        snap,
+        pageId,
+        Math.max(0, snap.timestamp - wallTime),
+        viewport
+      )
+    );
+  }
+  return events;
+}
+
+// ../core/src/screencast-trace.ts
+import { createHash as createHash2 } from "crypto";
+var DEFAULT_MAX_FRAMES = 600;
+var DEFAULT_MIN_INTERVAL_MS = 100;
+function thinScreencastFrames(frames, options = {}) {
+  const minInterval = options.minFrameIntervalMs ?? DEFAULT_MIN_INTERVAL_MS;
+  const maxFrames = options.maxFrames ?? DEFAULT_MAX_FRAMES;
+  const kept = [];
+  let lastKeptTs = -Infinity;
+  let lastData;
+  for (const frame of frames) {
+    if (frame.timestamp - lastKeptTs < minInterval) {
+      continue;
+    }
+    if (frame.data === lastData) {
+      continue;
+    }
+    kept.push(frame);
+    lastKeptTs = frame.timestamp;
+    lastData = frame.data;
+  }
+  if (kept.length <= maxFrames) {
+    return kept;
+  }
+  if (maxFrames <= 1) {
+    return kept.length ? [kept[0]] : [];
+  }
+  const out = [];
+  const step = (kept.length - 1) / (maxFrames - 1);
+  for (let i = 0; i < maxFrames; i++) {
+    out.push(kept[Math.round(i * step)]);
+  }
+  return out;
+}
+function buildDenseScreencast(frames, pageId, wallTime, viewport, options = {}) {
+  const events = [];
+  const resources = [];
+  const seen = /* @__PURE__ */ new Set();
+  for (const frame of thinScreencastFrames(frames, options)) {
+    const data = Buffer.from(frame.data, "base64");
+    const sha1 = createHash2("sha1").update(data).digest("hex");
+    const resourceName = `${sha1}.jpeg`;
+    if (!seen.has(sha1)) {
+      seen.add(sha1);
+      resources.push({ resourceName, data });
+    }
+    events.push({
+      type: "screencast-frame",
+      pageId,
+      sha1: resourceName,
+      width: viewport.width,
+      height: viewport.height,
+      timestamp: Math.max(0, frame.timestamp - wallTime)
+    });
+  }
+  return { events, resources };
+}
+
+// ../core/src/trace-frame-snapshots.ts
+var SNAPSHOT_DOCTYPE = "html";
+var FALLBACK_FRAME_URL = "about:blank";
+var BODY_STYLE = "margin:0";
+var IMAGE_STYLE = "display:block;width:100vw;height:100vh;object-fit:contain";
+var FrameSnapshotIndex = class {
+  #byTimestamp = /* @__PURE__ */ new Map();
+  // Element rects by timestamp, indexed independently of the screenshot gate so
+  // A8 input points resolve even when the frame carries no screenshot.
+  #elementsByTimestamp = /* @__PURE__ */ new Map();
+  #refs = [];
+  #lastName;
+  constructor(snapshots) {
+    for (const snap of snapshots) {
+      if (snap.elements) {
+        const currentEls = this.#elementsByTimestamp.get(snap.timestamp);
+        if (!currentEls || snap.elements.length > currentEls.length) {
+          this.#elementsByTimestamp.set(snap.timestamp, snap.elements);
+        }
+      }
+      if (!snap.screenshot) {
+        continue;
+      }
+      const current = this.#byTimestamp.get(snap.timestamp);
+      if (!current || snap.screenshot.length > (current.screenshot?.length ?? 0)) {
+        this.#byTimestamp.set(snap.timestamp, snap);
+      }
+    }
+  }
+  /** Captured element rects at a command's completion timestamp, if any. */
+  elementsAt(timestamp) {
+    return this.#elementsByTimestamp.get(timestamp);
+  }
+  /** Snapshot name representing the page state before the next action. */
+  beforeName() {
+    return this.#lastName;
+  }
+  /** Claims the screenshot captured at the command's completion, if any. */
+  claimAfter(timestamp, callId) {
+    const snap = this.#byTimestamp.get(timestamp);
+    if (!snap) {
+      return void 0;
+    }
+    this.#byTimestamp.delete(timestamp);
+    const snapshotName = `after@${callId}`;
+    this.#refs.push({ callId, snapshotName, snapshot: snap });
+    this.#lastName = snapshotName;
+    return snapshotName;
+  }
+  refs() {
+    return this.#refs;
+  }
+};
+function frameIdForPage(pageId) {
+  const suffix = pageId.startsWith("page@") ? pageId.slice("page@".length) : pageId;
+  return `frame@${suffix}`;
+}
+function imageMimeType(base64) {
+  return base64.startsWith("iVBOR") ? "image/png" : "image/jpeg";
+}
+function imageDocument(snap) {
+  const screenshot = snap.screenshot ?? "";
+  return [
+    "HTML",
+    {},
+    ["HEAD", {}, ["BASE", { href: snap.url ?? FALLBACK_FRAME_URL }]],
+    [
+      "BODY",
+      { style: BODY_STYLE },
+      [
+        "IMG",
+        {
+          src: `data:${imageMimeType(screenshot)};base64,${screenshot}`,
+          style: IMAGE_STYLE
+        }
+      ]
+    ]
+  ];
+}
+function buildImageFrameSnapshots(refs, pageId, wallTime, viewport) {
+  const frameId = frameIdForPage(pageId);
+  return refs.map((ref) => ({
+    type: "frame-snapshot",
+    snapshot: {
+      callId: ref.callId,
+      snapshotName: ref.snapshotName,
+      pageId,
+      frameId,
+      frameUrl: ref.snapshot.url ?? FALLBACK_FRAME_URL,
+      doctype: SNAPSHOT_DOCTYPE,
+      html: imageDocument(ref.snapshot),
+      viewport: { width: viewport.width, height: viewport.height },
+      timestamp: Math.max(0, ref.snapshot.timestamp - wallTime),
+      wallTime: ref.snapshot.timestamp,
+      collectionTime: 0,
+      resourceOverrides: [],
+      isMainFrame: true
+    }
+  }));
+}
+
+// ../core/src/trace-har.ts
+var INLINE_BODY_TEXT_MAX_BYTES = 8 * 1024;
+function toHeaderArray(h) {
+  if (!h) {
+    return [];
+  }
+  return Object.entries(h).map(([name, value]) => ({ name, value }));
+}
+function toQueryString(url) {
+  try {
+    const u = new URL(url);
+    const out = [];
+    u.searchParams.forEach((value, name) => out.push({ name, value }));
+    return out;
+  } catch {
+    return [];
+  }
+}
+function toHarContent(entry, mimeType, bodySha1) {
+  const content = { size: entry.size ?? 0, mimeType };
+  const body = entry.responseBody;
+  if (body === void 0) {
+    return content;
+  }
+  if (Buffer.byteLength(body, "utf8") < INLINE_BODY_TEXT_MAX_BYTES) {
+    content.text = body;
+  }
+  if (bodySha1) {
+    content._sha1 = bodySha1;
+  }
+  return content;
+}
+function networkRequestToHar(entry, opts = {}) {
+  const startedDateTime = new Date(entry.timestamp).toISOString();
+  const duration = entry.time ?? (entry.endTime ?? entry.startTime) - entry.startTime;
+  const status = entry.response?.status ?? entry.status ?? 0;
   const mimeType = entry.response?.mimeType ?? "";
   const responseHeaders = entry.response?.headers ?? entry.responseHeaders;
   return {
@@ -2125,7 +3481,7 @@ function networkRequestToHar(entry) {
         httpVersion: "HTTP/1.1",
         cookies: [],
         headers: toHeaderArray(responseHeaders),
-        content: { size: entry.size ?? 0, mimeType },
+        content: toHarContent(entry, mimeType, opts.bodySha1),
         redirectURL: "",
         headersSize: -1,
         bodySize: entry.size ?? -1
@@ -2153,6 +3509,9 @@ function buildTraceZip(inputs) {
         "transcript.md"
       );
     }
+    if (inputs.mutationsNdjson?.length) {
+      zipFile.addBuffer(inputs.mutationsNdjson, "trace.mutations");
+    }
     for (const resource of inputs.resources) {
       zipFile.addBuffer(resource.data, `resources/${resource.resourceName}`);
     }
@@ -2164,13 +3523,80 @@ function buildTraceZip(inputs) {
   });
 }
 
+// ../core/src/trace-mutations.ts
+var MAX_MUTATIONS_NDJSON_BYTES = 50 * 1024 * 1024;
+function buildMutationsNdjson(mutations, cap = MAX_MUTATIONS_NDJSON_BYTES) {
+  if (!mutations.length) {
+    return { ndjson: Buffer.alloc(0), truncated: false, written: 0 };
+  }
+  const lines = [];
+  let bytes = 0;
+  for (const mutation of mutations) {
+    const line = JSON.stringify(mutation);
+    const add = Buffer.byteLength(line, "utf8") + (lines.length ? 1 : 0);
+    if (lines.length > 0 && bytes + add > cap) {
+      break;
+    }
+    lines.push(line);
+    bytes += add;
+  }
+  const written = lines.length;
+  const dropped = mutations.length - written;
+  if (dropped > 0) {
+    const marker = { __truncated__: true, dropped };
+    lines.push(JSON.stringify(marker));
+  }
+  return {
+    ndjson: Buffer.from(lines.join("\n"), "utf8"),
+    truncated: dropped > 0,
+    written
+  };
+}
+
 // ../core/src/trace-exporter.ts
 var TRACE_VERSION = 8;
 var LIBRARY_NAME = "@wdio/devtools-core";
 var LIBRARY_VERSION = "1.0.0";
+var MAX_BODY_RESOURCE_BYTES = 1024 * 1024;
+var MAX_TOTAL_BODY_RESOURCE_BYTES = 20 * 1024 * 1024;
+function buildNetworkBodyResources(requests, caps = {
+  maxBodyBytes: MAX_BODY_RESOURCE_BYTES,
+  maxTotalBytes: MAX_TOTAL_BODY_RESOURCE_BYTES
+}) {
+  const resources = [];
+  const sha1ByRequestId = /* @__PURE__ */ new Map();
+  const stored = /* @__PURE__ */ new Set();
+  let totalBytes = 0;
+  for (const request of requests) {
+    if (request.responseBody === void 0) {
+      continue;
+    }
+    const data = Buffer.from(request.responseBody, "utf8");
+    if (data.byteLength > caps.maxBodyBytes) {
+      continue;
+    }
+    const sha1 = sha1Hex(data);
+    if (stored.has(sha1)) {
+      sha1ByRequestId.set(request.id, sha1);
+      continue;
+    }
+    if (totalBytes + data.byteLength > caps.maxTotalBytes) {
+      continue;
+    }
+    stored.add(sha1);
+    totalBytes += data.byteLength;
+    resources.push({ resourceName: sha1, data });
+    sha1ByRequestId.set(request.id, sha1);
+  }
+  return { resources, sha1ByRequestId };
+}
 function shortId(sessionId) {
   return (sessionId ?? Math.random().toString(36).slice(2, 10)).slice(0, 8);
 }
+function allocateTraceIds(sessionId) {
+  const idPrefix = shortId(sessionId);
+  return { contextId: `context@${idPrefix}`, pageId: `page@${idPrefix}` };
+}
 function resolveContextNaming(caps) {
   const platformName = typeof caps?.platformName === "string" ? caps.platformName.toLowerCase() : void 0;
   const deviceName = typeof caps?.["appium:deviceName"] === "string" ? caps["appium:deviceName"] : void 0;
@@ -2205,106 +3631,14 @@ function buildContextOptions(trace, contextId, wallTime) {
     }
   };
 }
-function buildActionEvents(commands, pageId, wallTime, testMetadata) {
-  const events = [];
-  let prevEndMs = 0;
-  let callCounter = 0;
-  let lastTestUid;
-  let groupCallId;
-  for (const cmd of commands) {
-    const action = mapCommandToAction(cmd.command);
-    if (!action) {
-      continue;
-    }
-    if (cmd.testUid && cmd.testUid !== lastTestUid) {
-      if (lastTestUid && groupCallId) {
-        callCounter++;
-        events.push({
-          type: "after",
-          callId: groupCallId,
-          endTime: prevEndMs
-        });
-      }
-      callCounter++;
-      groupCallId = `call@${callCounter}`;
-      const meta = testMetadata?.get(cmd.testUid);
-      const groupName = meta?.title ?? cmd.testUid;
-      events.push({
-        type: "before",
-        callId: groupCallId,
-        startTime: Math.max(
-          prevEndMs,
-          (cmd.startTime ?? cmd.timestamp) - wallTime
-        ),
-        class: "Tracing",
-        method: "tracingGroup",
-        pageId,
-        params: { name: groupName },
-        title: groupName,
-        apiName: "tracing.tracingGroup"
-      });
-      lastTestUid = cmd.testUid;
-    }
-    callCounter++;
-    const callId = `call@${callCounter}`;
-    const rawStartMs = (cmd.startTime ?? cmd.timestamp) - wallTime;
-    const rawEndMs = cmd.timestamp - wallTime;
-    const startMs = Math.max(prevEndMs, rawStartMs);
-    const endMs = Math.max(startMs + 1, rawEndMs);
-    const rawArgs = cmd.args;
-    let params;
-    const isValueMethod = FILL_METHODS.has(action.method);
-    if (action.class === "Element" && isValueMethod && rawArgs.length >= 2) {
-      params = { selector: rawArgs[0], value: rawArgs[1] };
-    } else if (action.class === "Element" && isValueMethod && rawArgs.length === 1) {
-      params = { value: rawArgs[0] };
-    } else if (action.class === "Element" && rawArgs.length === 1 && typeof rawArgs[0] === "string") {
-      params = { selector: rawArgs[0] };
-    } else if (rawArgs.length === 1 && typeof rawArgs[0] === "string") {
-      params = { url: rawArgs[0] };
-    } else {
-      params = Object.fromEntries(rawArgs.map((a, i) => [String(i), a]));
-    }
-    events.push({
-      type: "before",
-      callId,
-      startTime: startMs,
-      class: action.class,
-      method: action.method,
-      pageId,
-      params,
-      title: formatActionTitle(action, cmd.args, params),
-      apiName: `${action.class.toLowerCase()}.${action.method}`,
-      parentId: groupCallId
-    });
-    const afterEvent = {
-      type: "after",
-      callId,
-      endTime: endMs
-    };
-    if (cmd.error) {
-      const err = cmd.error;
-      afterEvent.error = { message: err.message ?? String(cmd.error) };
-    }
-    events.push(afterEvent);
-    prevEndMs = endMs;
-  }
-  if (lastTestUid && groupCallId) {
-    callCounter++;
-    events.push({
-      type: "after",
-      callId: groupCallId,
-      endTime: prevEndMs
-    });
-  }
-  return events;
-}
-function buildNetworkNdjson(requests, wallTime, pageId) {
+function buildNetworkNdjson(requests, wallTime, pageId, sha1ByRequestId) {
   if (!requests.length) {
     return Buffer.alloc(0);
   }
   const lines = requests.map((r) => {
-    const entry = networkRequestToHar(r);
+    const entry = networkRequestToHar(r, {
+      bodySha1: sha1ByRequestId.get(r.id)
+    });
     entry.snapshot = {
       ...entry.snapshot,
       // Monotonic offset so the viewer positions bars on the timeline.
@@ -2316,51 +3650,6 @@ function buildNetworkNdjson(requests, wallTime, pageId) {
   });
   return Buffer.from(lines.join("\n"), "utf8");
 }
-function buildSnapshotResources(snapshots, pageId) {
-  const out = [];
-  for (const snap of snapshots) {
-    const base = `${pageId}-${snap.timestamp}`;
-    if (snap.screenshot) {
-      out.push({
-        resourceName: `${base}.jpeg`,
-        data: Buffer.from(snap.screenshot, "base64")
-      });
-    }
-    if (snap.elements && snap.elements.length) {
-      out.push({
-        resourceName: `${base}-elements.json`,
-        data: Buffer.from(JSON.stringify(snap.elements), "utf8")
-      });
-    }
-    if (snap.snapshotText) {
-      out.push({
-        resourceName: `${base}-snapshot.txt`,
-        data: Buffer.from(snap.snapshotText, "utf8")
-      });
-    }
-  }
-  return out;
-}
-function buildScreencastFrames(snapshots, pageId, wallTime, viewport) {
-  return snapshots.filter((s) => s.screenshot).map((s) => {
-    const base = `${pageId}-${s.timestamp}`;
-    const frame = {
-      type: "screencast-frame",
-      pageId,
-      sha1: `${base}.jpeg`,
-      width: viewport.width,
-      height: viewport.height,
-      timestamp: Math.max(0, s.timestamp - wallTime)
-    };
-    if (s.elements && s.elements.length) {
-      frame.elements = `${base}-elements.json`;
-    }
-    if (s.snapshotText) {
-      frame.snapshot = `${base}-snapshot.txt`;
-    }
-    return frame;
-  });
-}
 function eventTime(e) {
   switch (e.type) {
     case "context-options":
@@ -2371,6 +3660,13 @@ function eventTime(e) {
       return e.endTime;
     case "screencast-frame":
       return e.timestamp;
+    case "frame-snapshot":
+      return e.snapshot.timestamp;
+    case "console":
+      return e.time;
+    case "stdout":
+    case "stderr":
+      return e.timestamp;
   }
 }
 function eventOrder(e) {
@@ -2380,9 +3676,14 @@ function eventOrder(e) {
     case "after":
       return 1;
     case "screencast-frame":
+    case "frame-snapshot":
       return 2;
-    case "before":
+    case "console":
+    case "stdout":
+    case "stderr":
       return 3;
+    case "before":
+      return 4;
   }
 }
 function compareEvents(a, b) {
@@ -2392,8 +3693,11 @@ function compareEvents(a, b) {
 function generateTranscript(commands, startWallTime, title) {
   const wallTimeISO = new Date(startWallTime).toISOString();
   const lines = [`# ${title ?? "Session"} \u2014 ${wallTimeISO}`, ""];
+  const ordered = [...commands].sort(
+    (a, b) => (a.startTime ?? a.timestamp) - (b.startTime ?? b.timestamp)
+  );
   const captured = [];
-  for (const c of commands) {
+  for (const c of ordered) {
     const action = mapCommandToAction(String(c.command));
     if (action) {
       captured.push({ entry: c, action });
@@ -2417,51 +3721,72 @@ function generateTranscript(commands, startWallTime, title) {
   });
   return lines.join("\n");
 }
-function buildTraceBundle(trace, opts = {}) {
-  const firstCommandTs = trace.commands[0]?.timestamp;
-  const wallTime = opts.wallTimeOverride ?? firstCommandTs ?? Date.now();
-  const idPrefix = shortId(opts.sessionId);
-  const contextId = `context@${idPrefix}`;
-  const pageId = `page@${idPrefix}`;
+function buildEventStream(trace, ctxOptions, pageId, wallTime, testMetadata, denseFrameEvents = []) {
   const viewport = trace.metadata.viewport ?? { width: 1280, height: 720 };
   const snapshots = trace.actionSnapshots ?? [];
-  const ctxOptions = buildContextOptions(trace, contextId, wallTime);
-  const events = [ctxOptions];
-  const firstSnap = snapshots.find((s) => s.screenshot);
-  if (firstSnap) {
-    const base = `${pageId}-${firstSnap.timestamp}`;
-    const initFrame = {
-      type: "screencast-frame",
+  const snapshotIndex = new FrameSnapshotIndex(snapshots);
+  const filmstrip = denseFrameEvents.length > 0 ? denseFrameEvents : buildFilmstripEvents(snapshots, pageId, wallTime, viewport);
+  const events = [
+    ctxOptions,
+    ...filmstrip,
+    ...buildActionEvents(
+      trace.commands,
       pageId,
-      sha1: `${base}.jpeg`,
-      width: viewport.width,
-      height: viewport.height,
-      timestamp: 0
-    };
-    if (firstSnap.elements && firstSnap.elements.length) {
-      initFrame.elements = `${base}-elements.json`;
-    }
-    if (firstSnap.snapshotText) {
-      initFrame.snapshot = `${base}-snapshot.txt`;
-    }
-    events.push(initFrame);
-  }
-  events.push(
-    ...buildScreencastFrames(
-      firstSnap ? snapshots.filter((s) => s !== firstSnap) : snapshots,
+      wallTime,
+      testMetadata,
+      snapshotIndex
+    ),
+    ...buildImageFrameSnapshots(
+      snapshotIndex.refs(),
       pageId,
       wallTime,
       viewport
     ),
-    ...buildActionEvents(trace.commands, pageId, wallTime, opts.testMetadata)
-  );
+    ...buildConsoleEvents(trace.consoleLogs, pageId, wallTime)
+  ];
   events.sort(compareEvents);
-  const ctxBName = ctxOptions.title;
+  return events;
+}
+function buildTraceBundle(trace, opts = {}) {
+  const firstCommandTs = trace.commands[0]?.timestamp;
+  const wallTime = opts.wallTimeOverride ?? firstCommandTs ?? Date.now();
+  const { contextId, pageId } = allocateTraceIds(opts.sessionId);
+  const ctxOptions = buildContextOptions(trace, contextId, wallTime);
+  const dense = buildDenseScreencast(
+    trace.screencastFrames ?? [],
+    pageId,
+    wallTime,
+    trace.metadata.viewport ?? { width: 1280, height: 720 }
+  );
+  const events = buildEventStream(
+    trace,
+    ctxOptions,
+    pageId,
+    wallTime,
+    opts.testMetadata,
+    dense.events
+  );
+  const networkBodies = buildNetworkBodyResources(trace.networkRequests);
   return {
     traceNdjson: events.map((e) => JSON.stringify(e)).join("\n") + "\n",
-    networkNdjson: buildNetworkNdjson(trace.networkRequests, wallTime, pageId),
-    transcriptMd: generateTranscript(trace.commands, wallTime, ctxBName),
-    resources: buildSnapshotResources(snapshots, pageId)
+    networkNdjson: buildNetworkNdjson(
+      trace.networkRequests,
+      wallTime,
+      pageId,
+      networkBodies.sha1ByRequestId
+    ),
+    transcriptMd: generateTranscript(
+      trace.commands,
+      wallTime,
+      ctxOptions.title
+    ),
+    mutationsNdjson: buildMutationsNdjson(trace.mutations ?? []).ndjson,
+    resources: [
+      ...buildSnapshotResources(trace.actionSnapshots ?? [], pageId),
+      ...dense.resources,
+      ...buildSourceResources(trace.sources),
+      ...networkBodies.resources
+    ]
   };
 }
 async function exportTraceZip(trace, opts = {}) {
@@ -2470,25 +3795,30 @@ async function exportTraceZip(trace, opts = {}) {
     traceNdjson: bundle.traceNdjson,
     networkNdjson: bundle.networkNdjson,
     resources: bundle.resources,
-    transcriptMd: bundle.transcriptMd
+    transcriptMd: bundle.transcriptMd,
+    mutationsNdjson: bundle.mutationsNdjson
   });
 }
 async function exportTraceDirectory(trace, targetDir, opts = {}) {
   const bundle = buildTraceBundle(trace, opts);
-  await fs.mkdir(path.join(targetDir, "resources"), { recursive: true });
+  await fs6.mkdir(path5.join(targetDir, "resources"), { recursive: true });
   await Promise.all([
-    fs.writeFile(path.join(targetDir, "trace.trace"), bundle.traceNdjson),
-    fs.writeFile(
-      path.join(targetDir, "transcript.md"),
+    fs6.writeFile(path5.join(targetDir, "trace.trace"), bundle.traceNdjson),
+    fs6.writeFile(
+      path5.join(targetDir, "transcript.md"),
       bundle.transcriptMd,
       "utf8"
     ),
-    bundle.networkNdjson.length ? fs.writeFile(
-      path.join(targetDir, "trace.network"),
+    bundle.networkNdjson.length ? fs6.writeFile(
+      path5.join(targetDir, "trace.network"),
       bundle.networkNdjson
     ) : Promise.resolve(),
+    bundle.mutationsNdjson.length ? fs6.writeFile(
+      path5.join(targetDir, "trace.mutations"),
+      bundle.mutationsNdjson
+    ) : Promise.resolve(),
     ...bundle.resources.map(
-      (r) => fs.writeFile(path.join(targetDir, "resources", r.resourceName), r.data)
+      (r) => fs6.writeFile(path5.join(targetDir, "resources", r.resourceName), r.data)
     )
   ]);
 }
@@ -2506,145 +3836,508 @@ async function writeTraceZip(capturer, opts) {
     },
     commands: capturer.commandsLog,
     sources: Object.fromEntries(capturer.sources),
-    ...actionSnapshots.length ? { actionSnapshots } : {}
+    ...actionSnapshots.length ? { actionSnapshots } : {},
+    ...opts.screencastFrames?.length ? { screencastFrames: [...opts.screencastFrames] } : {}
   };
-  await fs.mkdir(opts.outputDir, { recursive: true });
+  await fs6.mkdir(opts.outputDir, { recursive: true });
   const exportOpts = {
     sessionId: opts.sessionId,
     wallTimeOverride: capturer.startWallTime,
     testMetadata: opts.testMetadata
   };
+  const stem = opts.fileStem ?? `trace-${opts.sessionId}`;
   if (opts.format === "ndjson-directory") {
-    const dir = path.join(opts.outputDir, `trace-${opts.sessionId}`);
-    await fs.mkdir(dir, { recursive: true });
+    const dir = path5.join(opts.outputDir, stem);
+    await fs6.mkdir(dir, { recursive: true });
     await exportTraceDirectory(traceLog, dir, exportOpts);
     return dir;
   }
   const zip = await exportTraceZip(traceLog, exportOpts);
-  const zipPath = path.join(opts.outputDir, `trace-${opts.sessionId}.zip`);
-  await fs.writeFile(zipPath, zip);
+  const zipPath = path5.join(opts.outputDir, `${stem}.zip`);
+  await fs6.writeFile(zipPath, zip);
   return zipPath;
 }
-function synthesizeSnapshotsFromCommands(commands) {
-  return commands.filter((c) => c.screenshot && mapCommandToAction(c.command)).map((c) => ({
-    timestamp: c.timestamp,
-    command: c.command,
-    screenshot: c.screenshot
+function synthesizeSnapshotsFromCommands(commands) {
+  return commands.filter((c) => c.screenshot && mapCommandToAction(c.command)).map((c) => ({
+    timestamp: c.timestamp,
+    command: c.command,
+    screenshot: c.screenshot
+  }));
+}
+
+// ../core/src/spec-trace-helpers.ts
+import path6 from "path";
+
+// ../core/src/uid.ts
+function deterministicUid(...parts) {
+  const hash = parts.join("::").split("").reduce((acc, char) => (acc << 5) - acc + char.charCodeAt(0) | 0, 0);
+  return `stable-${Math.abs(hash).toString(36)}`;
+}
+var signatureCounters = /* @__PURE__ */ new Map();
+function generateStableUid(file, name) {
+  const signature = `${file}::${name}`;
+  const count = signatureCounters.get(signature) ?? 0;
+  signatureCounters.set(signature, count + 1);
+  const input = count > 0 ? `${signature}::${count}` : signature;
+  return deterministicUid(input);
+}
+function resetSignatureCounters() {
+  signatureCounters.clear();
+}
+
+// ../core/src/spec-trace-helpers.ts
+function findFlushableRange(ranges, testUid) {
+  if (testUid !== void 0) {
+    for (let i = ranges.length - 1; i >= 0; i--) {
+      if (ranges[i].testUid === testUid) {
+        return ranges[i];
+      }
+    }
+    return void 0;
+  }
+  return ranges[ranges.length - 1];
+}
+function sanitizeSpecName(specFile) {
+  const cleaned = trimChar(
+    specFile.replace(/^.*[/\\]/, "").replace(/\.[^.]+$/, "").replace(/[^a-zA-Z0-9_-]/g, "_"),
+    "_"
+  );
+  return cleaned || "unknown-spec";
+}
+function buildSpecSessionId(specFile, sessionId) {
+  const base = sanitizeSpecName(specFile);
+  const hash = deterministicUid(specFile).split("-").pop().slice(0, 8);
+  return `${base}-${hash}-${sessionId.slice(0, 8)}`;
+}
+function buildTestSliceSessionId(specFile, key, sessionId) {
+  const base = sanitizeSpecName(specFile);
+  const hash = deterministicUid(key).split("-").pop().slice(0, 8);
+  return `${base}-${hash}-${sessionId.slice(0, 8)}`;
+}
+var MAX_SLUG_LENGTH = 60;
+function slugify(text) {
+  const collapsed = trimChar(
+    text.toLowerCase().replace(/[^a-z0-9]+/g, "-"),
+    "-"
+  );
+  return trimChar(collapsed.slice(0, MAX_SLUG_LENGTH), "-");
+}
+function buildTestSliceFolder(specFile, testTitle, browser, key) {
+  const specBase = sanitizeSpecName(path6.basename(specFile));
+  const keyHash = deterministicUid(key).split("-").pop().slice(0, 8);
+  const titleSlug = slugify(testTitle ?? "") || keyHash;
+  const browserSlug = slugify(browser ?? "") || "browser";
+  const retryMatch = key.match(/-retry(\d+)$/);
+  const retrySuffix = retryMatch ? `-retry${retryMatch[1]}` : "";
+  return `${specBase}-${titleSlug}-${browserSlug}-${keyHash}${retrySuffix}`;
+}
+function buildSpecCapturer(capturer, range, nextRange) {
+  const end = nextRange ? {
+    commands: nextRange.commandStartIdx,
+    console: nextRange.consoleStartIdx,
+    network: nextRange.networkStartIdx,
+    mutations: nextRange.mutationStartIdx,
+    traceLogs: nextRange.traceLogStartIdx
+  } : void 0;
+  return {
+    mutations: capturer.mutations.slice(range.mutationStartIdx, end?.mutations),
+    traceLogs: capturer.traceLogs.slice(range.traceLogStartIdx, end?.traceLogs),
+    consoleLogs: capturer.consoleLogs.slice(
+      range.consoleStartIdx,
+      end?.console
+    ),
+    networkRequests: capturer.networkRequests.slice(
+      range.networkStartIdx,
+      end?.network
+    ),
+    commandsLog: capturer.commandsLog.slice(
+      range.commandStartIdx,
+      end?.commands
+    ),
+    sources: new Map(capturer.sources),
+    metadata: capturer.metadata,
+    startWallTime: capturer.startWallTime
+  };
+}
+function filterTestMetadataBySpec(allMetadata, specFile) {
+  const filtered = /* @__PURE__ */ new Map();
+  for (const [uid, meta] of allMetadata) {
+    if (meta.specFile === specFile) {
+      filtered.set(uid, meta);
+    }
+  }
+  return filtered;
+}
+function filterTestMetadataByUid(allMetadata, testUid) {
+  const filtered = /* @__PURE__ */ new Map();
+  const entry = allMetadata.get(testUid);
+  if (entry) {
+    filtered.set(testUid, entry);
+  }
+  return filtered;
+}
+function pushSliceRange(ctx, specFile, key, testUid, suppressSameKey) {
+  const lastRange = ctx.specRanges[ctx.specRanges.length - 1];
+  if (suppressSameKey && lastRange && lastRange.key === key) {
+    return null;
+  }
+  const prevRange = lastRange && !ctx.flushedSpecs.has(lastRange.key) ? lastRange : null;
+  ctx.specRanges.push({
+    specFile,
+    key,
+    testUid,
+    commandStartIdx: ctx.capturer.commandsLog.length,
+    consoleStartIdx: ctx.capturer.consoleLogs.length,
+    networkStartIdx: ctx.capturer.networkRequests.length,
+    mutationStartIdx: ctx.capturer.mutations.length,
+    traceLogStartIdx: ctx.capturer.traceLogs.length
+  });
+  return prevRange;
+}
+function recordSliceBoundary(ctx, granularity, specFile, testUid) {
+  if (granularity === "spec") {
+    return pushSliceRange(ctx, specFile, specFile, void 0, true);
+  }
+  if (granularity === "test" && testUid !== void 0) {
+    const priorAttempts = ctx.specRanges.filter(
+      (r) => r.testUid === testUid
+    ).length;
+    const key = priorAttempts === 0 ? testUid : `${testUid}-retry${priorAttempts}`;
+    return pushSliceRange(ctx, specFile, key, testUid, false);
+  }
+  return null;
+}
+function recordSpecBoundary(ctx, specFile, traceGranularity) {
+  return recordSliceBoundary(ctx, traceGranularity, specFile);
+}
+function sliceByWindow(items, start2, end) {
+  if (start2 === void 0) {
+    return [];
+  }
+  return items.filter(
+    (i) => i.timestamp >= start2 && (end === void 0 || i.timestamp < end)
+  );
+}
+async function writeSliceTrace(input, sliceSessionId, testMetadata, overrides = {}) {
+  const sliceCapturer = buildSpecCapturer(
+    input.capturer,
+    input.range,
+    input.nextRange
+  );
+  const commandStart = (c) => c ? c.startTime ?? c.timestamp : void 0;
+  const fallbackStart = () => {
+    const times = [
+      ...sliceCapturer.consoleLogs.map((c) => c.timestamp),
+      ...sliceCapturer.networkRequests.map((n) => n.timestamp)
+    ];
+    return times.length ? Math.min(...times) : void 0;
+  };
+  const windowStart = commandStart(sliceCapturer.commandsLog[0]) ?? fallbackStart();
+  const windowEnd = input.nextRange ? commandStart(input.capturer.commandsLog[input.nextRange.commandStartIdx]) : void 0;
+  const sliceSnapshots = sliceByWindow(
+    input.actionSnapshots,
+    windowStart,
+    windowEnd
+  );
+  const sliceFrames = input.screencastFrames ? sliceByWindow(input.screencastFrames, windowStart, windowEnd) : void 0;
+  if (windowStart !== void 0) {
+    sliceCapturer.startWallTime = windowStart;
+  }
+  return writeTraceZip(sliceCapturer, {
+    outputDir: overrides.outputDir ?? input.outputDir,
+    sessionId: sliceSessionId,
+    fileStem: overrides.fileStem,
+    capabilities: input.capabilities,
+    actionSnapshots: sliceSnapshots.length > 0 ? sliceSnapshots : void 0,
+    screencastFrames: sliceFrames?.length ? sliceFrames : void 0,
+    format: input.format,
+    testMetadata
+  });
+}
+async function writeSpecTrace(input) {
+  return writeSliceTrace(
+    input,
+    buildSpecSessionId(input.range.specFile, input.sessionId),
+    filterTestMetadataBySpec(input.testMetadata, input.range.specFile)
+  );
+}
+async function writeTestSliceTrace(input) {
+  const testUid = input.range.testUid ?? input.range.key;
+  const title = input.testMetadata.get(testUid)?.title;
+  const browserName = input.capabilities?.browserName;
+  const folder = buildTestSliceFolder(
+    input.range.specFile,
+    title,
+    browserName,
+    input.range.key
+  );
+  return writeSliceTrace(
+    input,
+    buildTestSliceSessionId(
+      input.range.specFile,
+      input.range.key,
+      input.sessionId
+    ),
+    filterTestMetadataByUid(input.testMetadata, testUid),
+    { outputDir: path6.join(input.outputDir, folder), fileStem: "trace" }
+  );
+}
+
+// ../core/src/trace-finalizer.ts
+var SPEC_WITHOUT_BOUNDARIES_WARNING = 'traceGranularity is "spec" but no spec boundaries were detected (the runner may not expose per-test hooks). Falling back to session-level trace.';
+var TEST_WITHOUT_BOUNDARIES_WARNING = 'traceGranularity is "test" but no test boundaries were detected (the runner may not expose per-test hooks). Falling back to session-level trace.';
+var SLICE_COUNT_WARN_THRESHOLD = 200;
+var PENDING_SETTLE_TIMEOUT_MS = 5e3;
+async function settlePending(pending, timeoutMs) {
+  let timer;
+  const timedOut = new Promise((resolve2) => {
+    timer = setTimeout(() => resolve2(true), timeoutMs);
+    timer.unref?.();
+  });
+  const settled = Promise.allSettled(pending).then(() => false);
+  const result = await Promise.race([settled, timedOut]);
+  if (timer) {
+    clearTimeout(timer);
+  }
+  return result;
+}
+async function awaitPendingCaptures(ctx) {
+  if (!ctx.awaitPending?.length) {
+    return;
+  }
+  const timedOut = await settlePending(
+    ctx.awaitPending,
+    PENDING_SETTLE_TIMEOUT_MS
+  );
+  if (timedOut) {
+    ctx.log?.(
+      "warn",
+      `One or more of ${ctx.awaitPending.length} snapshot capture(s) did not settle within ${PENDING_SETTLE_TIMEOUT_MS}ms; writing trace with the snapshots captured so far.`
+    );
+  }
+}
+function sliceCountWarning(count) {
+  return `traceGranularity produced ${count} trace slices. Consider pairing it with a retention policy (e.g. tracePolicy: "retain-on-failure") to avoid writing hundreds of trace archives.`;
+}
+function toOutcomes(metadata) {
+  return Array.from(metadata.values(), (m) => ({
+    state: m.state,
+    attempt: m.attempt
   }));
 }
-
-// ../core/src/uid.ts
-function deterministicUid(...parts) {
-  const hash = parts.join("::").split("").reduce((acc, char) => (acc << 5) - acc + char.charCodeAt(0) | 0, 0);
-  return `stable-${Math.abs(hash).toString(36)}`;
+function shouldRetain(ctx, metadata, ledgerOutcomes) {
+  return shouldRetainTrace(ctx.policy, {
+    outcomes: ledgerOutcomes?.length ? ledgerOutcomes : toOutcomes(metadata),
+    attemptInfoAvailable: ctx.attemptInfoAvailable ?? false
+  }).retain;
 }
-var signatureCounters = /* @__PURE__ */ new Map();
-function generateStableUid(file, name) {
-  const signature = `${file}::${name}`;
-  const count = signatureCounters.get(signature) ?? 0;
-  signatureCounters.set(signature, count + 1);
-  const input = count > 0 ? `${signature}::${count}` : signature;
-  return deterministicUid(input);
+function attemptFromKey(key) {
+  const match = /-retry(\d+)$/.exec(key);
+  return match ? Number(match[1]) : 0;
 }
-function resetSignatureCounters() {
-  signatureCounters.clear();
+function sliceOutcomeView(ctx, range, isTestSlice) {
+  if (!ctx.outcomes) {
+    return void 0;
+  }
+  return isTestSlice ? ctx.outcomes.forTest(range.testUid, attemptFromKey(range.key)) : ctx.outcomes.forSpec(range.specFile);
 }
-
-// ../core/src/finalize-screencast.ts
-import fs3 from "fs";
-import os2 from "os";
-import path3 from "path";
-
-// ../core/src/video-encoder.ts
-import fs2 from "fs/promises";
-import path2 from "path";
-import os from "os";
-import { createRequire } from "module";
-var require2 = createRequire(import.meta.url);
-function loadFfmpeg() {
+async function flushRangeTrace(ctx, range, nextRange) {
+  if (ctx.mode !== "trace") {
+    return void 0;
+  }
+  if (ctx.flushed.has(range.key)) {
+    return void 0;
+  }
+  ctx.flushed.add(range.key);
+  const isTestSlice = range.testUid !== void 0;
+  const sliceMetadata = isTestSlice ? filterTestMetadataByUid(ctx.testMetadata, range.testUid) : filterTestMetadataBySpec(ctx.testMetadata, range.specFile);
+  const outcomes = sliceOutcomeView(ctx, range, isTestSlice);
+  const artifact = {
+    kind: "trace",
+    path: "",
+    scope: isTestSlice ? "test" : "spec",
+    key: range.key,
+    testUids: Array.from(sliceMetadata.keys()),
+    retained: shouldRetain(ctx, sliceMetadata, outcomes)
+  };
+  if (!artifact.retained) {
+    ctx.onArtifact?.(artifact);
+    return artifact;
+  }
+  const writeSlice = isTestSlice ? writeTestSliceTrace : writeSpecTrace;
+  artifact.path = await writeSlice({
+    range,
+    nextRange,
+    capturer: ctx.capturer,
+    actionSnapshots: ctx.actionSnapshots ?? [],
+    screencastFrames: ctx.screencastFrames,
+    sessionId: ctx.sessionId,
+    outputDir: ctx.resolveOutputDir(range),
+    format: ctx.format,
+    testMetadata: ctx.testMetadata,
+    capabilities: ctx.capabilities
+  });
+  ctx.log?.(
+    "info",
+    `Trace for ${isTestSlice ? "test" : "spec"} "${range.key}" saved to ${artifact.path}`
+  );
+  ctx.onArtifact?.(artifact);
+  return artifact;
+}
+async function flushRangeLogged(ctx, range) {
   try {
-    return require2("fluent-ffmpeg");
-  } catch {
-    throw new Error(
-      "VideoEncoder: fluent-ffmpeg is required for screencast encoding. Install it with: npm install fluent-ffmpeg"
+    return await flushRangeTrace(ctx, range);
+  } catch (err) {
+    const label = range.testUid !== void 0 ? `test "${range.key}"` : `spec "${range.specFile}"`;
+    ctx.log?.(
+      "warn",
+      `Failed to flush trace for ${label}: ${errorMessage(err)}`
     );
+    return void 0;
   }
 }
-async function writeFramesAndManifest(frames, tmpDir, ext) {
-  const manifestLines = ["ffconcat version 1.0"];
-  for (let i = 0; i < frames.length; i++) {
-    const frameName = `frame-${String(i).padStart(6, "0")}.${ext}`;
-    const framePath = path2.join(tmpDir, frameName);
-    await fs2.writeFile(framePath, Buffer.from(frames[i].data, "base64"));
-    const nextTs = frames[i + 1]?.timestamp ?? frames[i].timestamp + 100;
-    const durationSecs = Math.max((nextTs - frames[i].timestamp) / 1e3, 0.01);
-    manifestLines.push(`file '${framePath}'`);
-    manifestLines.push(`duration ${durationSecs.toFixed(6)}`);
+async function writeSessionTrace(ctx) {
+  const prepare = ctx.prepareSnapshots ?? ((s) => s);
+  const snapshots = prepare(ctx.actionSnapshots ?? []);
+  const artifact = {
+    kind: "trace",
+    path: "",
+    scope: "session",
+    testUids: Array.from(ctx.testMetadata.keys()),
+    retained: shouldRetain(ctx, ctx.testMetadata, ctx.outcomes?.all())
+  };
+  if (!artifact.retained) {
+    ctx.onArtifact?.(artifact);
+    return artifact;
+  }
+  artifact.path = await writeTraceZip(ctx.capturer, {
+    outputDir: ctx.resolveOutputDir(),
+    sessionId: ctx.sessionId,
+    capabilities: ctx.capabilities,
+    actionSnapshots: snapshots.length ? snapshots : void 0,
+    screencastFrames: ctx.screencastFrames,
+    format: ctx.format,
+    testMetadata: ctx.testMetadata
+  });
+  ctx.log?.("info", `Trace saved to ${artifact.path}`);
+  ctx.onArtifact?.(artifact);
+  return artifact;
+}
+async function safely(ctx, write) {
+  try {
+    return await write();
+  } catch (err) {
+    ctx.log?.("warn", `trace write failed: ${errorMessage(err)}`);
+    return void 0;
   }
-  const lastFramePath = path2.join(
-    tmpDir,
-    `frame-${String(frames.length - 1).padStart(6, "0")}.${ext}`
-  );
-  manifestLines.push(`file '${lastFramePath}'`);
-  const manifestPath = path2.join(tmpDir, "manifest.txt");
-  await fs2.writeFile(manifestPath, manifestLines.join("\n"));
-  return manifestPath;
 }
-function classifyFfmpegError(err) {
-  const msg = err.message || "";
-  if (msg.includes("Cannot find ffmpeg") || msg.includes("ENOENT") || msg.includes("spawn") || msg.includes("not found")) {
-    return new Error(
-      "VideoEncoder: ffmpeg binary not found on PATH. Install ffmpeg: https://ffmpeg.org/download.html"
+async function flushAllRanges(ctx) {
+  const artifacts = [];
+  for (let i = 0; i < ctx.ranges.length; i++) {
+    const range = ctx.ranges[i];
+    const nextRange = ctx.ranges[i + 1];
+    const artifact = await safely(
+      ctx,
+      () => flushRangeTrace(ctx, range, nextRange)
     );
+    if (artifact) {
+      artifacts.push(artifact);
+    }
   }
-  return new Error(`VideoEncoder: ffmpeg error \u2014 ${msg}`);
+  return artifacts;
 }
-function runFfmpeg(ffmpeg, manifestPath, outputPath) {
-  return new Promise((resolve2, reject) => {
-    ffmpeg().input(manifestPath).inputOptions(["-f", "concat", "-safe", "0"]).videoCodec("libvpx").outputOptions([
-      "-b:v",
-      "1M",
-      "-pix_fmt",
-      "yuv420p",
-      "-vsync",
-      "cfr",
-      "-r",
-      "10",
-      // Force a keyframe every frame. VP8 can only seek to keyframes, and
-      // libvpx's default GOP places a single keyframe on near-static
-      // screencast content — so scrubber/marker seeks snap back to the
-      // start. At 10fps over short recordings, all-intra keeps seeking
-      // frame-accurate at an acceptable size.
-      "-g",
-      "1",
-      "-keyint_min",
-      "1",
-      "-auto-alt-ref",
-      "0",
-      "-disposition:v",
-      "default"
-    ]).output(outputPath).on("end", () => resolve2()).on("error", (err) => reject(classifyFfmpegError(err))).run();
-  });
+async function finalizeTraceExport(ctx) {
+  if (ctx.mode !== "trace") {
+    return [];
+  }
+  await awaitPendingCaptures(ctx);
+  const artifacts = await fanOutTraceWrites(ctx);
+  await maybeWriteManifest(ctx, artifacts);
+  return artifacts;
 }
-async function encodeToVideo(frames, outputPath, options = {}) {
-  if (frames.length === 0) {
-    throw new Error("VideoEncoder: no frames to encode");
+async function fanOutTraceWrites(ctx) {
+  const sliced = ctx.granularity === "spec" || ctx.granularity === "test";
+  if (sliced && ctx.ranges.length > 0) {
+    if (ctx.ranges.length > SLICE_COUNT_WARN_THRESHOLD) {
+      ctx.log?.("warn", sliceCountWarning(ctx.ranges.length));
+    }
+    return flushAllRanges(ctx);
   }
-  const ffmpeg = loadFfmpeg();
-  const ext = options.captureFormat === "png" ? "png" : "jpg";
-  const tmpDir = await fs2.mkdtemp(
-    path2.join(os.tmpdir(), "devtools-screencast-")
-  );
+  if (ctx.granularity === "spec") {
+    ctx.log?.("warn", SPEC_WITHOUT_BOUNDARIES_WARNING);
+  } else if (ctx.granularity === "test") {
+    ctx.log?.("warn", TEST_WITHOUT_BOUNDARIES_WARNING);
+  }
+  const artifact = await safely(ctx, () => writeSessionTrace(ctx));
+  return artifact ? [artifact] : [];
+}
+async function maybeWriteManifest(ctx, fanOutArtifacts) {
+  if (!ctx.emitManifest) {
+    return;
+  }
+  const artifacts = ctx.collectedArtifacts ?? fanOutArtifacts;
   try {
-    const manifestPath = await writeFramesAndManifest(frames, tmpDir, ext);
-    await runFfmpeg(ffmpeg, manifestPath, outputPath);
-  } finally {
-    await fs2.rm(tmpDir, { recursive: true, force: true }).catch(() => {
-    });
+    const path14 = await writeArtifactsManifest(
+      ctx.resolveOutputDir(),
+      buildArtifactsManifest({
+        sessionId: ctx.sessionId,
+        format: ctx.format ?? "zip",
+        artifacts,
+        testMetadata: ctx.testMetadata
+      })
+    );
+    ctx.log?.("info", `Artifacts manifest written to ${path14}`);
+  } catch (err) {
+    ctx.log?.(
+      "warn",
+      `Failed to write artifacts manifest: ${errorMessage(err)}`
+    );
   }
 }
 
+// ../core/src/terminal-throttle.ts
+var TERMINAL_REPEAT_WINDOW_MS = 1e3;
+var LEADING_ISO_TIMESTAMP_RE = /^\d{4}-\d{2}-\d{2}T\d{2}:\d{2}:\d{2}(?:\.\d\d\d)?Z {1,4}/;
+function terminalRepeatKey(line) {
+  return line.replace(LEADING_ISO_TIMESTAMP_RE, "");
+}
+var TerminalLineThrottle = class {
+  #lastEmitted = /* @__PURE__ */ new Map();
+  #windowMs;
+  constructor(windowMs = TERMINAL_REPEAT_WINDOW_MS) {
+    this.#windowMs = windowMs;
+  }
+  /**
+   * True if the line should be emitted, false if it's a within-window repeat of
+   * a line already emitted. The window is anchored to the last *emit*, not the
+   * last occurrence, so a sustained stream of one line still emits once per
+   * window instead of going silent after the first. Expired keys are pruned on
+   * each emit, so state stays bounded by the number of distinct lines seen
+   * within the window.
+   */
+  shouldEmit(line, now = Date.now()) {
+    const key = terminalRepeatKey(line);
+    const last = this.#lastEmitted.get(key);
+    if (last !== void 0 && now - last < this.#windowMs) {
+      return false;
+    }
+    this.#lastEmitted.set(key, now);
+    this.#prune(now);
+    return true;
+  }
+  #prune(now) {
+    for (const [key, ts] of this.#lastEmitted) {
+      if (now - ts >= this.#windowMs) {
+        this.#lastEmitted.delete(key);
+      }
+    }
+  }
+};
+
 // ../core/src/finalize-screencast.ts
+import fs7 from "fs";
+import os2 from "os";
+import path7 from "path";
 async function finalizeScreencast({
   recorder,
   sessionId,
@@ -2655,11 +4348,11 @@ async function finalizeScreencast({
   sendUpstream,
   onLog
 }) {
-  const log12 = (level, message) => onLog?.(level, message);
+  const log14 = (level, message) => onLog?.(level, message);
   try {
     await recorder.stop();
   } catch (err) {
-    log12("warn", `Screencast stop failed: ${errorMessage(err)}`);
+    log14("warn", `Screencast stop failed: ${errorMessage(err)}`);
     return;
   }
   const frames = recorder.frames;
@@ -2668,15 +4361,16 @@ async function finalizeScreencast({
   }
   const fileName = `${filenamePrefix}-${sessionId}.webm`;
   const candidate = outputDir || process.cwd();
-  let videoPath = path3.join(candidate, fileName);
+  let videoPath = path7.join(candidate, fileName);
   try {
-    fs3.accessSync(candidate, fs3.constants.W_OK);
+    fs7.mkdirSync(candidate, { recursive: true });
+    fs7.accessSync(candidate, fs7.constants.W_OK);
   } catch {
-    videoPath = path3.join(os2.tmpdir(), fileName);
+    videoPath = path7.join(os2.tmpdir(), fileName);
   }
   try {
     await encodeToVideo(frames, videoPath, { captureFormat });
-    log12("info", `\u{1F4F9} Screencast video: ${videoPath}`);
+    log14("info", `\u{1F4F9} Screencast video: ${videoPath}`);
     sendUpstream("screencast", {
       sessionId,
       videoPath,
@@ -2686,33 +4380,37 @@ async function finalizeScreencast({
       startTime: frames[0]?.timestamp
     });
   } catch (err) {
-    log12("warn", `Screencast encode failed: ${errorMessage(err)}`);
+    log14("warn", `Screencast encode failed: ${errorMessage(err)}`);
   }
 }
 
 // ../core/src/output-dir.ts
-import fs4 from "fs";
-import path4 from "path";
-var NODE_MODULES_SEGMENT = `${path4.sep}node_modules${path4.sep}`;
+import fs8 from "fs";
+import path8 from "path";
+var NODE_MODULES_SEGMENT = `${path8.sep}node_modules${path8.sep}`;
+var OUTPUT_SUBDIR = "test-results";
 function isWritable(dir) {
   try {
-    fs4.accessSync(dir, fs4.constants.W_OK);
+    fs8.accessSync(dir, fs8.constants.W_OK);
     return true;
   } catch {
     return false;
   }
 }
 function resolveAdapterOutputDir(input = {}) {
+  return path8.join(resolveBaseDir(input), OUTPUT_SUBDIR);
+}
+function resolveBaseDir(input) {
   const fallback = input.fallbackDir ?? process.cwd();
   if (input.userConfiguredDir) {
     return input.userConfiguredDir;
   }
   const candidates = [];
   if (input.testFilePath) {
-    candidates.push(path4.dirname(input.testFilePath));
+    candidates.push(path8.dirname(input.testFilePath));
   }
   if (input.configPath) {
-    candidates.push(path4.dirname(input.configPath));
+    candidates.push(path8.dirname(input.configPath));
   }
   candidates.push(fallback);
   for (const dir of candidates) {
@@ -2932,7 +4630,38 @@ var ScreencastRecorderBase = class {
    */
   pushCdpFrame(data, timestampSeconds) {
     const timestamp = typeof timestampSeconds === "number" ? Math.round(timestampSeconds * 1e3) : Date.now();
-    this.buffer.push({ data, timestamp });
+    this.#appendFrame({ data, timestamp });
+  }
+  /**
+   * Append a frame, decimating the buffer in place once it exceeds
+   * `maxBufferFrames` so a long session can't grow it without bound.
+   */
+  #appendFrame(frame) {
+    this.buffer.push(frame);
+    if (this.buffer.length > Math.max(2, this.options.maxBufferFrames)) {
+      this.#decimateBuffer();
+    }
+  }
+  /**
+   * Halve the buffer by keeping every other frame plus the first and last, so
+   * memory is bounded while the temporal spread survives (never tail-truncated).
+   * `#startIndex` is remapped to the count of surviving pre-marker frames, which
+   * keeps `frames`/`duration` excluding pre-marker frames across decimation.
+   */
+  #decimateBuffer() {
+    const lastIndex = this.buffer.length - 1;
+    const kept = [];
+    let preMarkerKept = 0;
+    for (let i = 0; i < this.buffer.length; i++) {
+      if (i % 2 === 0 || i === lastIndex) {
+        if (i < this.#startIndex) {
+          preMarkerKept++;
+        }
+        kept.push(this.buffer[i]);
+      }
+    }
+    this.buffer = kept;
+    this.#startIndex = preMarkerKept;
   }
   /** Whether `setStartMarker` (or `markStartAtLatest`) has fired yet. */
   get hasStartMarker() {
@@ -2971,13 +4700,13 @@ var ScreencastRecorderBase = class {
         this.onUnavailable(new Error("first screenshot returned null"));
         return;
       }
-      this.buffer.push({ data: first, timestamp: Date.now() });
+      this.#appendFrame({ data: first, timestamp: Date.now() });
       const intervalMs = this.options.pollIntervalMs;
       this.#pollTimer = setInterval(async () => {
         try {
           const data = await this.takeScreenshot();
           if (data !== null) {
-            this.buffer.push({ data, timestamp: Date.now() });
+            this.#appendFrame({ data, timestamp: Date.now() });
           }
         } catch {
           this.#stopPolling();
@@ -2999,15 +4728,15 @@ var ScreencastRecorderBase = class {
 };
 
 // ../core/src/script-loader.ts
-import fs5 from "fs/promises";
-import path5 from "path";
-import { createRequire as createRequire2 } from "module";
-var require3 = createRequire2(import.meta.url);
+import fs9 from "fs/promises";
+import path9 from "path";
+import { createRequire as createRequire3 } from "module";
+var require4 = createRequire3(import.meta.url);
 async function loadInjectableScript() {
-  const scriptPath = require3.resolve("@wdio/devtools-script");
-  const scriptDir = path5.dirname(scriptPath);
-  const preloadScriptPath = path5.join(scriptDir, "script.js");
-  const scriptContent = await fs5.readFile(preloadScriptPath, "utf-8");
+  const scriptPath = require4.resolve("@wdio/devtools-script");
+  const scriptDir = path9.dirname(scriptPath);
+  const preloadScriptPath = path9.join(scriptDir, "script.js");
+  const scriptContent = await fs9.readFile(preloadScriptPath, "utf-8");
   return `(async function() { ${scriptContent} })()`;
 }
 async function pollUntilReady(check, opts = {}) {
@@ -3023,7 +4752,7 @@ async function pollUntilReady(check, opts = {}) {
 }
 
 // ../core/src/session-capturer.ts
-import fs6 from "fs/promises";
+import fs10 from "fs/promises";
 import { WebSocket } from "ws";
 var SessionCapturerBase = class {
   // ── State (mostly private; subclasses access shared ws via `this.ws`) ────
@@ -3041,6 +4770,11 @@ var SessionCapturerBase = class {
   // stdout, OR when stream forwarding wants to log via console.
   #isCapturingConsole = false;
   #isCapturingStream = false;
+  // Collapses high-frequency identical terminal lines (e.g. WDIO's per-command
+  // COMMAND/RESULT logger frames reprinted every ~100ms during an expect poll)
+  // so they don't flood the console lane. Terminal-source only — user
+  // console.* is source='test' and never throttled.
+  #terminalThrottle = new TerminalLineThrottle();
   // Command bookkeeping — used by adapters that emit commands themselves
   // (nightwatch, selenium). The WDIO service adapter doesn't call sendCommand
   // (WDIO owns the command lifecycle), so this state is harmless overhead.
@@ -3165,6 +4899,32 @@ var SessionCapturerBase = class {
       command: toSend
     });
   }
+  /**
+   * Mark the most recent user action of a test as failed — for framework
+   * failures that aren't captured as their own command. Broadcasts the swap so
+   * live mode highlights it too. Returns false when no eligible action is found,
+   * OR when that most-recent action already carries an error: the failure is
+   * then already represented (e.g. an expect matcher captured as its own row via
+   * afterAssertion), so it must not bleed onto an earlier *passing* action.
+   */
+  failLastAction(testUid, error) {
+    for (let i = this.commandsLog.length - 1; i >= 0; i--) {
+      const command = this.commandsLog[i];
+      if (!mapCommandToAction(command.command)) {
+        continue;
+      }
+      if (testUid && command.testUid !== testUid) {
+        continue;
+      }
+      if (command.error) {
+        return false;
+      }
+      command.error = error;
+      this.sendReplaceCommand(command.timestamp, command);
+      return true;
+    }
+    return false;
+  }
   /**
    * Read a file from disk, store in `sources`, and broadcast to the UI via
    * `sendUpstream('sources', { [path]: text })`. Idempotent — a cached path is
@@ -3176,7 +4936,7 @@ var SessionCapturerBase = class {
       return;
     }
     try {
-      const source = (await fs6.readFile(filePath, "utf-8")).toString();
+      const source = (await fs10.readFile(filePath, "utf-8")).toString();
       this.sources.set(filePath, source);
       this.sendUpstream("sources", { [filePath]: source });
     } catch (err) {
@@ -3324,7 +5084,7 @@ var SessionCapturerBase = class {
           const segments = rawLine.split("\r").filter((s) => s.trim());
           const lastSegment = segments[segments.length - 1] ?? rawLine;
           const clean = stripAnsi(lastSegment).trim();
-          if (!clean || this.isInternalStreamLine(clean) || SPINNER_RE.test(clean)) {
+          if (!clean || this.isInternalStreamLine(clean) || SPINNER_RE.test(clean) || !this.#terminalThrottle.shouldEmit(clean)) {
             continue;
           }
           this.onLine(detectLogLevel(clean), [clean], LOG_SOURCES.TERMINAL);
@@ -3402,100 +5162,6 @@ function safeStringify(value) {
   }
 }
 
-// ../core/src/spec-trace-helpers.ts
-function sanitizeSpecName(specFile) {
-  return specFile.replace(/^.*[/\\]/, "").replace(/\.[^.]+$/, "").replace(/[^a-zA-Z0-9_-]/g, "_").replace(/^_+|_+$/g, "") || "unknown-spec";
-}
-function buildSpecSessionId(specFile, sessionId) {
-  const base = sanitizeSpecName(specFile);
-  const hash = deterministicUid(specFile).split("-").pop().slice(0, 8);
-  return `${base}-${hash}-${sessionId.slice(0, 8)}`;
-}
-function buildSpecCapturer(capturer, range, nextRange) {
-  const end = nextRange ? {
-    commands: nextRange.commandStartIdx,
-    console: nextRange.consoleStartIdx,
-    network: nextRange.networkStartIdx,
-    mutations: nextRange.mutationStartIdx,
-    traceLogs: nextRange.traceLogStartIdx
-  } : void 0;
-  return {
-    mutations: capturer.mutations.slice(range.mutationStartIdx, end?.mutations),
-    traceLogs: capturer.traceLogs.slice(range.traceLogStartIdx, end?.traceLogs),
-    consoleLogs: capturer.consoleLogs.slice(
-      range.consoleStartIdx,
-      end?.console
-    ),
-    networkRequests: capturer.networkRequests.slice(
-      range.networkStartIdx,
-      end?.network
-    ),
-    commandsLog: capturer.commandsLog.slice(
-      range.commandStartIdx,
-      end?.commands
-    ),
-    sources: new Map(capturer.sources),
-    metadata: capturer.metadata,
-    startWallTime: capturer.startWallTime
-  };
-}
-function filterTestMetadataBySpec(allMetadata, specFile) {
-  const filtered = /* @__PURE__ */ new Map();
-  for (const [uid, meta] of allMetadata) {
-    if (meta.specFile === specFile) {
-      filtered.set(uid, meta);
-    }
-  }
-  return filtered;
-}
-function recordSpecBoundary(ctx, specFile, traceGranularity) {
-  if (traceGranularity !== "spec") {
-    return null;
-  }
-  const lastRange = ctx.specRanges[ctx.specRanges.length - 1];
-  if (lastRange && lastRange.specFile === specFile) {
-    return null;
-  }
-  const prevRange = lastRange && !ctx.flushedSpecs.has(lastRange.specFile) ? lastRange : null;
-  ctx.specRanges.push({
-    specFile,
-    commandStartIdx: ctx.capturer.commandsLog.length,
-    consoleStartIdx: ctx.capturer.consoleLogs.length,
-    networkStartIdx: ctx.capturer.networkRequests.length,
-    mutationStartIdx: ctx.capturer.mutations.length,
-    traceLogStartIdx: ctx.capturer.traceLogs.length,
-    snapshotCount: ctx.actionSnapshots.length
-  });
-  return prevRange;
-}
-async function writeSpecTrace(input) {
-  const specCapturer = buildSpecCapturer(
-    input.capturer,
-    input.range,
-    input.nextRange
-  );
-  const specSnapshots = input.actionSnapshots.slice(
-    input.range.snapshotCount,
-    input.nextRange?.snapshotCount ?? input.actionSnapshots.length
-  );
-  const specSessionId = buildSpecSessionId(
-    input.range.specFile,
-    input.sessionId
-  );
-  const testMetadata = filterTestMetadataBySpec(
-    input.testMetadata,
-    input.range.specFile
-  );
-  return writeTraceZip(specCapturer, {
-    outputDir: input.outputDir,
-    sessionId: specSessionId,
-    capabilities: input.capabilities,
-    actionSnapshots: specSnapshots.length > 0 ? specSnapshots : void 0,
-    format: input.format,
-    testMetadata
-  });
-}
-
 // ../core/src/suite-helpers.ts
 function createSuiteStats(init) {
   return {
@@ -3575,16 +5241,61 @@ function stampTestEnd(test, end = /* @__PURE__ */ new Date()) {
   test.end = end;
   test._duration = end.getTime() - (test.start?.getTime() ?? end.getTime());
 }
+function deriveAncestorKind(suite, parentKind) {
+  if (parentKind === "feature") {
+    return "scenario";
+  }
+  if (suite.file?.endsWith(".feature") && parentKind !== "scenario") {
+    return "feature";
+  }
+  return "suite";
+}
+function collectSuiteTestMetadata(suites) {
+  const metadata = /* @__PURE__ */ new Map();
+  const walk = (suite, ancestors) => {
+    const parentKind = ancestors[ancestors.length - 1]?.kind;
+    const chain = [
+      ...ancestors,
+      {
+        uid: suite.uid,
+        title: suite.title,
+        kind: deriveAncestorKind(suite, parentKind)
+      }
+    ];
+    for (const entry of suite.tests ?? []) {
+      if (typeof entry !== "object" || entry === null) {
+        continue;
+      }
+      metadata.set(entry.uid, {
+        title: entry.fullTitle || entry.title,
+        specFile: entry.file ?? suite.file,
+        state: entry.state,
+        attempt: entry.retries ?? 0,
+        ancestry: chain
+      });
+    }
+    for (const child of suite.suites ?? []) {
+      walk(child, chain);
+    }
+  };
+  for (const suite of suites) {
+    if (typeof suite !== "object" || suite === null) {
+      continue;
+    }
+    walk(suite, []);
+  }
+  return metadata;
+}
 
 // ../core/src/test-discovery.ts
-import fs7 from "fs";
+import fs11 from "fs";
 function findTestDefinitions(filePath, opts = {}) {
-  if (!fs7.existsSync(filePath)) {
+  if (!fs11.existsSync(filePath)) {
     return [];
   }
   let source;
   try {
-    source = fs7.readFileSync(filePath, "utf-8");
+    source = fs11.readFileSync(filePath, "utf-8");
   } catch {
     return [];
   }
@@ -3678,15 +5389,113 @@ var TestReporterBase = class {
   }
 };
 
+// src/trace-context.ts
+function buildTraceContext(input, sessionId) {
+  return {
+    mode: input.mode,
+    policy: input.policy,
+    granularity: input.granularity,
+    format: input.format,
+    capturer: input.capturer,
+    actionSnapshots: input.capturer.actionSnapshots,
+    sessionId,
+    testMetadata: collectSuiteTestMetadata(input.suites),
+    outcomes: input.outcomes,
+    ranges: input.ranges,
+    flushed: input.flushed,
+    screencastFrames: input.screencastFrames,
+    resolveOutputDir: () => resolveAdapterOutputDir({
+      testFilePath: input.testFilePath,
+      configPath: input.configPath
+    }),
+    awaitPending: [...input.capturer.snapshotCaptures, ...input.traceFlushes],
+    // Nightwatch feeds real per-test attempt numbers via TestAttemptTracker
+    // (B4), so retry-aware policies use per-test attempts, not the fallback.
+    attemptInfoAvailable: true,
+    // Off by default; opt-in only — Nightwatch has no live Allure signal to
+    // auto-detect against (produce-only Allure), unlike WDIO/Selenium.
+    emitManifest: input.emitArtifactsManifest ?? false,
+    collectedArtifacts: input.artifacts,
+    onArtifact: (a) => input.artifacts.push(a),
+    log: input.log
+  };
+}
+
+// src/test-artifacts.ts
+async function emitTestArtifacts(input) {
+  await captureAndAttachScreenshot({
+    mode: input.mode,
+    granularity: input.granularity,
+    policy: input.screenshotPolicy,
+    failed: input.failed,
+    screenshotBase64: lastRenderedScreenshot(
+      input.actionSnapshots,
+      input.startWallTime
+    ),
+    sessionId: input.sessionId,
+    outputDir: input.outputDir,
+    testUid: input.uid,
+    attach: void 0,
+    onArtifact: input.onArtifact,
+    onLog: input.onLog
+  });
+  await captureAndAttachVideo({
+    mode: input.mode,
+    granularity: input.granularity,
+    policy: input.videoPolicy,
+    frames: input.frames,
+    startWallTime: input.startWallTime,
+    outcomes: input.outcomes,
+    attempt: input.attempt,
+    outputDir: input.outputDir,
+    testUid: input.uid,
+    sessionId: input.sessionId,
+    captureFormat: input.captureFormat,
+    attach: void 0,
+    onArtifact: input.onArtifact,
+    onLog: input.onLog
+  });
+}
+
+// src/helpers/assertCapture.ts
+import logger from "@wdio/logger";
+var log = logger("@wdio/nightwatch-devtools:assertCapture");
+function wireAssertCapture(getCapturer, getTestUid) {
+  patchNodeAssert(
+    (cmd) => captureAssert(getCapturer(), getTestUid(), cmd),
+    (level, message) => log[level](message)
+  );
+}
+function captureAssert(capturer, testUid, cmd) {
+  if (!capturer) {
+    return;
+  }
+  capturer.captureCommand(
+    cmd.command,
+    cmd.args,
+    cmd.result,
+    cmd.error,
+    testUid,
+    cmd.callSource,
+    cmd.timestamp
+  ).catch(
+    (err) => log.warn(`Failed to capture ${cmd.command}: ${errorMessage(err)}`)
+  );
+  const last = capturer.commandsLog[capturer.commandsLog.length - 1];
+  if (last) {
+    capturer.sendCommand(last);
+  }
+}
+
 // src/index.ts
 import { stop as stopBackend } from "@wdio/devtools-backend";
-import logger11 from "@wdio/logger";
+import logger13 from "@wdio/logger";
 
 // src/run-lifecycle.ts
-import * as fs9 from "fs";
-import * as path7 from "path";
+import * as fs13 from "fs";
+import * as path11 from "path";
 import * as os3 from "os";
-import logger from "@wdio/logger";
+import logger2 from "@wdio/logger";
 import { remote } from "webdriverio";
 import { start, stop } from "@wdio/devtools-backend";
 
@@ -3744,8 +5553,8 @@ var CONFIG_FILENAMES = [
 var PLUGIN_GLOBAL_KEY = "__nightwatchDevtoolsPlugin";
 
 // src/helpers/utils.ts
-import * as fs8 from "fs";
-import * as path6 from "path";
+import * as fs12 from "fs";
+import * as path10 from "path";
 import { parse as parseStackTrace2 } from "stacktrace-parser";
 function determineTestState(testcase) {
   if (testcase.passed === 0 && testcase.failed === 0) {
@@ -3802,7 +5611,7 @@ function findTestFileFromStack() {
     return void 0;
   }
   const filePath = normalizeFilePath(frame.file);
-  return fs8.existsSync(filePath) ? filePath : void 0;
+  return fs12.existsSync(filePath) ? filePath : void 0;
 }
 function extractTestMetadata(filePath) {
   const defs = findTestDefinitions(filePath, {
@@ -3930,21 +5739,21 @@ function resolveNightwatchConfig() {
   );
   if (configFlagIdx !== -1 && process.argv[configFlagIdx + 1]) {
     const argvConfig = process.argv[configFlagIdx + 1];
-    const resolved = path6.isAbsolute(argvConfig) ? argvConfig : path6.resolve(process.cwd(), argvConfig);
-    if (fs8.existsSync(resolved)) {
+    const resolved = path10.isAbsolute(argvConfig) ? argvConfig : path10.resolve(process.cwd(), argvConfig);
+    if (fs12.existsSync(resolved)) {
       return resolved;
     }
   }
   let dir = process.cwd();
-  const root = path6.parse(dir).root;
+  const root = path10.parse(dir).root;
   while (dir && dir !== root) {
     for (const file of CONFIG_FILENAMES) {
-      const candidate = path6.join(dir, file);
-      if (fs8.existsSync(candidate)) {
+      const candidate = path10.join(dir, file);
+      if (fs12.existsSync(candidate)) {
         return candidate;
       }
     }
-    const parent = path6.dirname(dir);
+    const parent = path10.dirname(dir);
     if (parent === dir) {
       break;
     }
@@ -3954,11 +5763,11 @@ function resolveNightwatchConfig() {
 }
 
 // src/run-lifecycle.ts
-var log = logger("@wdio/nightwatch-devtools:run-lifecycle");
+var log2 = logger2("@wdio/nightwatch-devtools:run-lifecycle");
 function handleReuseMode(ctx) {
   ctx.options.hostname = process.env[REUSE_ENV.HOST];
   ctx.options.port = Number(process.env[REUSE_ENV.PORT]);
-  log.info(
+  log2.info(
     `\u267B  Reusing DevTools backend at ${ctx.options.hostname}:${ctx.options.port}`
   );
   if (ctx.testReporter) {
@@ -3966,7 +5775,7 @@ function handleReuseMode(ctx) {
     ctx.passCount = 0;
     ctx.failCount = 0;
     ctx.skipCount = 0;
-    log.info("Cleared execution data for rerun");
+    log2.info("Cleared execution data for rerun");
   }
 }
 async function runPluginBefore(ctx) {
@@ -3977,9 +5786,9 @@ async function runPluginBefore(ctx) {
   const configPath = resolveNightwatchConfig();
   ctx.setConfigPath(configPath);
   if (configPath) {
-    log.info(`\u2713 Config: ${configPath}`);
+    log2.info(`\u2713 Config: ${configPath}`);
   } else {
-    log.warn(
+    log2.warn(
       "Could not find nightwatch config \u2014 test rerun will be unavailable"
     );
   }
@@ -3990,18 +5799,18 @@ async function runPluginBefore(ctx) {
   }
   try {
     if (ctx.options.mode === "trace") {
-      log.info("Trace mode \u2014 skipping backend port-bind and UI window");
+      log2.info("Trace mode \u2014 skipping backend port-bind and UI window");
     } else {
       ctx.options.port = await findFreePort(
         ctx.options.port,
         ctx.options.hostname
       );
-      log.info("\u{1F680} Starting DevTools backend...");
+      log2.info("\u{1F680} Starting DevTools backend...");
       const { port } = await start(ctx.options);
       ctx.options.port = port;
       const url = `http://${ctx.options.hostname}:${ctx.options.port}`;
-      log.info(`\u2713 Backend started on port ${ctx.options.port}`);
-      log.info(`  DevTools UI: ${url}`);
+      log2.info(`\u2713 Backend started on port ${ctx.options.port}`);
+      log2.info(`  DevTools UI: ${url}`);
       await ctx.openDevtoolsBrowserAt(url);
       await new Promise(
         (resolve2) => setTimeout(resolve2, TIMING.UI_CONNECTION_WAIT)
@@ -4010,18 +5819,18 @@ async function runPluginBefore(ctx) {
     ;
     globalThis[PLUGIN_GLOBAL_KEY] = ctx.plugin;
   } catch (err) {
-    log.error(`Failed to start backend: ${errorMessage(err)}`);
+    log2.error(`Failed to start backend: ${errorMessage(err)}`);
     throw err;
   }
 }
 async function openDevtoolsBrowser(ctx, url) {
   try {
-    ctx.userDataDir = path7.join(
+    ctx.userDataDir = path11.join(
       os3.tmpdir(),
       `nightwatch-devtools-${ctx.options.port}-${Date.now()}`
     );
-    if (!fs9.existsSync(ctx.userDataDir)) {
-      fs9.mkdirSync(ctx.userDataDir, { recursive: true });
+    if (!fs13.existsSync(ctx.userDataDir)) {
+      fs13.mkdirSync(ctx.userDataDir, { recursive: true });
     }
     ctx.devtoolsBrowser = await remote({
       logLevel: "info",
@@ -4047,8 +5856,8 @@ async function openDevtoolsBrowser(ctx, url) {
     });
     await ctx.devtoolsBrowser.url(url);
   } catch (err) {
-    log.error(`Failed to open DevTools UI: ${errorMessage(err)}`);
-    log.info(`Please manually open: ${url}`);
+    log2.error(`Failed to open DevTools UI: ${errorMessage(err)}`);
+    log2.info(`Please manually open: ${url}`);
   }
 }
 async function finalizeAllSuites(ctx, browser) {
@@ -4071,22 +5880,22 @@ function logRunSummary(ctx) {
     ctx.failCount > 0 ? `${ctx.failCount} failed` : null,
     ctx.skipCount > 0 ? `${ctx.skipCount} skipped` : null
   ].filter(Boolean).join("  ");
-  log.info(`${ctx.failCount > 0 ? "\u274C" : "\u2705"} Tests complete!  ${summary}`);
-  log.info(`   DevTools UI: http://${ctx.options.hostname}:${ctx.options.port}`);
+  log2.info(`${ctx.failCount > 0 ? "\u274C" : "\u2705"} Tests complete!  ${summary}`);
+  log2.info(`   DevTools UI: http://${ctx.options.hostname}:${ctx.options.port}`);
 }
 async function waitForDevtoolsBrowserClose(ctx) {
   if (!ctx.devtoolsBrowser) {
     return;
   }
   ;
-  logger.setLevel(
+  logger2.setLevel(
     "devtools",
     "warn"
   );
   let exitBySignal = false;
   const signalHandler = () => {
     exitBySignal = true;
-    log.info("\n\u2713 Exiting... Browser window will remain open");
+    log2.info("\n\u2713 Exiting... Browser window will remain open");
     process.exit(0);
   };
   process.once("SIGINT", signalHandler);
@@ -4097,7 +5906,7 @@ async function waitForDevtoolsBrowserClose(ctx) {
       await new Promise((res) => setTimeout(res, TIMING.BROWSER_POLL_INTERVAL));
     } catch {
       if (!exitBySignal) {
-        log.info("Browser window closed, stopping DevTools app");
+        log2.info("Browser window closed, stopping DevTools app");
         break;
       }
     }
@@ -4107,7 +5916,7 @@ async function waitForDevtoolsBrowserClose(ctx) {
   }
   process.removeListener("SIGINT", signalHandler);
   process.removeListener("SIGTERM", signalHandler);
-  logger.setLevel(
+  logger2.setLevel(
     "devtools",
     "info"
   );
@@ -4120,8 +5929,8 @@ async function waitForDevtoolsBrowserClose(ctx) {
 }
 
 // src/event-hub.ts
-import logger2 from "@wdio/logger";
-var log2 = logger2("@wdio/nightwatch-devtools:event-hub");
+import logger3 from "@wdio/logger";
+var log3 = logger3("@wdio/nightwatch-devtools:event-hub");
 function makeSessionMetadataHandler(bindings) {
   return (data) => {
     try {
@@ -4142,23 +5951,23 @@ function makeSessionMetadataHandler(bindings) {
         options: bindings.buildMetadataOptions()
       });
     } catch (err) {
-      log2.error(`Error in event handler: ${errorMessage(err)}`);
+      log3.error(`Error in event handler: ${errorMessage(err)}`);
     }
   };
 }
 function registerEventHandlers(eventHub, bindings) {
   bindings.setCucumberRunner(eventHub.runner === "cucumber");
   if (eventHub.runner === "cucumber") {
-    log2.info("\u2713 Cucumber runner detected via NightwatchEventHub");
+    log3.info("\u2713 Cucumber runner detected via NightwatchEventHub");
   }
-  log2.info("\u2713 NightwatchEventHub registered \u2014 enriched metadata enabled");
+  log3.info("\u2713 NightwatchEventHub registered \u2014 enriched metadata enabled");
   const handler = makeSessionMetadataHandler(bindings);
   eventHub.on("TestSuiteStarted", handler);
   eventHub.on("TestRunStarted", handler);
 }
 
 // src/cucumber-lifecycle.ts
-import logger3 from "@wdio/logger";
+import logger4 from "@wdio/logger";
 
 // src/helpers/cucumberResult.ts
 function cucumberResultToTestState(result) {
@@ -4186,7 +5995,7 @@ function closeOpenSteps(suite, scenarioState, now = /* @__PURE__ */ new Date())
 }
 
 // src/helpers/cucumberScenarioBuilder.ts
-function buildScenarioStepTest(input, scenarioUid, i) {
+function buildScenarioStepTest(input, scenarioUid, attempt, i) {
   const {
     featureUri,
     scenarioName,
@@ -4202,7 +6011,9 @@ function buildScenarioStepTest(input, scenarioUid, i) {
   const stepDefLoc = findStepDefinitionLine(stepDefFiles, step.text);
   const callSource = stepDefLoc ? `${stepDefLoc.filePath}:${stepDefLoc.line}` : featureAbsPath && stepLines[i] > 0 ? `${featureAbsPath}:${stepLines[i]}` : void 0;
   return {
-    uid: deterministicUid(featureUri, `step:${scenarioName}:${step.text}`),
+    // Scope by the scenario uid (which carries the scenario line) so identical
+    // step text in sibling scenarios and outline example rows stays distinct.
+    uid: deterministicUid(featureUri, `step:${scenarioUid}:${step.text}`),
     cid: DEFAULTS.CID,
     title: stepLabel,
     fullTitle: `${scenarioName} ${stepLabel}`,
@@ -4212,7 +6023,9 @@ function buildScenarioStepTest(input, scenarioUid, i) {
     end: null,
     type: "test",
     file: featureUri,
-    retries: 0,
+    // Scenario-level attempt from the tracker (0 first run, +1 per retry);
+    // flows to TestOutcome.attempt via collectSuiteTestMetadata.
+    retries: attempt,
     _duration: 0,
     hooks: [],
     callSource
@@ -4228,7 +6041,11 @@ function buildCucumberScenarioSuite(input) {
     scenarioLine,
     parentFeatureSuiteUid
   } = input;
-  const scenarioUid = deterministicUid(featureUri, `scenario:${scenarioName}`);
+  const scenarioUid = deterministicUid(
+    featureUri,
+    `scenario:${scenarioName}:${scenarioLine}`
+  );
+  const attempt = input.recordAttempt?.(scenarioUid, featureUri) ?? 0;
   const scenarioSuite = {
     uid: scenarioUid,
     cid: DEFAULTS.CID,
@@ -4247,49 +6064,51 @@ function buildCucumberScenarioSuite(input) {
     callSource: featureAbsPath && scenarioLine > 0 ? `${featureAbsPath}:${scenarioLine}` : void 0
   };
   for (let i = 0; i < steps.length; i++) {
-    scenarioSuite.tests.push(buildScenarioStepTest(input, scenarioUid, i));
+    scenarioSuite.tests.push(
+      buildScenarioStepTest(input, scenarioUid, attempt, i)
+    );
   }
   return scenarioSuite;
 }
 
 // src/helpers/featureFileScan.ts
-import fs10 from "fs";
-import path8 from "path";
+import fs14 from "fs";
+import path12 from "path";
 function scanFeatureFile(featureUri) {
-  const featureAbsPath = path8.resolve(process.cwd(), featureUri);
+  const featureAbsPath = path12.resolve(process.cwd(), featureUri);
   const result = {
-    featureName: path8.basename(featureUri, ".feature"),
+    featureName: path12.basename(featureUri, ".feature"),
     featureContent: "",
     featureAbsPath,
     stepDefFiles: [],
     capturedPaths: []
   };
-  if (featureUri === "unknown.feature" || !fs10.existsSync(featureAbsPath)) {
+  if (featureUri === "unknown.feature" || !fs14.existsSync(featureAbsPath)) {
     return result;
   }
-  result.featureContent = fs10.readFileSync(featureAbsPath, "utf-8");
+  result.featureContent = fs14.readFileSync(featureAbsPath, "utf-8");
   const match = result.featureContent.match(/^\s*Feature:\s*(.+)/m);
   if (match) {
     result.featureName = match[1].trim();
   }
   result.capturedPaths.push(featureAbsPath);
-  const featureDir = path8.dirname(featureAbsPath);
+  const featureDir = path12.dirname(featureAbsPath);
   const stepDirCandidates = ["step_definitions", "steps", "support"];
   for (const candidate of stepDirCandidates) {
-    const stepDir = path8.join(featureDir, candidate);
-    if (!fs10.existsSync(stepDir) || !fs10.statSync(stepDir).isDirectory()) {
+    const stepDir = path12.join(featureDir, candidate);
+    if (!fs14.existsSync(stepDir) || !fs14.statSync(stepDir).isDirectory()) {
       continue;
     }
-    for (const entry of fs10.readdirSync(stepDir)) {
+    for (const entry of fs14.readdirSync(stepDir)) {
       if (!/\.(js|ts|mjs|cjs)$/.test(entry)) {
         continue;
       }
-      const stepFilePath = path8.join(stepDir, entry);
+      const stepFilePath = path12.join(stepDir, entry);
       result.capturedPaths.push(stepFilePath);
       try {
         result.stepDefFiles.push({
           filePath: stepFilePath,
-          content: fs10.readFileSync(stepFilePath, "utf-8")
+          content: fs14.readFileSync(stepFilePath, "utf-8")
         });
       } catch {
       }
@@ -4298,8 +6117,50 @@ function scanFeatureFile(featureUri) {
   return result;
 }
 
+// src/trace-slices.ts
+function sliceActive(ctx) {
+  return ctx.traceMode && ctx.traceGranularity === "test";
+}
+function boundaryContext(ctx) {
+  return {
+    specRanges: ctx.specRanges,
+    flushedSpecs: ctx.flushedSpecs,
+    capturer: ctx.sessionCapturer
+  };
+}
+function flushPrevious(ctx, prevRange) {
+  if (!prevRange) {
+    return;
+  }
+  void ctx.flushTraceRange(prevRange);
+}
+function recordSpecSliceBoundary(ctx, specFile) {
+  const prevRange = recordSpecBoundary(
+    boundaryContext(ctx),
+    specFile,
+    ctx.traceGranularity
+  );
+  flushPrevious(ctx, prevRange);
+}
+function recordTestSliceBoundary(ctx, specFile, testUid) {
+  if (!sliceActive(ctx)) {
+    return;
+  }
+  recordSliceBoundary(boundaryContext(ctx), "test", specFile, testUid);
+}
+function flushTestSlice(ctx) {
+  if (!sliceActive(ctx)) {
+    return;
+  }
+  const range = findFlushableRange(ctx.specRanges);
+  if (!range) {
+    return;
+  }
+  void ctx.flushTraceRange(range);
+}
+
 // src/cucumber-lifecycle.ts
-var log3 = logger3("@wdio/nightwatch-devtools:cucumber");
+var log4 = logger4("@wdio/nightwatch-devtools:cucumber");
 function attachScenarioToFeature(ctx, featureSuite, scenarioSuite) {
   const existingIdx = featureSuite.suites.findIndex(
     (s) => s.uid === scenarioSuite.uid
@@ -4335,6 +6196,12 @@ function createFeatureSuite(ctx, featureUri, featureName, featureContent, featur
 function normalizeSteps(pickleSteps) {
   return (pickleSteps ?? []).map((s) => ({ text: s.text ?? "" }));
 }
+function captureFeatureSources(ctx, paths) {
+  for (const p of paths) {
+    ctx.sessionCapturer.captureSource(p).catch(() => {
+    });
+  }
+}
 async function initCucumberScenario(ctx, browser, pickle) {
   await ctx.ensureSessionInitialized(browser);
   const featureUri = pickle.uri ?? "unknown.feature";
@@ -4347,10 +6214,7 @@ async function initCucumberScenario(ctx, browser, pickle) {
     stepDefFiles,
     capturedPaths
   } = scanFeatureFile(featureUri);
-  for (const p of capturedPaths) {
-    ctx.sessionCapturer.captureSource(p).catch(() => {
-    });
-  }
+  captureFeatureSources(ctx, capturedPaths);
   const { featureSuite, scenarioLine, stepLines, stepKeywords } = createFeatureSuite(
     ctx,
     featureUri,
@@ -4370,15 +6234,17 @@ async function initCucumberScenario(ctx, browser, pickle) {
     stepLines,
     stepKeywords,
     scenarioLine,
-    parentFeatureSuiteUid: featureSuite.uid
+    parentFeatureSuiteUid: featureSuite.uid,
+    recordAttempt: (uid, specFile) => ctx.recordAttempt(uid, specFile)
   });
   attachScenarioToFeature(ctx, featureSuite, scenarioSuite);
+  recordTestSliceBoundary(ctx, featureUri, scenarioSuite.uid);
   ctx.setCurrentScenarioSuite(scenarioSuite);
   ctx.setCurrentStep(null);
   ctx.setCurrentTest(null);
   ctx.testReporter.updateSuites();
   ctx.wrapBrowserOnce(browser);
-  log3.info(`\u{1F952} Scenario: ${scenarioName}`);
+  log4.info(`\u{1F952} Scenario: ${scenarioName}`);
 }
 async function finalizeCucumberScenario(ctx, browser, result, pickle) {
   try {
@@ -4390,6 +6256,7 @@ async function finalizeCucumberScenario(ctx, browser, result, pickle) {
       scenario.state = scenarioState;
       scenario.end = now;
       scenario._duration = duration;
+      ctx.recordOutcome(scenario.uid, scenarioState);
       closeOpenSteps(scenario, scenarioState, now);
       const featureUri = pickle?.uri ?? "unknown.feature";
       ctx.testManager.markTestAsProcessed(featureUri, pickle?.name ?? "");
@@ -4399,7 +6266,7 @@ async function finalizeCucumberScenario(ctx, browser, result, pickle) {
       }
       ctx.incrementCount(scenarioState);
       const icon = ctx.testIcon(scenarioState);
-      log3.info(
+      log4.info(
         `  ${icon} ${pickle?.name ?? "Unknown"} (${(duration / 1e3).toFixed(2)}s)`
       );
       ctx.testReporter.updateSuites();
@@ -4408,8 +6275,13 @@ async function finalizeCucumberScenario(ctx, browser, result, pickle) {
       ctx.setCurrentTest(null);
     }
     await ctx.sessionCapturer.captureTrace(browser);
+    flushTestSlice(ctx);
+    await ctx.emitTestArtifacts(
+      scenario?.uid,
+      scenarioState === TEST_STATE.FAILED
+    );
   } catch (err) {
-    log3.error(`Failed to finalize Cucumber scenario: ${errorMessage(err)}`);
+    log4.error(`Failed to finalize Cucumber scenario: ${errorMessage(err)}`);
   }
 }
 async function cucumberBeforeStep(ctx, _browser, pickleStep, _pickle) {
@@ -4453,11 +6325,11 @@ async function cucumberAfter(ctx, browser, result, pickle) {
 }
 
 // src/test-lifecycle.ts
-import logger5 from "@wdio/logger";
+import logger6 from "@wdio/logger";
 
 // src/helpers/specFileResolver.ts
-import fs11 from "fs";
-import path9 from "path";
+import fs15 from "fs";
+import path13 from "path";
 function resolveSpecFilePath(testFile, modulePath, srcFolders, cachedPath) {
   let fullPath = findTestFileFromStack() || null;
   if (!fullPath && cachedPath && cachedPath.includes(testFile)) {
@@ -4473,27 +6345,27 @@ function resolveSpecFilePath(testFile, modulePath, srcFolders, cachedPath) {
   const normalized = (modulePath || "").replace(/\\/g, "/");
   const srcFolderPaths = srcFolders.flatMap(
     (sf) => normalized ? [
-      path9.resolve(workspaceRoot, sf, normalized + ".js"),
-      path9.resolve(workspaceRoot, sf, normalized + ".ts"),
-      path9.resolve(workspaceRoot, sf, normalized + ".cjs"),
-      path9.resolve(workspaceRoot, sf, normalized)
+      path13.resolve(workspaceRoot, sf, normalized + ".js"),
+      path13.resolve(workspaceRoot, sf, normalized + ".ts"),
+      path13.resolve(workspaceRoot, sf, normalized + ".cjs"),
+      path13.resolve(workspaceRoot, sf, normalized)
     ] : []
   );
   const possiblePaths = [
     ...srcFolderPaths,
     // Treat module path as relative to cwd (works when src_folders isn't nested)
     ...normalized ? [
-      path9.resolve(workspaceRoot, normalized + ".js"),
-      path9.resolve(workspaceRoot, normalized + ".ts"),
-      path9.resolve(workspaceRoot, normalized + ".cjs"),
-      path9.resolve(workspaceRoot, normalized)
+      path13.resolve(workspaceRoot, normalized + ".js"),
+      path13.resolve(workspaceRoot, normalized + ".ts"),
+      path13.resolve(workspaceRoot, normalized + ".cjs"),
+      path13.resolve(workspaceRoot, normalized)
     ] : [],
-    path9.resolve(workspaceRoot, "tests", testFile + ".js"),
-    path9.resolve(workspaceRoot, "test", testFile + ".js"),
-    path9.resolve(workspaceRoot, testFile + ".js")
+    path13.resolve(workspaceRoot, "tests", testFile + ".js"),
+    path13.resolve(workspaceRoot, "test", testFile + ".js"),
+    path13.resolve(workspaceRoot, testFile + ".js")
   ];
   for (const candidate of possiblePaths) {
-    if (fs11.existsSync(candidate)) {
+    if (fs15.existsSync(candidate)) {
       return candidate;
     }
   }
@@ -4501,8 +6373,8 @@ function resolveSpecFilePath(testFile, modulePath, srcFolders, cachedPath) {
 }
 
 // src/helpers/closePreviousTest.ts
-import logger4 from "@wdio/logger";
-var log4 = logger4("@wdio/nightwatch-devtools:closePreviousTest");
+import logger5 from "@wdio/logger";
+var log5 = logger5("@wdio/nightwatch-devtools:closePreviousTest");
 async function closePreviousTest(input) {
   const {
     runningTest,
@@ -4521,7 +6393,7 @@ async function closePreviousTest(input) {
     testManager.updateTestState(runningTest, testState);
     testManager.markTestAsProcessed(testFile, runningTest.title);
     incrementCount(testState);
-    log4.info(
+    log5.info(
       `  ${testIcon(testState)} ${runningTest.title} (${(runningTest._duration / 1e3).toFixed(2)}s)`
     );
   } else {
@@ -4535,13 +6407,13 @@ async function closePreviousTest(input) {
     );
     testManager.markTestAsProcessed(testFile, runningTest.title);
     incrementCount(TEST_STATE.PASSED);
-    log4.info(`  \u2705 ${runningTest.title} (${(duration / 1e3).toFixed(2)}s)`);
+    log5.info(`  \u2705 ${runningTest.title} (${(duration / 1e3).toFixed(2)}s)`);
   }
   await new Promise((resolve2) => setTimeout(resolve2, TIMING.UI_RENDER_DELAY));
 }
 
 // src/test-lifecycle.ts
-var log5 = logger5("@wdio/nightwatch-devtools:test-lifecycle");
+var log6 = logger6("@wdio/nightwatch-devtools:test-lifecycle");
 function resolveSuiteMetadata(ctx, currentTest) {
   const moduleName = currentTest.module ?? "";
   const testFile = moduleName.split("/").pop() || moduleName || DEFAULTS.FILE_NAME;
@@ -4552,7 +6424,7 @@ function resolveSuiteMetadata(ctx, currentTest) {
     ctx.browserProxy.getCurrentTestFullPath() || void 0
   );
   if (!fullPath) {
-    log5.warn(
+    log6.warn(
       `[beforeEach] Could not resolve file path for "${testFile}" \u2014 source view will be unavailable`
     );
   }
@@ -4586,21 +6458,25 @@ function pickCurrentTestName(currentTest, testNames, processedTests) {
   ) : void 0;
   return matchedRuntimeTestName || testNames.find((name) => !processedTests.has(name));
 }
-async function startNextTest(ctx, currentSuite, currentTestName, processedTests) {
+async function startNextTest(ctx, currentSuite, currentTestName, processedTests, specFile) {
   if (processedTests.size === 0) {
     ctx.suiteManager.markSuiteAsRunning(currentSuite);
   }
   const test = ctx.testManager.findTestInSuite(currentSuite, currentTestName);
   if (test) {
+    test.retries = ctx.recordAttempt(test.uid, specFile ?? void 0);
+    if (specFile) {
+      recordTestSliceBoundary(ctx, specFile, test.uid);
+    }
     test.state = TEST_STATE.RUNNING;
     test.start = /* @__PURE__ */ new Date();
     test.end = null;
     ctx.testReporter.onTestStart(test);
     ctx.setCurrentTest(test);
-    log5.info(`  \u25B6 ${currentTestName}`);
+    log6.info(`  \u25B6 ${currentTestName}`);
     await new Promise((resolve2) => setTimeout(resolve2, TIMING.TEST_START_DELAY));
   } else {
-    log5.warn(
+    log6.warn(
       `Test "${currentTestName}" not found in suite "${currentSuite.title}"`
     );
     ctx.setCurrentTest(null);
@@ -4645,7 +6521,7 @@ function closeUnreportedRunningTest(ctx, currentSuite, testFile, results, proces
   ctx.testManager.markTestAsProcessed(testFile, runningTest.title);
   ctx.incrementCount(testState);
   const icon = ctx.testIcon(testState);
-  log5.info(`  ${icon} ${runningTest.title} (${(duration / 1e3).toFixed(2)}s)`);
+  log6.info(`  ${icon} ${runningTest.title} (${(duration / 1e3).toFixed(2)}s)`);
 }
 async function closeReportedTestcases(ctx, currentSuite, testFile, testcases, processedTests) {
   const testcaseNames = Object.keys(testcases);
@@ -4661,7 +6537,7 @@ async function closeReportedTestcases(ctx, currentSuite, testFile, testcases, pr
       ctx.testManager.updateTestState(test, testState, /* @__PURE__ */ new Date(), dur);
       ctx.incrementCount(testState);
       const icon = ctx.testIcon(testState);
-      log5.info(`  ${icon} ${currentTestName} (${(dur / 1e3).toFixed(2)}s)`);
+      log6.info(`  ${icon} ${currentTestName} (${(dur / 1e3).toFixed(2)}s)`);
     }
     ctx.testManager.markTestAsProcessed(testFile, currentTestName);
   }
@@ -4703,11 +6579,11 @@ async function closeOutTestcases(ctx, browser) {
 }
 
 // src/session-init.ts
-import logger10 from "@wdio/logger";
+import logger12 from "@wdio/logger";
 
 // src/session.ts
 import http from "http";
-import logger6 from "@wdio/logger";
+import logger7 from "@wdio/logger";
 
 // src/action-snapshot.ts
 function captureActionSnapshot2(browser, command, takeScreenshot) {
@@ -4845,7 +6721,7 @@ function dedupeNetworkRequests(incoming, existing) {
 }
 
 // src/session.ts
-var log6 = logger6("@wdio/nightwatch-devtools:SessionCapturer");
+var log7 = logger7("@wdio/nightwatch-devtools:SessionCapturer");
 function unwrapDriverValue(result) {
   if (result && typeof result === "object" && "value" in result) {
     return result.value;
@@ -4853,7 +6729,7 @@ function unwrapDriverValue(result) {
   return result;
 }
 var getProp = (obj, key) => obj && typeof obj === "object" ? obj[key] : void 0;
-var getPath = (obj, ...path10) => path10.reduce((acc, k) => getProp(acc, k), obj);
+var getPath = (obj, ...path14) => path14.reduce((acc, k) => getProp(acc, k), obj);
 var firstDefined = (obj, ...keys) => {
   if (!obj || typeof obj !== "object") {
     return void 0;
@@ -4901,13 +6777,13 @@ var SessionCapturer = class extends SessionCapturerBase {
     this.patchStreams();
   }
   onWsOpen() {
-    log6.info("\u2713 Worker WebSocket connected to backend");
+    log7.info("\u2713 Worker WebSocket connected to backend");
   }
   onWsError(err) {
-    log6.error(`Couldn't connect to devtools backend: ${errorMessage(err)}`);
+    log7.error(`Couldn't connect to devtools backend: ${errorMessage(err)}`);
   }
   onWsClose() {
-    log6.info("Worker WebSocket disconnected");
+    log7.info("Worker WebSocket disconnected");
   }
   async captureCommand(command, args, result, error, testUid, callSource, timestamp) {
     const serializedError = serializeError(error);
@@ -4928,7 +6804,7 @@ var SessionCapturer = class extends SessionCapturerBase {
     );
     if (isNavigationCommand && this.#browser && !error) {
       this.#capturePerformanceData(commandLogEntry, args).catch((err) => {
-        log6.warn(`Failed to capture performance data: ${errorMessage(err)}`);
+        log7.warn(`Failed to capture performance data: ${errorMessage(err)}`);
       });
     }
     if (this.traceMode === "trace" && !error && this.#browser && mapCommandToAction(command)) {
@@ -4959,6 +6835,37 @@ var SessionCapturer = class extends SessionCapturerBase {
       typeof args[0] === "string" ? args[0] : void 0
     );
   }
+  /**
+   * Ingest a pre-built assertion entry (native `browser.assert`/`verify`
+   * synthesized from Nightwatch's results, or a node:assert capture) into the
+   * same command stream driver commands use. Unlike {@link captureCommand} this
+   * preserves the entry's `title` (the human assertion message) and never
+   * dedups — each call is a distinct action row. Assigns a fresh `_id` and a
+   * matching stable public `id` (so a later `sendReplaceCommand` can update
+   * this exact row in place — native asserts stream a pending row at call time,
+   * then finalize their pass/fail), pushes, and broadcasts.
+   */
+  captureAssertCommand(entry) {
+    const withId = entry;
+    withId._id = this.commandCounter++;
+    withId.id = withId._id;
+    this.commandsLog.push(withId);
+    if (this.traceMode === "trace" && !entry.error && this.#browser && mapCommandToAction(entry.command)) {
+      const browser = this.#browser;
+      this.snapshotCaptures.push(
+        captureActionSnapshot2(
+          browser,
+          entry.command,
+          () => this.takeScreenshotViaHttp(browser)
+        ).then((snap) => {
+          if (snap) {
+            this.actionSnapshots.push(snap);
+          }
+        })
+      );
+    }
+    this.sendCommand(withId);
+  }
   /**
    * Replace an already-captured command entry (used for retried commands so
    * only the final execution result is shown in the UI).
@@ -5018,38 +6925,38 @@ var SessionCapturer = class extends SessionCapturerBase {
           try {
             const value = JSON.parse(body).value || null;
             if (!value) {
-              log6.warn(`[screenshot] Empty response from ${endpoint}`);
+              log7.warn(`[screenshot] Empty response from ${endpoint}`);
             }
             resolve2(value);
           } catch {
-            log6.warn(`[screenshot] Failed to parse response from ${endpoint}`);
+            log7.warn(`[screenshot] Failed to parse response from ${endpoint}`);
             resolve2(null);
           }
         });
       });
       req.on("error", (err) => {
-        log6.warn(
+        log7.warn(
           `[screenshot] HTTP request failed (${endpoint}): ${errorMessage(err)}`
         );
         resolve2(null);
       });
       req.setTimeout(5e3, () => {
-        log6.warn(`[screenshot] Request timed out (${endpoint})`);
+        log7.warn(`[screenshot] Request timed out (${endpoint})`);
         req.destroy();
         resolve2(null);
       });
     });
   }
   onSourceReadError(filePath, err) {
-    log6.warn(`Failed to read source file ${filePath}: ${errorMessage(err)}`);
+    log7.warn(`Failed to read source file ${filePath}: ${errorMessage(err)}`);
   }
   onUpstreamDrop(event, reason, err) {
     if (reason === "send-error") {
-      log6.warn(`[upstream] Failed to send "${event}": ${errorMessage(err)}`);
+      log7.warn(`[upstream] Failed to send "${event}": ${errorMessage(err)}`);
       return;
     }
     if (this.hasEverConnected()) {
-      log6.warn(`[upstream] WebSocket not open \u2014 dropping "${event}" event`);
+      log7.warn(`[upstream] WebSocket not open \u2014 dropping "${event}" event`);
     }
   }
   /**
@@ -5072,12 +6979,12 @@ var SessionCapturer = class extends SessionCapturerBase {
         return unwrapDriverValue(checkResult) === true;
       });
       if (hasCollector) {
-        log6.info("\u2713 Script injected and collector ready");
+        log7.info("\u2713 Script injected and collector ready");
       } else {
-        log6.warn("Script injection may have failed \u2014 collector not found");
+        log7.warn("Script injection may have failed \u2014 collector not found");
       }
     } catch (err) {
-      log6.error(`Failed to inject script: ${errorMessage(err)}`);
+      log7.error(`Failed to inject script: ${errorMessage(err)}`);
       throw err;
     }
   }
@@ -5131,7 +7038,7 @@ var SessionCapturer = class extends SessionCapturerBase {
     } catch (err) {
       const msg = errorMessage(err) ?? "";
       if (!msg.includes("log type") && !msg.includes("performance")) {
-        log6.warn(`Performance log capture failed: ${msg}`);
+        log7.warn(`Performance log capture failed: ${msg}`);
       }
     }
   }
@@ -5158,10 +7065,10 @@ var SessionCapturer = class extends SessionCapturerBase {
         traceData.mutations
       ) ? traceData.mutations.length : 0;
       if (mutationCount > 0) {
-        log6.info(`[trace] Captured ${mutationCount} DOM mutation(s)`);
+        log7.info(`[trace] Captured ${mutationCount} DOM mutation(s)`);
       }
     } catch (err) {
-      log6.error(
+      log7.error(
         `Failed to capture trace from injected script: ${errorMessage(err)}`
       );
     }
@@ -5169,12 +7076,17 @@ var SessionCapturer = class extends SessionCapturerBase {
 };
 
 // src/reporter.ts
-import logger7 from "@wdio/logger";
-var log7 = logger7("@wdio/nightwatch-devtools:Reporter");
+import logger8 from "@wdio/logger";
+var log8 = logger8("@wdio/nightwatch-devtools:Reporter");
 var TestReporter = class extends TestReporterBase {
   #currentSpecFile;
   #testNamesCache = /* @__PURE__ */ new Map();
   #currentSuite;
+  #attemptFor;
+  constructor(report, attemptFor) {
+    super(report);
+    this.#attemptFor = attemptFor;
+  }
   onSuiteStart(suiteStats) {
     this.#currentSpecFile = suiteStats.file;
     this.#currentSuite = suiteStats;
@@ -5187,7 +7099,7 @@ var TestReporter = class extends TestReporterBase {
       const testNames = rerunLabel ? metadata.testNames.filter((name) => name === rerunLabel) : metadata.testNames;
       if (testNames.length > 0) {
         this.#testNamesCache.set(this.#currentSpecFile, testNames);
-        log7.info(
+        log8.info(
           `\u{1F4DD} Extracted ${testNames.length} test names from ${this.#currentSpecFile}`
         );
       }
@@ -5235,11 +7147,12 @@ var TestReporter = class extends TestReporterBase {
     );
     cachedNames.forEach((testName) => {
       if (!processedTestNames.has(testName)) {
+        const uid = generateStableUid2({
+          file: suiteStats.file,
+          fullTitle: `${suiteStats.title} ${testName}`
+        });
         const skippedTest = {
-          uid: generateStableUid2({
-            file: suiteStats.file,
-            fullTitle: `${suiteStats.title} ${testName}`
-          }),
+          uid,
           cid: DEFAULTS.CID,
           title: testName,
           fullTitle: `${suiteStats.title} ${testName}`,
@@ -5249,12 +7162,12 @@ var TestReporter = class extends TestReporterBase {
           end: /* @__PURE__ */ new Date(),
           type: "test",
           file: suiteStats.file,
-          retries: DEFAULTS.RETRIES,
+          retries: this.#attemptFor(uid) ?? DEFAULTS.RETRIES,
           _duration: DEFAULTS.DURATION,
           hooks: []
         };
         suiteStats.tests.push(skippedTest);
-        log7.info(`Created skipped test "${testName}" (never executed)`);
+        log8.info(`Created skipped test "${testName}" (never executed)`);
       }
     });
     this.sendUpstream();
@@ -5273,10 +7186,12 @@ var TestReporter = class extends TestReporterBase {
 
 // src/helpers/testManager.ts
 var TestManager = class {
-  constructor(testReporter) {
+  constructor(testReporter, recordOutcome) {
     this.testReporter = testReporter;
+    this.recordOutcome = recordOutcome;
   }
   testReporter;
+  recordOutcome;
   processedTests = /* @__PURE__ */ new Map();
   lastKnownTestName = null;
   /**
@@ -5299,6 +7214,7 @@ var TestManager = class {
     }
     if (state !== TEST_STATE.RUNNING) {
       this.testReporter.onTestEnd(test);
+      this.recordOutcome?.(test.uid, state);
     }
   }
   /**
@@ -5518,7 +7434,7 @@ var SuiteManager = class {
 };
 
 // src/helpers/browserProxy.ts
-import logger8 from "@wdio/logger";
+import logger10 from "@wdio/logger";
 
 // src/helpers/serializeCommandResult.ts
 function serializeCommandResult(callbackResult, methodName) {
@@ -5551,17 +7467,201 @@ function serializeCommandResult(callbackResult, methodName) {
   return void 0;
 }
 
+// src/helpers/nativeAssertions.ts
+import logger9 from "@wdio/logger";
+var log9 = logger9("@wdio/nightwatch-devtools:nativeAssertions");
+var ASSERT_CMD_RE = /^(assert|verify)\.\w+$/;
+function assertCommandTimings(commands, count) {
+  const executed = commands.filter(
+    (c) => typeof c?.name === "string" && ASSERT_CMD_RE.test(c.name)
+  );
+  if (executed.length !== count) {
+    return new Array(count).fill(null);
+  }
+  return executed.map(
+    (c) => typeof c.startTime === "number" && typeof c.endTime === "number" ? { startTime: c.startTime, endTime: c.endTime } : null
+  );
+}
+function messageMatchesArgs(entry, args) {
+  const text = String(entry.fullMsg ?? entry.message ?? "");
+  const literals = args.filter(
+    (a) => typeof a === "string" || typeof a === "number"
+  );
+  return literals.length > 0 && literals.every((a) => text.includes(String(a)));
+}
+function gatherResultAssertions(results) {
+  const testcases = results?.testcases;
+  if (testcases && typeof testcases === "object") {
+    const all = [];
+    for (const tc of Object.values(testcases)) {
+      if (Array.isArray(tc?.assertions)) {
+        all.push(...tc.assertions);
+      }
+    }
+    if (all.length > 0) {
+      return all;
+    }
+  }
+  return Array.isArray(results?.assertions) ? results.assertions : [];
+}
+function correlate(calls, assertions) {
+  const consumed = new Array(assertions.length).fill(false);
+  const toOutcome = (idx) => {
+    consumed[idx] = true;
+    const entry = assertions[idx];
+    return {
+      passed: !entry.failure,
+      message: stripAnsi(String(entry.fullMsg ?? entry.message ?? "")).trim()
+    };
+  };
+  const matched = calls.map((call) => {
+    const idx = assertions.findIndex(
+      (entry, i) => !consumed[i] && messageMatchesArgs(entry, call.args)
+    );
+    return idx === -1 ? null : toOutcome(idx);
+  });
+  return matched.map((outcome) => {
+    if (outcome) {
+      return outcome;
+    }
+    const idx = consumed.findIndex((used) => !used);
+    return idx === -1 ? null : toOutcome(idx);
+  });
+}
+function latestResolvedScreenshot(capturer) {
+  for (let i = capturer.commandsLog.length - 1; i >= 0; i--) {
+    const shot = capturer.commandsLog[i]?.screenshot;
+    if (shot) {
+      return shot;
+    }
+  }
+  return null;
+}
+async function resolveAssertionScreenshot(capturer, browser) {
+  return latestResolvedScreenshot(capturer) ?? await capturer.takeScreenshotViaHttp(browser);
+}
+function conciseTitle(call) {
+  const preview = call.args.map(
+    (a) => typeof a === "string" ? `'${a}'` : a !== null && typeof a === "object" ? "\u2026" : String(a)
+  ).join(", ");
+  return `${call.prefix}.${call.method}(${preview})`;
+}
+function pendingAssertionCommand(call, testUid, screenshot) {
+  const entry = {
+    command: `${call.prefix}.${call.method}`,
+    args: call.args.map(safeSerializeAssertArg),
+    title: conciseTitle(call),
+    timestamp: call.timestamp,
+    startTime: call.timestamp
+  };
+  if (call.callSource) {
+    entry.callSource = call.callSource;
+  }
+  if (testUid) {
+    entry.testUid = testUid;
+  }
+  if (screenshot) {
+    entry.screenshot = screenshot;
+  }
+  return entry;
+}
+function parseActualFromMessage(message) {
+  const marker = "but got:";
+  const idx = message.lastIndexOf(marker);
+  if (idx === -1) {
+    return void 0;
+  }
+  let rest = message.slice(idx + marker.length).trim();
+  rest = rest.replace(/ \(\d+ms\)$/, "").trim();
+  rest = rest.replace(/^["']/, "").replace(/["']$/, "").trim();
+  return rest || void 0;
+}
+function collapsedAssertResult2(call, outcome) {
+  const result = {
+    passed: outcome.passed,
+    expected: call.args.length <= 1 ? call.args[0] : call.args,
+    message: outcome.message
+  };
+  const actual = outcome.passed ? void 0 : parseActualFromMessage(outcome.message);
+  if (actual !== void 0) {
+    result.actual = actual;
+  }
+  return result;
+}
+function finalizeAssertionRow(capturer, call, outcome, timing, screenshot, testUid) {
+  const entry = call.entry;
+  const finalized = matcherAssertionToCommandLog(
+    {
+      prefix: call.prefix,
+      method: call.method,
+      args: call.args,
+      passed: outcome.passed,
+      message: outcome.message || `${call.prefix}.${call.method} failed`,
+      callSource: call.callSource,
+      title: entry.title
+    },
+    testUid
+  );
+  entry.result = collapsedAssertResult2(call, outcome);
+  entry.error = finalized.error;
+  if (!entry.screenshot && screenshot) {
+    entry.screenshot = screenshot;
+  }
+  if (timing) {
+    entry.startTime = timing.startTime;
+    entry.timestamp = timing.endTime > timing.startTime ? timing.endTime : timing.startTime;
+  }
+  capturer.captureAssertCommand(entry);
+  log9.info(`[assert] ${entry.title} \u2192 ${outcome.passed ? "pass" : "fail"}`);
+}
+async function captureNativeAssertions(capturer, browser, currentTest, testUid, calls) {
+  if (calls.length === 0) {
+    return;
+  }
+  const results = currentTest?.results;
+  const assertions = gatherResultAssertions(results);
+  const outcomes = correlate(calls, assertions);
+  const timings = assertCommandTimings(
+    Array.isArray(results?.commands) ? results.commands : [],
+    calls.length
+  );
+  const screenshot = await resolveAssertionScreenshot(capturer, browser);
+  calls.forEach((call, index) => {
+    if (!call.entry) {
+      return;
+    }
+    const outcome = outcomes[index];
+    if (outcome) {
+      finalizeAssertionRow(
+        capturer,
+        call,
+        outcome,
+        timings[index],
+        screenshot,
+        testUid
+      );
+      return;
+    }
+    if (!call.entry.screenshot && screenshot) {
+      call.entry.screenshot = screenshot;
+    }
+    capturer.captureAssertCommand(call.entry);
+  });
+}
+
 // src/helpers/browserProxy.ts
-var log8 = logger8("@wdio/nightwatch-devtools:browserProxy");
+var log10 = logger10("@wdio/nightwatch-devtools:browserProxy");
 var BrowserProxy = class {
-  constructor(sessionCapturer, testManager, getCurrentTest) {
+  constructor(sessionCapturer, testManager, getCurrentTest, captureAssertions = true) {
     this.sessionCapturer = sessionCapturer;
     this.testManager = testManager;
     this.getCurrentTest = getCurrentTest;
+    this.captureAssertions = captureAssertions;
   }
   sessionCapturer;
   testManager;
   getCurrentTest;
+  captureAssertions;
   /** Tracks which browser *instances* have already been proxied to avoid double-wrapping. */
   proxiedBrowsers = /* @__PURE__ */ new WeakSet();
   commandStack = [];
@@ -5573,6 +7673,14 @@ var BrowserProxy = class {
    * rather than appending, showing only the final execution result.
    */
   retryTracker = new RetryTracker();
+  /**
+   * Per-test buffer of explicit `browser.assert.*` / `browser.verify.*` calls,
+   * recorded synchronously at call time by {@link wrapAssertionNamespaces}.
+   * Nightwatch exposes no per-assertion hook and its test-end results carry no
+   * source location for passing assertions, so call-time capture is the only
+   * way to get real args + callSource. Drained (and cleared) each `afterEach`.
+   */
+  nativeAssertCalls = [];
   /**
    * Update the session capturer reference after a WebDriver session change.
    * Does NOT re-wrap browser methods — wrapping is permanent per browser object.
@@ -5584,12 +7692,98 @@ var BrowserProxy = class {
     this.commandStack = [];
     this.lastCommandSig = null;
     this.retryTracker.reset();
+    this.nativeAssertCalls = [];
+  }
+  /** Hand off this test's recorded native-assertion calls and clear the
+   *  buffer so the next test starts fresh. */
+  drainNativeAssertCalls() {
+    const calls = this.nativeAssertCalls;
+    this.nativeAssertCalls = [];
+    return calls;
+  }
+  /**
+   * Replace `browser.assert` / `browser.verify` (both are Nightwatch Proxies
+   * whose `get` returns a fresh function per access) with a recording Proxy:
+   * on each method call it captures `{prefix, method, args, callSource}` from a
+   * user-code frame, streams a neutral pending row immediately (live), then
+   * delegates to the ORIGINAL namespace method so Nightwatch's queue, chaining,
+   * and abortOnFailure semantics (assert aborts, verify does not) are
+   * byte-for-byte unchanged. Called once per browser.
+   */
+  wrapAssertionNamespaces(browser) {
+    if (!this.captureAssertions) {
+      return;
+    }
+    const b = browser;
+    ["assert", "verify"].forEach((prefix) => {
+      const original = b[prefix];
+      if (!original || typeof original !== "object") {
+        return;
+      }
+      b[prefix] = this.recordingNamespaceProxy(original, prefix, []);
+    });
+  }
+  /**
+   * Recording Proxy over one assert/verify namespace. A function property
+   * becomes a call-time recorder keyed by its full dotted path
+   * (`titleContains`, `not.titleContains`); a nested namespace object recurses
+   * through the SAME wrapper — Nightwatch exposes `assert.not` as its own Proxy,
+   * so negated asserts are recorded via the identical mechanism as positive
+   * ones instead of a parallel path. The recorder buffers a pending row, then
+   * delegates to the ORIGINAL method so Nightwatch's queue, chaining, and
+   * abort/negate semantics stay byte-for-byte unchanged. Non-method,
+   * non-namespace props pass through untouched.
+   */
+  recordingNamespaceProxy(target, prefix, path14) {
+    return new Proxy(target, {
+      get: (t, name, receiver) => {
+        const orig = Reflect.get(t, name, receiver);
+        if (typeof name !== "string") {
+          return orig;
+        }
+        if (orig !== null && typeof orig === "object") {
+          return this.recordingNamespaceProxy(orig, prefix, [...path14, name]);
+        }
+        if (typeof orig !== "function") {
+          return orig;
+        }
+        return (...args) => {
+          const callInfo = getCallSourceFromStack();
+          if (callInfo.filePath !== void 0) {
+            this.emitPendingAssertion({
+              prefix,
+              method: [...path14, name].join("."),
+              args,
+              callSource: callInfo.callSource,
+              timestamp: Date.now()
+            });
+          }
+          return orig(...args);
+        };
+      }
+    });
+  }
+  /** Buffer an explicit assert/verify call at invocation time (prebuilding its
+   *  row with args/callSource/screenshot), but do NOT stream it yet. Nightwatch
+   *  exposes no per-assertion result hook, so streaming here would show every
+   *  assert as a neutral (green) row while the test is still Running — before
+   *  its pass/fail is known. `captureNativeAssertions` emits the rows at test-end
+   *  with real outcomes + execution timing instead. */
+  emitPendingAssertion(call) {
+    const testUid = this.getCurrentTest()?.uid;
+    const entry = pendingAssertionCommand(
+      call,
+      testUid,
+      latestResolvedScreenshot(this.sessionCapturer)
+    );
+    call.entry = entry;
+    this.nativeAssertCalls.push(call);
   }
   getCurrentTestFullPath() {
     return this.currentTestFullPath;
   }
-  setCurrentTestFullPath(path10) {
-    this.currentTestFullPath = path10;
+  setCurrentTestFullPath(path14) {
+    this.currentTestFullPath = path14;
   }
   /**
    * Wrap browser navigation methods (url / navigate / navigateTo) to inject
@@ -5610,9 +7804,9 @@ var BrowserProxy = class {
       b[methodName] = function(...args) {
         const result = original(...args);
         const injectAndCapture = () => {
-          log8.info(`[nav] ${methodName}(${args[0] ?? ""}) \u2014 injecting script`);
+          log10.info(`[nav] ${methodName}(${args[0] ?? ""}) \u2014 injecting script`);
           return sessionCapturer.injectScript(browser).then(() => sessionCapturer.captureTrace(browser)).catch(
-            (err) => log8.error(`Failed to inject script: ${err.message}`)
+            (err) => log10.error(`Failed to inject script: ${err.message}`)
           );
         };
         const chainable = result;
@@ -5629,7 +7823,7 @@ var BrowserProxy = class {
     wrapNav("url");
     wrapNav("navigate");
     wrapNav("navigateTo");
-    log8.info("\u2713 Script injection wrapped");
+    log10.info("\u2713 Script injection wrapped");
   }
   wrapBrowserCommands(browser) {
     if (this.proxiedBrowsers.has(browser)) {
@@ -5662,8 +7856,9 @@ var BrowserProxy = class {
       };
       wrappedMethods.push(methodName);
     });
+    this.wrapAssertionNamespaces(browser);
     this.proxiedBrowsers.add(browser);
-    log8.info(`\u2713 Wrapped ${wrappedMethods.length} browser methods`);
+    log10.info(`\u2713 Wrapped ${wrappedMethods.length} browser methods`);
   }
   handleRetryReplacement(browser, methodName, logArgs, serializedResult, effectiveUid, callSource, commandTimestamp) {
     const { entry, oldTimestamp } = this.sessionCapturer.replaceCommand(
@@ -5692,13 +7887,13 @@ var BrowserProxy = class {
       callSource,
       commandTimestamp
     ).catch(
-      (err) => log8.error(`Failed to capture ${methodName}: ${err.message}`)
+      (err) => log10.error(`Failed to capture ${methodName}: ${err.message}`)
     );
     const lastCommand = this.sessionCapturer.commandsLog[this.sessionCapturer.commandsLog.length - 1];
     if (lastCommand) {
       this.retryTracker.setLastId(lastCommand._id ?? null);
       this.sessionCapturer.sendCommand(lastCommand);
-      log8.info(`[command] ${methodName}`);
+      log10.info(`[command] ${methodName}`);
       this.attachScreenshot(browser, lastCommand, methodName);
     }
     this.maybeRepollMutations(browser, methodName);
@@ -5735,7 +7930,7 @@ var BrowserProxy = class {
   }
   // Result-capturing callback factory — called by Nightwatch's async queue
   // when the command completes. This is where we get the *actual* result.
-  makeCaptureCallback(browser, methodName, logArgs, cmdSig, callSource, commandTimestamp, testUid, userCallback) {
+  makeCaptureCallback(browser, methodName, logArgs, cmdSig, callSource, hasUserSource, commandTimestamp, testUid, userCallback) {
     return (callbackResult) => {
       this.popCommandStackIfMatches(methodName, cmdSig);
       const serializedResult = serializeCommandResult(
@@ -5743,7 +7938,7 @@ var BrowserProxy = class {
         methodName
       );
       const effectiveUid = this.getCurrentTest()?.uid ?? testUid;
-      if (effectiveUid) {
+      if (effectiveUid && hasUserSource) {
         if (this.retryTracker.isRetry(cmdSig)) {
           this.handleRetryReplacement(
             browser,
@@ -5811,6 +8006,7 @@ var BrowserProxy = class {
       logArgs,
       cmdSig,
       callSource,
+      callInfo.filePath !== void 0,
       commandTimestamp,
       this.getCurrentTest()?.uid,
       userCallback
@@ -5830,7 +8026,7 @@ var BrowserProxy = class {
       return;
     }
     const normalizedError = toError(error);
-    log8.error(`[command error] ${methodName}: ${normalizedError.message}`);
+    log10.error(`[command error] ${methodName}: ${normalizedError.message}`);
     this.sessionCapturer.captureCommand(
       methodName,
       args,
@@ -5839,7 +8035,7 @@ var BrowserProxy = class {
       currentTest.uid,
       callSource
     ).catch(
-      (err) => log8.error(`Failed to capture ${methodName}: ${err.message}`)
+      (err) => log10.error(`Failed to capture ${methodName}: ${err.message}`)
     );
     const lastCommand = this.sessionCapturer.commandsLog[this.sessionCapturer.commandsLog.length - 1];
     if (lastCommand) {
@@ -5862,7 +8058,7 @@ var BrowserProxy = class {
       if (screenshot) {
         entry.screenshot = screenshot;
         this.sessionCapturer.sendReplaceCommand(ts, entry);
-        log8.info(`[screenshot] Attached to ${methodName}${suffix}`);
+        log10.info(`[screenshot] Attached to ${methodName}${suffix}`);
       }
     }).catch(() => {
     });
@@ -5870,8 +8066,8 @@ var BrowserProxy = class {
 };
 
 // src/screencast.ts
-import logger9 from "@wdio/logger";
-var log9 = logger9("@wdio/nightwatch-devtools:ScreencastRecorder");
+import logger11 from "@wdio/logger";
+var log11 = logger11("@wdio/nightwatch-devtools:ScreencastRecorder");
 var ScreencastRecorder = class extends ScreencastRecorderBase {
   #sessionCapturer;
   constructor(sessionCapturer, options) {
@@ -5879,15 +8075,15 @@ var ScreencastRecorder = class extends ScreencastRecorderBase {
     this.#sessionCapturer = sessionCapturer;
   }
   onPollingStarted(intervalMs) {
-    log9.info(
+    log11.info(
       `\u2713 Screencast recording started (polling mode, ${intervalMs} ms interval)`
     );
   }
   onPollingStopped(frameCount) {
-    log9.info(`\u2713 Screencast stopped \u2014 ${frameCount} frame(s) collected`);
+    log11.info(`\u2713 Screencast stopped \u2014 ${frameCount} frame(s) collected`);
   }
   onUnavailable(err) {
-    log9.warn(
+    log11.warn(
       `Screencast unavailable (${errorMessage(err)}). Recording skipped.`
     );
   }
@@ -5901,9 +8097,9 @@ var ScreencastRecorder = class extends ScreencastRecorderBase {
 };
 
 // src/session-init.ts
-var log10 = logger10("@wdio/nightwatch-devtools:session-init");
+var log12 = logger12("@wdio/nightwatch-devtools:session-init");
 async function handleSessionChange(ctx, finalizeCurrent) {
-  log10.info("Browser session changed \u2014 reconnecting WebSocket only");
+  log12.info("Browser session changed \u2014 reconnecting WebSocket only");
   ctx.isScriptInjected = false;
   ctx.bidiAttachAttempted = false;
   await finalizeCurrent();
@@ -5911,17 +8107,24 @@ async function handleSessionChange(ctx, finalizeCurrent) {
   ctx.sessionCapturer = null;
 }
 function initReporterChain(ctx) {
-  ctx.testReporter = new TestReporter((suitesData) => {
-    if (ctx.sessionCapturer) {
-      ctx.sessionCapturer.sendUpstream("suites", suitesData);
-    }
-  });
-  ctx.testManager = new TestManager(ctx.testReporter);
+  ctx.testReporter = new TestReporter(
+    (suitesData) => {
+      if (ctx.sessionCapturer) {
+        ctx.sessionCapturer.sendUpstream("suites", suitesData);
+      }
+    },
+    (uid) => ctx.attemptFor(uid)
+  );
+  ctx.testManager = new TestManager(
+    ctx.testReporter,
+    (uid, state) => ctx.recordOutcome(uid, state)
+  );
   ctx.suiteManager = new SuiteManager(ctx.testReporter);
   ctx.browserProxy = new BrowserProxy(
     ctx.sessionCapturer,
     ctx.testManager,
-    () => ctx.getCurrentTest() ?? ctx.getCurrentScenarioSuite()
+    () => ctx.getCurrentTest() ?? ctx.getCurrentScenarioSuite(),
+    ctx.captureAssertions
   );
 }
 function rebindReporterToNewSession(ctx) {
@@ -5956,12 +8159,12 @@ function broadcastSessionMetadata(ctx, browser) {
   ctx.sessionCapturer.sendUpstream("metadata", metadata);
   const browserName = capabilities.browserName || desiredCapabilities.browserName || "unknown";
   const browserVersion = capabilities.browserVersion || capabilities.version || "";
-  log10.info(
+  log12.info(
     `\u2713 Browser: ${browserName}${browserVersion ? " " + browserVersion : ""} (session: ${sessionId})`
   );
   const loggingPrefs = capabilities["goog:loggingPrefs"] || desiredCapabilities["goog:loggingPrefs"] || {};
   if (!loggingPrefs.performance && !ctx.bidiEnabled) {
-    log10.warn(
+    log12.warn(
       "\u26A0  Network tab will be empty \u2014 add 'goog:loggingPrefs': { performance: 'ALL' } to your capabilities (or enable bidi:true)"
     );
   }
@@ -5973,17 +8176,17 @@ async function tryAttachBidi(ctx, browser) {
   ctx.bidiAttachAttempted = true;
   const driver = browser.driver;
   if (!driver) {
-    log10.warn("bidi:true set but browser.driver unavailable \u2014 skipping");
+    log12.warn("bidi:true set but browser.driver unavailable \u2014 skipping");
     return;
   }
-  const { attachBidiHandlers, buildBidiSinks } = await import("./bidi-FIHBBGT4.js");
+  const { attachBidiHandlers, buildBidiSinks } = await import("./bidi-5ALZJJNC.js");
   const ok = await attachBidiHandlers(
     driver,
     buildBidiSinks(ctx.sessionCapturer)
   );
   if (ok) {
     ctx.sessionCapturer.bidiActive = true;
-    log10.info("\u2713 BiDi attached \u2014 perf-log network capture disabled");
+    log12.info("\u2713 BiDi attached \u2014 perf-log network capture disabled");
   }
 }
 async function tryStartScreencast(ctx, browser, sessionId) {
@@ -5995,7 +8198,7 @@ async function tryStartScreencast(ctx, browser, sessionId) {
     ctx.screencastOptions
   );
   ctx.screencastSessionId = sessionId;
-  log10.info(`\u{1F3AC} Starting screencast for session ${sessionId}`);
+  log12.info(`\u{1F3AC} Starting screencast for session ${sessionId}`);
   await ctx.screencastRecorder.start(browser);
 }
 async function ensureSessionInitialized(ctx, browser, finalizeCurrentScreencast2) {
@@ -6025,7 +8228,7 @@ async function ensureSessionInitialized(ctx, browser, finalizeCurrentScreencast2
   if (ctx.mode !== "trace") {
     const connected = await ctx.sessionCapturer.waitForConnection(3e3);
     if (!connected) {
-      log10.error("\u274C Worker WebSocket failed to connect!");
+      log12.error("\u274C Worker WebSocket failed to connect!");
     }
   }
   if (!ctx.testReporter) {
@@ -6041,24 +8244,28 @@ async function finalizeCurrentScreencast(ctx) {
   if (!ctx.screencastRecorder || !ctx.screencastSessionId) {
     return;
   }
-  await finalizeScreencast({
-    recorder: ctx.screencastRecorder,
-    sessionId: ctx.screencastSessionId,
-    filenamePrefix: "nightwatch-video",
-    outputDir: resolveAdapterOutputDir({
-      testFilePath: ctx.browserProxy?.getCurrentTestFullPath?.() ?? void 0,
-      configPath: ctx.configPath
-    }),
-    captureFormat: ctx.screencastOptions.captureFormat,
-    sendUpstream: (scope, data) => ctx.sessionCapturer?.sendUpstream(scope, data),
-    onLog: (level, message) => log10[level](message)
-  });
+  if (ctx.mode === "trace") {
+    await ctx.screencastRecorder.stop();
+  } else {
+    await finalizeScreencast({
+      recorder: ctx.screencastRecorder,
+      sessionId: ctx.screencastSessionId,
+      filenamePrefix: "nightwatch-video",
+      outputDir: resolveAdapterOutputDir({
+        testFilePath: ctx.browserProxy?.getCurrentTestFullPath?.() ?? void 0,
+        configPath: ctx.configPath
+      }),
+      captureFormat: ctx.screencastOptions.captureFormat,
+      sendUpstream: (scope, data) => ctx.sessionCapturer?.sendUpstream(scope, data),
+      onLog: (level, message) => log12[level](message)
+    });
+  }
   ctx.screencastRecorder = void 0;
   ctx.screencastSessionId = void 0;
 }
 
 // src/index.ts
-var log11 = logger11("@wdio/nightwatch-devtools");
+var log13 = logger13("@wdio/nightwatch-devtools");
 var NightwatchDevToolsPlugin = class {
   options;
   sessionCapturer;
@@ -6083,30 +8290,60 @@ var NightwatchDevToolsPlugin = class {
   #specRanges = [];
   /** Set of spec files already flushed to disk. */
   #flushedSpecs = /* @__PURE__ */ new Set();
+  /** Every trace/video artifact seen this run (retained or not), for the
+   *  end-of-run artifacts manifest. Populated via the context's onArtifact. */
+  #artifacts = [];
+  /** In-flight fire-and-forget eager/boundary slice flushes, awaited at finalize
+   *  so the last slice's write + its manifest entry land before teardown. */
+  #traceFlushes = [];
   #getRerunLabel() {
     return process.env[REUSE_ENV.RERUN_ENTRY_TYPE] === "test" ? process.env[REUSE_ENV.RERUN_LABEL]?.trim() : void 0;
   }
   #screencastOptions;
   #screencastRecorder;
   #screencastSessionId;
+  // Snapshotted before each recorder is nulled, so the export isn't blank.
+  #filmstripFrames = [];
   #bidiEnabled = false;
   #bidiAttachAttempted = false;
+  /** Wall-clock ms at the current test/scenario start — the lower bound of that
+   *  test's action-snapshot and video-frame window (per-test artifact slicing). */
+  #currentTestStartWallTime = 0;
+  // Nightwatch `--retries` and cross-worker reruns may reset this in-process
+  // tracker; only retries that re-enter this process's start hook are counted.
+  #attemptTracker = new TestAttemptTracker();
   constructor(options = {}) {
     const mode = options.mode ?? "live";
-    const ignore = mode === "trace" && options.screencast?.enabled === true;
+    const wantRecorder = mode === "trace" && (options.filmstrip === true || options.video !== void 0 && options.video !== "off");
+    const ignore = mode === "trace" && !wantRecorder && options.screencast?.enabled === true;
     if (ignore) {
-      log11.warn("trace mode: ignoring screencast option (live-mode feature)");
+      log13.warn("trace mode: ignoring screencast option (live-mode feature)");
+    }
+    let screencast = ignore ? {} : options.screencast ?? {};
+    if (wantRecorder) {
+      screencast = { ...options.screencast ?? {}, enabled: true };
     }
-    const screencast = ignore ? {} : options.screencast ?? {};
     this.options = {
       port: options.port ?? 3e3,
       hostname: options.hostname ?? "localhost",
       screencast,
       bidi: options.bidi ?? false,
+      captureAssertions: options.captureAssertions ?? true,
       mode,
       traceFormat: options.traceFormat ?? "zip",
-      traceGranularity: options.traceGranularity ?? "session"
+      traceGranularity: options.traceGranularity ?? "session",
+      tracePolicy: options.tracePolicy ?? "on",
+      filmstrip: options.filmstrip ?? true,
+      screenshot: options.screenshot ?? "off",
+      video: options.video ?? "off",
+      // No live Allure signal in Nightwatch (produce-only), so no auto-detect:
+      // off by default, opt-in via the option.
+      emitArtifactsManifest: options.emitArtifactsManifest ?? false
     };
+    const policyWarning = tracePolicyModeWarning(options.tracePolicy, mode);
+    if (policyWarning) {
+      log13.warn(policyWarning);
+    }
     this.#screencastOptions = { ...SCREENCAST_DEFAULTS, ...screencast };
     this.#bidiEnabled = options.bidi === true;
   }
@@ -6140,6 +8377,9 @@ var NightwatchDevToolsPlugin = class {
       get bidiEnabled() {
         return self.#bidiEnabled;
       },
+      get captureAssertions() {
+        return self.options.captureAssertions;
+      },
       get sessionCapturer() {
         return self.sessionCapturer;
       },
@@ -6254,7 +8494,11 @@ var NightwatchDevToolsPlugin = class {
       clearExecutionData: () => {
         self.testReporter.clearExecutionData();
         self.suiteManager.clearExecutionData();
+        self.#attemptTracker.reset();
       },
+      recordAttempt: (uid, specFile) => self.#attemptTracker.recordStart(uid, specFile),
+      recordOutcome: (uid, state) => self.#attemptTracker.recordOutcome(uid, state),
+      attemptFor: (uid) => self.#attemptTracker.attemptFor(uid),
       buildMetadataOptions: () => self.#buildMetadataOptions(),
       ensureSessionInitialized: (b) => self.#ensureSessionInitialized(b),
       wrapBrowserOnce: (b) => self.#wrapBrowserOnce(b),
@@ -6263,10 +8507,28 @@ var NightwatchDevToolsPlugin = class {
       setCucumberRunner: (v) => {
         self.#isCucumberRunner = v;
       },
-      getRerunLabel: () => self.#getRerunLabel()
+      getRerunLabel: () => self.#getRerunLabel(),
+      get traceMode() {
+        return self.options.mode === "trace";
+      },
+      get traceGranularity() {
+        return self.options.traceGranularity;
+      },
+      get specRanges() {
+        return self.#specRanges;
+      },
+      get flushedSpecs() {
+        return self.#flushedSpecs;
+      },
+      flushTraceRange: (range) => self.#flushSpecTrace(range),
+      emitTestArtifacts: (uid, failed) => self.#emitTestArtifacts(uid, failed)
     };
     return this.#internals;
   }
+  /** Boundary cast: currentTest is Nightwatch's loose bag; only uid is read. */
+  #currentTestUid() {
+    return this.#currentTest?.uid;
+  }
   #handleReuseMode() {
     handleReuseMode(this.#getInternals());
   }
@@ -6282,6 +8544,12 @@ var NightwatchDevToolsPlugin = class {
     internals.handleReuse = () => this.#handleReuseMode();
     internals.plugin = this;
     await runPluginBefore(internals);
+    if (this.options.captureAssertions) {
+      wireAssertCapture(
+        () => this.sessionCapturer,
+        () => this.#currentTestUid()
+      );
+    }
   }
   async #ensureSessionInitialized(browser) {
     await ensureSessionInitialized(
@@ -6291,9 +8559,13 @@ var NightwatchDevToolsPlugin = class {
     );
   }
   async #finalizeCurrentScreencast() {
+    if ((this.options.filmstrip || this.options.video !== "off") && this.#screencastRecorder) {
+      this.#filmstripFrames.push(...this.#screencastRecorder.frames);
+    }
     await finalizeCurrentScreencast(this.#getInternals());
   }
   async cucumberBefore(browser, pickle) {
+    this.#currentTestStartWallTime = Date.now();
     await cucumberBefore(this.#getInternals(), browser, pickle);
   }
   async cucumberAfter(browser, result, pickle) {
@@ -6322,12 +8594,13 @@ var NightwatchDevToolsPlugin = class {
   #pickCurrentTestName(currentTest, testNames, processedTests) {
     return pickCurrentTestName(currentTest, testNames, processedTests);
   }
-  async #startNextTest(currentSuite, currentTestName, processedTests) {
+  async #startNextTest(currentSuite, currentTestName, processedTests, specFile) {
     await startNextTest(
       this.#getInternals(),
       currentSuite,
       currentTestName,
-      processedTests
+      processedTests,
+      specFile
     );
   }
   async #closePreviousRunningTest(currentSuite, testFile, currentTest) {
@@ -6345,6 +8618,7 @@ var NightwatchDevToolsPlugin = class {
     if (this.#isCucumberRunner) {
       return;
     }
+    this.#currentTestStartWallTime = Date.now();
     await this.#ensureSessionInitialized(browser);
     const currentTest = browser.currentTest;
     if (!currentTest) {
@@ -6364,23 +8638,7 @@ var NightwatchDevToolsPlugin = class {
       });
     }
     if (fullPath) {
-      const prevRange = recordSpecBoundary(
-        {
-          specRanges: this.#specRanges,
-          flushedSpecs: this.#flushedSpecs,
-          capturer: this.sessionCapturer,
-          actionSnapshots: this.sessionCapturer.actionSnapshots
-        },
-        fullPath,
-        this.options.traceGranularity
-      );
-      if (prevRange) {
-        void this.#flushSpecTrace(prevRange).catch(
-          (err) => log11.warn(
-            `Failed to flush trace for spec "${prevRange.specFile}": ${errorMessage(err)}`
-          )
-        );
-      }
+      recordSpecSliceBoundary(this.#getInternals(), fullPath);
     }
     await this.#closePreviousRunningTest(currentSuite, testFile, currentTest);
     const processedTests = this.testManager.getProcessedTests(testFile);
@@ -6390,7 +8648,12 @@ var NightwatchDevToolsPlugin = class {
       processedTests
     );
     if (currentTestName) {
-      await this.#startNextTest(currentSuite, currentTestName, processedTests);
+      await this.#startNextTest(
+        currentSuite,
+        currentTestName,
+        processedTests,
+        fullPath
+      );
     }
     this.#wrapBrowserOnce(browser);
   }
@@ -6401,36 +8664,81 @@ var NightwatchDevToolsPlugin = class {
     if (browser && this.sessionCapturer) {
       try {
         await this.#closeOutTestcases(browser);
+        if (this.options.captureAssertions) {
+          await captureNativeAssertions(
+            this.sessionCapturer,
+            browser,
+            browser.currentTest,
+            this.#currentTestUid(),
+            this.browserProxy.drainNativeAssertCalls()
+          );
+        }
         await this.sessionCapturer.captureTrace(browser);
+        flushTestSlice(this.#getInternals());
+        const results = browser.currentTest?.results;
+        const failed = !!results && ((results.errors ?? 0) > 0 || (results.failed ?? 0) > 0);
+        await this.#emitTestArtifacts(this.#currentTestUid(), failed);
       } catch (err) {
-        log11.error(`Failed to capture trace: ${errorMessage(err)}`);
+        log13.error(`Failed to capture trace: ${errorMessage(err)}`);
       }
     }
   }
   async #closeOutTestcases(browser) {
     await closeOutTestcases(this.#getInternals(), browser);
   }
+  /** Directory for produced artifacts — next to the test file, else the config,
+   *  else cwd (mirrors #traceContext's resolution). */
+  get #outputDir() {
+    return resolveAdapterOutputDir({
+      testFilePath: this.browserProxy?.getCurrentTestFullPath?.() ?? void 0,
+      configPath: this.#configPath
+    });
+  }
+  /** Produce (never attach — no live Allure API) this test's per-test screenshot
+   *  and video slice. No-op outside trace mode + `test` granularity (core-gated).
+   *  Shared by the per-test `afterEach` and the cucumber per-scenario finalize. */
+  async #emitTestArtifacts(uid, failed) {
+    const attempt = uid ? this.#attemptTracker.attemptFor(uid) : void 0;
+    await emitTestArtifacts({
+      mode: this.options.mode,
+      granularity: this.options.traceGranularity,
+      screenshotPolicy: this.options.screenshot,
+      videoPolicy: this.options.video,
+      failed,
+      actionSnapshots: this.sessionCapturer.actionSnapshots,
+      frames: this.#screencastRecorder?.frames ?? this.#filmstripFrames,
+      startWallTime: this.#currentTestStartWallTime,
+      outcomes: uid ? this.#attemptTracker.forTest(uid, attempt) : [],
+      uid,
+      attempt,
+      sessionId: this.sessionCapturer?.metadata?.sessionId,
+      outputDir: this.#outputDir,
+      captureFormat: this.#screencastOptions.captureFormat,
+      onArtifact: (a) => this.#artifacts.push(a),
+      onLog: (level, msg) => log13[level](msg)
+    });
+  }
   async after(browser) {
     await this.#finalizeCurrentScreencast();
     try {
       await this.#finalizeAllSuites(browser);
       this.#logRunSummary();
       if (this.options.mode === "trace") {
-        await this.#writeTraceZipIfNeeded();
+        await this.#writeTraceIfNeeded();
         await this.sessionCapturer?.closeWebSocket();
         await stopBackend();
         return;
       }
       if (!this.#devtoolsBrowser) {
         this.testReporter?.updateSuites();
-        log11.info("\u267B  Rerun complete \u2014 flushing WebSocket...");
+        log13.info("\u267B  Rerun complete \u2014 flushing WebSocket...");
         await this.sessionCapturer?.closeWebSocket();
         return;
       }
-      log11.info("\u{1F4A1} Please close the DevTools browser window to finish...");
+      log13.info("\u{1F4A1} Please close the DevTools browser window to finish...");
       await this.#waitForDevtoolsBrowserClose();
     } catch (err) {
-      log11.error(`Failed to stop backend: ${errorMessage(err)}`);
+      log13.error(`Failed to stop backend: ${errorMessage(err)}`);
     }
   }
   async #finalizeAllSuites(browser) {
@@ -6439,90 +8747,56 @@ var NightwatchDevToolsPlugin = class {
   #logRunSummary() {
     logRunSummary(this.#getInternals());
   }
-  async #flushSpecTrace(range, nextRange) {
-    if (this.#flushedSpecs.has(range.specFile)) {
-      return void 0;
-    }
-    this.#flushedSpecs.add(range.specFile);
+  /** Thin wrapper so boundary flushes and the final flush share one path.
+   *  flushRangeLogged logs+swallows a failed flush (shared spec/test string) so
+   *  the fire-and-forget boundary callers don't each re-implement the guard. */
+  #flushSpecTrace(range) {
     const sessionId = this.sessionCapturer.metadata?.sessionId;
     if (!sessionId) {
-      return void 0;
-    }
-    const allMetadata = /* @__PURE__ */ new Map();
-    if (this.suiteManager) {
-      for (const suite of this.suiteManager.getAllSuites().values()) {
-        for (const entry of suite.tests) {
-          if (typeof entry === "string") {
-            continue;
-          }
-          allMetadata.set(entry.uid, {
-            title: entry.fullTitle,
-            specFile: entry.file
-          });
-        }
-      }
+      return Promise.resolve(void 0);
     }
-    const tracePath = await writeSpecTrace({
-      range,
-      nextRange,
-      capturer: this.sessionCapturer,
-      actionSnapshots: this.sessionCapturer.actionSnapshots,
-      sessionId,
-      outputDir: resolveAdapterOutputDir({ configPath: this.#configPath }),
-      format: this.options.traceFormat,
-      testMetadata: allMetadata
-    });
-    log11.info(`Trace for spec "${range.specFile}" saved to ${tracePath}`);
-    return tracePath;
+    const flush = flushRangeLogged(this.#traceContext(sessionId), range);
+    this.#traceFlushes.push(flush);
+    return flush;
   }
-  async #writeTraceZipIfNeeded() {
-    if (this.options.mode !== "trace" || !this.sessionCapturer) {
-      return;
-    }
-    const sessionId = this.sessionCapturer.metadata?.sessionId;
-    if (!sessionId) {
-      return;
-    }
-    try {
-      if (this.sessionCapturer.snapshotCaptures.length) {
-        await Promise.allSettled(this.sessionCapturer.snapshotCaptures);
-      }
-      if (this.options.traceGranularity === "spec") {
-        for (const range of this.#specRanges) {
-          if (!this.#flushedSpecs.has(range.specFile)) {
-            await this.#flushSpecTrace(range);
-          }
-        }
-        return;
-      }
-      const testMetadata = /* @__PURE__ */ new Map();
-      if (this.suiteManager) {
-        for (const suite of this.suiteManager.getAllSuites().values()) {
-          for (const entry of suite.tests) {
-            if (typeof entry === "string") {
-              continue;
-            }
-            testMetadata.set(entry.uid, {
-              title: entry.fullTitle,
-              specFile: entry.file
-            });
-          }
-        }
-      }
-      const snapshots = this.sessionCapturer.actionSnapshots;
-      const tracePath = await writeTraceZip(this.sessionCapturer, {
-        outputDir: resolveAdapterOutputDir({
-          configPath: this.#configPath
-        }),
-        sessionId,
-        actionSnapshots: snapshots.length ? snapshots : void 0,
+  /** Assemble the framework-agnostic trace-export context from plugin state.
+   *  Output dir ignores the spec range — nightwatch writes next to config. */
+  #traceContext(sessionId) {
+    return buildTraceContext(
+      {
+        mode: this.options.mode,
+        policy: this.options.tracePolicy,
+        granularity: this.options.traceGranularity,
         format: this.options.traceFormat,
-        testMetadata
-      });
-      log11.info(`Trace saved to ${tracePath}`);
-    } catch (err) {
-      log11.warn(`trace write failed: ${errorMessage(err)}`);
+        capturer: this.sessionCapturer,
+        suites: this.suiteManager.getAllSuites().values(),
+        outcomes: this.#attemptTracker,
+        ranges: this.#specRanges,
+        flushed: this.#flushedSpecs,
+        artifacts: this.#artifacts,
+        traceFlushes: this.#traceFlushes,
+        emitArtifactsManifest: this.options.emitArtifactsManifest,
+        // Accumulated (finalized-session) frames plus the live recorder's — a
+        // mid-run per-spec/per-test flush fires before the recorder is drained
+        // into #filmstripFrames, so its frames live only on the recorder still;
+        // at the final write the recorder is already nulled, so no double-count.
+        screencastFrames: this.options.filmstrip ? [
+          ...this.#filmstripFrames,
+          ...this.#screencastRecorder?.frames ?? []
+        ] : void 0,
+        configPath: this.#configPath,
+        testFilePath: this.browserProxy?.getCurrentTestFullPath?.() ?? void 0,
+        log: (level, msg) => log13[level](msg)
+      },
+      sessionId
+    );
+  }
+  async #writeTraceIfNeeded() {
+    const sessionId = this.sessionCapturer?.metadata?.sessionId;
+    if (this.options.mode !== "trace" || !this.sessionCapturer || !sessionId) {
+      return;
     }
+    await finalizeTraceExport(this.#traceContext(sessionId));
   }
   async #waitForDevtoolsBrowserClose() {
     await waitForDevtoolsBrowserClose(this.#getInternals());